diff mbox series

[v3] elf: Avoid nested functions in the loader (all ports) [BZ #27220]

Message ID 20210924204917.1618743-1-maskray@google.com
State Superseded
Headers show
Series [v3] elf: Avoid nested functions in the loader (all ports) [BZ #27220] | expand

Checks

Context Check Description
dj/TryBot-apply_patch success Patch applied to master at the time it was sent
dj/TryBot-32bit fail Patch caused testsuite regressions

Commit Message

Fangrui Song Sept. 24, 2021, 8:49 p.m. UTC
[Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
This version fixes all ports and doesn't add NESTING dispatches.]
[Available at
https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]

dynamic-link.h is included more than once in some elf/ files (rtld.c,
dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
functions. This harms readability and the nested functions usage
is the biggest obstacle prevents CC=clang (which doesn't support the
feature).

The key idea for unnesting is to add extra parameters (link_map * and
r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
implementation in the google/grte/v5-2.27/master which uses static
variables.)

Future simplification:
* If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
  elf_machine_runtime_setup can drop the `scope` parameter.
* If TLSDESC no longer need to be in elf_machine_lazy_rel,
  elf_machine_lazy_rel can drop the `scope` parameter.

Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.

Tested build-many-glibcs.py glibcs with
{alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
---
Changes from v1
* Remove global variables: cur_l, cur_scope, cur_strtab
---
Changes from v2
* Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
---
 elf/dl-conflict.c                      | 39 ++++++++--------
 elf/dl-reloc-static-pie.c              | 15 ++++---
 elf/dl-reloc.c                         | 57 +++++++++++------------
 elf/do-rel.h                           | 16 +++----
 elf/dynamic-link.h                     | 62 +++++++++++++-------------
 elf/get-dynamic-info.h                 | 15 +++----
 elf/rtld.c                             | 15 +++----
 sysdeps/aarch64/dl-machine.h           | 22 +++++----
 sysdeps/alpha/dl-machine.h             | 16 ++++---
 sysdeps/arc/dl-machine.h               | 18 +++++---
 sysdeps/arm/dl-machine.h               | 34 +++++++-------
 sysdeps/csky/dl-machine.h              | 19 ++++----
 sysdeps/hppa/dl-machine.h              | 23 +++++-----
 sysdeps/i386/dl-machine.h              | 40 ++++++++++-------
 sysdeps/ia64/dl-machine.h              | 22 ++++-----
 sysdeps/m68k/dl-machine.h              | 19 ++++----
 sysdeps/microblaze/dl-machine.h        | 19 ++++----
 sysdeps/mips/dl-machine.h              | 58 +++++++++++++-----------
 sysdeps/nios2/dl-machine.h             | 21 +++++----
 sysdeps/powerpc/powerpc32/dl-machine.h | 19 ++++----
 sysdeps/powerpc/powerpc64/dl-machine.h | 21 +++++----
 sysdeps/riscv/dl-machine.h             | 23 +++++-----
 sysdeps/s390/s390-32/dl-machine.h      | 19 ++++----
 sysdeps/s390/s390-64/dl-machine.h      | 19 ++++----
 sysdeps/sh/dl-machine.h                | 19 ++++----
 sysdeps/sparc/sparc32/dl-machine.h     | 18 ++++----
 sysdeps/sparc/sparc64/dl-machine.h     | 18 ++++----
 sysdeps/x86_64/dl-machine.h            | 25 ++++++-----
 28 files changed, 382 insertions(+), 329 deletions(-)

Comments

Szabolcs Nagy Sept. 29, 2021, 11:21 a.m. UTC | #1
The 09/24/2021 13:49, Fangrui Song via Libc-alpha wrote:
> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
> This version fixes all ports and doesn't add NESTING dispatches.]
> [Available at
> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
> 
> dynamic-link.h is included more than once in some elf/ files (rtld.c,
> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
> functions. This harms readability and the nested functions usage
> is the biggest obstacle prevents CC=clang (which doesn't support the
> feature).
> 
> The key idea for unnesting is to add extra parameters (link_map * and
> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
> implementation in the google/grte/v5-2.27/master which uses static
> variables.)
> 
> Future simplification:
> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
>   elf_machine_runtime_setup can drop the `scope` parameter.
> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
>   elf_machine_lazy_rel can drop the `scope` parameter.
> 
> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
> 
> Tested build-many-glibcs.py glibcs with
> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.

the changes look good to me on a first glance, but since this
affects ld.so (and static pie) self relocation it would be
nice to do execution tests on more targets: it is probably
enough to run ./ld.so via qemu user to see no new dynamic
relocs got introduced into the early start code that breaks
self relocation.

the aarch64 changes look ok to me, but i saw some spurious
whitespace changes and an unnecessary code style change
for { in

> diff --git a/sysdeps/x86_64/dl-machine.h b/sysdeps/x86_64/dl-machine.h
> index b3ed4dd467..9c0182d597 100644
> --- a/sysdeps/x86_64/dl-machine.h
> +++ b/sysdeps/x86_64/dl-machine.h
...
> @@ -250,12 +251,11 @@ elf_machine_plt_value (struct link_map *map, const ElfW(Rela) *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> -__attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
> -		  void *const reloc_addr_arg, int skip_ifunc)
> -{
> +static inline void __attribute__((always_inline))
> +elf_machine_rela(struct link_map *map, struct r_scope_elem *scope[],
> +		 const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
> +		 const struct r_found_version *version,
> +		 void *const reloc_addr_arg, int skip_ifunc) {
Adhemerval Zanella Sept. 29, 2021, 6:36 p.m. UTC | #2
On 24/09/2021 17:49, Fangrui Song wrote:
> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
> This version fixes all ports and doesn't add NESTING dispatches.]
> [Available at
> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
> 
> dynamic-link.h is included more than once in some elf/ files (rtld.c,
> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
> functions. This harms readability and the nested functions usage
> is the biggest obstacle prevents CC=clang (which doesn't support the
> feature).
> 
> The key idea for unnesting is to add extra parameters (link_map * and
> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
> implementation in the google/grte/v5-2.27/master which uses static
> variables.)
> 
> Future simplification:
> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
>   elf_machine_runtime_setup can drop the `scope` parameter.
> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
>   elf_machine_lazy_rel can drop the `scope` parameter.
> 
> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
> 
> Tested build-many-glibcs.py glibcs with
> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
> ---
> Changes from v1
> * Remove global variables: cur_l, cur_scope, cur_strtab
> ---
> Changes from v2
> * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.

Some minor comments below.  The architecture changes are mostly
mechanical and the bulk the change seems good, however there are
some regressions with --enable-static-pie:

$ grep ^FAIL x86_64-linux-gnu/tests.sum
FAIL: elf/tst-tls1-static-non-pie
FAIL: gmon/tst-gmon-static
FAIL: gmon/tst-gmon-static-gprof

$ grep ^FAIL i686-linux-gnu/tests.sum
FAIL: elf/tst-tls1-static-non-pie
FAIL: gmon/tst-gmon-static
FAIL: gmon/tst-gmon-static-gprof

The aarch64-linux-gnu with --enable-static-pie shows no regression.

I also have tested on powerpc64le, powerpc64, powerpc32, sparc64, sparcv9,
s390x, s390, hppa, ia64, and armhf without any regression.  I am still
running tests on alpha and mips64, so I hopelfully see if anything
breaks before v4.

> ---
>  elf/dl-conflict.c                      | 39 ++++++++--------
>  elf/dl-reloc-static-pie.c              | 15 ++++---
>  elf/dl-reloc.c                         | 57 +++++++++++------------
>  elf/do-rel.h                           | 16 +++----
>  elf/dynamic-link.h                     | 62 +++++++++++++-------------
>  elf/get-dynamic-info.h                 | 15 +++----
>  elf/rtld.c                             | 15 +++----
>  sysdeps/aarch64/dl-machine.h           | 22 +++++----
>  sysdeps/alpha/dl-machine.h             | 16 ++++---
>  sysdeps/arc/dl-machine.h               | 18 +++++---
>  sysdeps/arm/dl-machine.h               | 34 +++++++-------
>  sysdeps/csky/dl-machine.h              | 19 ++++----
>  sysdeps/hppa/dl-machine.h              | 23 +++++-----
>  sysdeps/i386/dl-machine.h              | 40 ++++++++++-------
>  sysdeps/ia64/dl-machine.h              | 22 ++++-----
>  sysdeps/m68k/dl-machine.h              | 19 ++++----
>  sysdeps/microblaze/dl-machine.h        | 19 ++++----
>  sysdeps/mips/dl-machine.h              | 58 +++++++++++++-----------
>  sysdeps/nios2/dl-machine.h             | 21 +++++----
>  sysdeps/powerpc/powerpc32/dl-machine.h | 19 ++++----
>  sysdeps/powerpc/powerpc64/dl-machine.h | 21 +++++----
>  sysdeps/riscv/dl-machine.h             | 23 +++++-----
>  sysdeps/s390/s390-32/dl-machine.h      | 19 ++++----
>  sysdeps/s390/s390-64/dl-machine.h      | 19 ++++----
>  sysdeps/sh/dl-machine.h                | 19 ++++----
>  sysdeps/sparc/sparc32/dl-machine.h     | 18 ++++----
>  sysdeps/sparc/sparc64/dl-machine.h     | 18 ++++----
>  sysdeps/x86_64/dl-machine.h            | 25 ++++++-----
>  28 files changed, 382 insertions(+), 329 deletions(-)
> 
> diff --git a/elf/dl-conflict.c b/elf/dl-conflict.c
> index 64fa5793d2..1d69b5cd9f 100644
> --- a/elf/dl-conflict.c
> +++ b/elf/dl-conflict.c
> @@ -26,20 +26,12 @@
>  #include <sys/types.h>
>  #include "dynamic-link.h"
>  
> -void
> -_dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
> -		       ElfW(Rela) *conflictend)
> -{
> -#if ! ELF_MACHINE_NO_RELA
> -  if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
> -    _dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name));
> -
> -  {
> -    /* Do the conflict relocation of the object and library GOT and other
> -       data.  */
> +/* Used by RESOLVE_CONFLICT_FIND_MAP at init time. Cannot be accessed

I think it would be better to extend the comment explaining why exaclty
it is not accessed concurrently even though the function that uses it
(elf_machine_rela) might be used on lazy resolution.  Something like:

/* Used at loading time for solely for prelink executable.  It is not
   called concurrently so it is be safe to defined as static).  */

> + * concurrently.  */
> +static struct link_map *resolve_conflict_map __attribute__ ((__unused__));
>  
>      /* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code.  */
> -#define RESOLVE_MAP(ref, version, flags) (*ref = NULL, NULL)
> +#define RESOLVE_MAP(map, scope, ref, version, flags) (*ref = NULL, NULL)
>  #define RESOLVE(ref, version, flags) (*ref = NULL, 0)
>  #define RESOLVE_CONFLICT_FIND_MAP(map, r_offset) \
>    do {									      \
> @@ -50,12 +42,23 @@ _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
>      (map) = resolve_conflict_map;					      \
>    } while (0)
>  
> +#include "dynamic-link.h"
> +
> +void
> +_dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
> +		       ElfW(Rela) *conflictend)
> +{
> +#if ! ELF_MACHINE_NO_RELA
> +  if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
> +    _dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name));
> +
> +  {
> +    /* Do the conflict relocation of the object and library GOT and other
> +       data.  */
> +
>      /* Prelinking makes no sense for anything but the main namespace.  */
>      assert (l->l_ns == LM_ID_BASE);
> -    struct link_map *resolve_conflict_map __attribute__ ((__unused__))
> -      = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
> -
> -#include "dynamic-link.h"
> +    resolve_conflict_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
>  
>      /* Override these, defined in dynamic-link.h.  */
>  #undef CHECK_STATIC_TLS
> @@ -66,8 +69,8 @@ _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
>      GL(dl_num_cache_relocations) += conflictend - conflict;
>  
>      for (; conflict < conflictend; ++conflict)
> -      elf_machine_rela (l, conflict, NULL, NULL, (void *) conflict->r_offset,
> -			0);
> +      elf_machine_rela (l, NULL, conflict, NULL, NULL,
> +			(void *) conflict->r_offset, 0);
>    }
>  #endif
>  }

Ok.

> diff --git a/elf/dl-reloc-static-pie.c b/elf/dl-reloc-static-pie.c
> index 68ded176cd..4007580453 100644
> --- a/elf/dl-reloc-static-pie.c
> +++ b/elf/dl-reloc-static-pie.c
> @@ -19,8 +19,14 @@
>  #if ENABLE_STATIC_PIE
>  /* Mark symbols hidden in static PIE for early self relocation to work.  */
>  # pragma GCC visibility push(hidden)
> +#include <assert.h>
>  #include <unistd.h>
>  #include <ldsodefs.h>
> +
> +#include <dl-machine.h>
> +
> +#define STATIC_PIE_BOOTSTRAP
> +#define RESOLVE_MAP(map, scope, sym, version, flags) map
>  #include "dynamic-link.h"
>  
>  /* Relocate static executable with PIE.  */
> @@ -30,11 +36,6 @@ _dl_relocate_static_pie (void)
>  {
>    struct link_map *main_map = _dl_get_dl_main_map ();
>  
> -# define STATIC_PIE_BOOTSTRAP
> -# define BOOTSTRAP_MAP (main_map)
> -# define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
> -# include "dynamic-link.h"
> -
>    /* Figure out the run-time load address of static PIE.  */
>    main_map->l_addr = elf_machine_load_address ();
>  
> @@ -53,12 +54,12 @@ _dl_relocate_static_pie (void)
>    elf_get_dynamic_info (main_map);
>  
>  # ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
> -  ELF_MACHINE_BEFORE_RTLD_RELOC (main_map->l_info);
> +  ELF_MACHINE_BEFORE_RTLD_RELOC (main_map, main_map->l_info);
>  # endif
>  
>    /* Relocate ourselves so we can do normal function calls and
>       data access using the global offset table.  */
> -  ELF_DYNAMIC_RELOCATE (main_map, 0, 0, 0);
> +  ELF_DYNAMIC_RELOCATE (main_map, NULL, 0, 0, 0);
>    main_map->l_relocated = 1;
>  
>    /* Initialize _r_debug_extended.  */

Ok.

> diff --git a/elf/dl-reloc.c b/elf/dl-reloc.c
> index 6c957456b8..8867e32c9e 100644
> --- a/elf/dl-reloc.c
> +++ b/elf/dl-reloc.c
> @@ -162,6 +162,32 @@ _dl_nothread_init_static_tls (struct link_map *map)
>  }
>  #endif /* !PTHREAD_IN_LIBC */
>  
> +/* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code.  */
> +#define RESOLVE_MAP(l, scope, ref, version, r_type)			      \
> +    ((ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL			      \
> +      && __glibc_likely (!dl_symbol_visibility_binds_local_p (*ref)))	      \
> +     ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0)		      \

Since you changing, use __glibc_likely as well.

> +	 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class)  \
> +	? (bump_num_cache_relocations (),				      \
> +	   (*ref) = l->l_lookup_cache.ret,				      \
> +	   l->l_lookup_cache.value)					      \
> +	: ({ lookup_t _lr;						      \
> +	     int _tc = elf_machine_type_class (r_type);			      \
> +	     l->l_lookup_cache.type_class = _tc;			      \
> +	     l->l_lookup_cache.sym = (*ref);				      \
> +	     const struct r_found_version *v = NULL;			      \
> +	     if ((version) != NULL && (version)->hash != 0)		      \
> +	       v = (version);						      \
> +	     _lr = _dl_lookup_symbol_x ((const char *) D_PTR (l, l_info[DT_STRTAB]) + (*ref)->st_name, \
> +					l, (ref), scope, v, _tc,	      \
> +					DL_LOOKUP_ADD_DEPENDENCY	      \
> +					| DL_LOOKUP_FOR_RELOCATE, NULL);      \
> +	     l->l_lookup_cache.ret = (*ref);				      \
> +	     l->l_lookup_cache.value = _lr; }))				      \
> +     : l)
> +
> +#include "dynamic-link.h"
> +
>  void
>  _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
>  		     int reloc_mode, int consider_profiling)

Ok.

> @@ -243,36 +269,7 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
>    {
>      /* Do the actual relocation of the object's GOT and other data.  */
>  
> -    /* String table object symbols.  */
> -    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, r_type) \
> -    ((ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL			      \
> -      && __glibc_likely (!dl_symbol_visibility_binds_local_p (*ref)))	      \
> -     ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0)		      \
> -	 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class)  \
> -	? (bump_num_cache_relocations (),				      \
> -	   (*ref) = l->l_lookup_cache.ret,				      \
> -	   l->l_lookup_cache.value)					      \
> -	: ({ lookup_t _lr;						      \
> -	     int _tc = elf_machine_type_class (r_type);			      \
> -	     l->l_lookup_cache.type_class = _tc;			      \
> -	     l->l_lookup_cache.sym = (*ref);				      \
> -	     const struct r_found_version *v = NULL;			      \
> -	     if ((version) != NULL && (version)->hash != 0)		      \
> -	       v = (version);						      \
> -	     _lr = _dl_lookup_symbol_x (strtab + (*ref)->st_name, l, (ref),   \
> -					scope, v, _tc,			      \
> -					DL_LOOKUP_ADD_DEPENDENCY	      \
> -					| DL_LOOKUP_FOR_RELOCATE, NULL);      \
> -	     l->l_lookup_cache.ret = (*ref);				      \
> -	     l->l_lookup_cache.value = _lr; }))				      \
> -     : l)
> -
> -#include "dynamic-link.h"
> -
> -    ELF_DYNAMIC_RELOCATE (l, lazy, consider_profiling, skip_ifunc);
> +    ELF_DYNAMIC_RELOCATE (l, scope, lazy, consider_profiling, skip_ifunc);
>  
>  #ifndef PROF
>      if (__glibc_unlikely (consider_profiling)

Ok.

> diff --git a/elf/do-rel.h b/elf/do-rel.h
> index 321ac2b359..f441b74919 100644
> --- a/elf/do-rel.h
> +++ b/elf/do-rel.h
> @@ -37,8 +37,8 @@
>     relocations; they should be set up to call _dl_runtime_resolve, rather
>     than fully resolved now.  */
>  
> -auto inline void __attribute__ ((always_inline))
> -elf_dynamic_do_Rel (struct link_map *map,
> +static inline void __attribute__ ((always_inline))
> +elf_dynamic_do_Rel (struct link_map *map, struct r_scope_elem *scope[],
>  		    ElfW(Addr) reladdr, ElfW(Addr) relsize,
>  		    __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative,
>  		    int lazy, int skip_ifunc)

Ok.

> @@ -68,13 +68,13 @@ elf_dynamic_do_Rel (struct link_map *map,
>  	  }
>  	else
>  # endif
> -	  elf_machine_lazy_rel (map, l_addr, r, skip_ifunc);
> +	  elf_machine_lazy_rel (map, scope, l_addr, r, skip_ifunc);
>  
>  # ifdef ELF_MACHINE_IRELATIVE
>        if (r2 != NULL)
>  	for (; r2 <= end2; ++r2)
>  	  if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
> -	    elf_machine_lazy_rel (map, l_addr, r2, skip_ifunc);
> +	    elf_machine_lazy_rel (map, scope, l_addr, r2, skip_ifunc);
>  # endif
>      }
>    else

Ok.

> @@ -134,7 +134,7 @@ elf_dynamic_do_Rel (struct link_map *map,
>  #endif
>  
>  	      ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
> -	      elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)],
> +	      elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)],
>  			       &map->l_versions[ndx],
>  			       (void *) (l_addr + r->r_offset), skip_ifunc);
>  	    }
> @@ -146,7 +146,7 @@ elf_dynamic_do_Rel (struct link_map *map,
>  		{
>  		  ElfW(Half) ndx
>  		    = version[ELFW(R_SYM) (r2->r_info)] & 0x7fff;
> -		  elf_machine_rel (map, r2,
> +		  elf_machine_rel (map, scope, r2,
>  				   &symtab[ELFW(R_SYM) (r2->r_info)],
>  				   &map->l_versions[ndx],
>  				   (void *) (l_addr + r2->r_offset),

Ok.

> @@ -167,14 +167,14 @@ elf_dynamic_do_Rel (struct link_map *map,
>  	      }
>  	    else
>  # endif
> -	      elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
> +	      elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
>  			       (void *) (l_addr + r->r_offset), skip_ifunc);
>  
>  # ifdef ELF_MACHINE_IRELATIVE
>  	  if (r2 != NULL)
>  	    for (; r2 <= end2; ++r2)
>  	      if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
> -		elf_machine_rel (map, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
> +		elf_machine_rel (map, scope, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
>  				 NULL, (void *) (l_addr + r2->r_offset),
>  				 skip_ifunc);
>  # endif

Ok.

> diff --git a/elf/dynamic-link.h b/elf/dynamic-link.h
> index 3eb24ba3a6..f3f6c3bcac 100644
> --- a/elf/dynamic-link.h
> +++ b/elf/dynamic-link.h
> @@ -59,31 +59,33 @@ int _dl_try_allocate_static_tls (struct link_map *map, bool optional)
>     copying memory, breaking the very code written to handle the
>     unaligned cases.  */
>  # if ! ELF_MACHINE_NO_REL
> -auto inline void __attribute__((always_inline))
> -elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
> -		 const ElfW(Sym) *sym, const struct r_found_version *version,
> +static inline void __attribute__((always_inline))
> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
> +		 const ElfW(Rel) *reloc, const ElfW(Sym) *sym,
> +		 const struct r_found_version *version,
>  		 void *const reloc_addr, int skip_ifunc);
> -auto inline void __attribute__((always_inline))
> +static inline void __attribute__((always_inline))
>  elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>  			  void *const reloc_addr);
>  # endif
>  # if ! ELF_MACHINE_NO_RELA
> -auto inline void __attribute__((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
> -		  void *const reloc_addr, int skip_ifunc);
> -auto inline void __attribute__((always_inline))
> -elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
> -			   void *const reloc_addr);
> +static inline void __attribute__((always_inline))
> +elf_machine_rela(struct link_map *map, struct r_scope_elem *scope[],

Space after name.

> +		 const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
> +		 const struct r_found_version *version, void *const reloc_addr,
> +		 int skip_ifunc);
> +static inline void __attribute__((always_inline))
> +elf_machine_rela_relative(ElfW(Addr) l_addr, const ElfW(Rela) *reloc,

Ditto

> +	                  void *const reloc_addr);
>  # endif
>  # if ELF_MACHINE_NO_RELA || defined ELF_MACHINE_PLT_REL
> -auto inline void __attribute__((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void __attribute__((always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>  		      int skip_ifunc);
>  # else
> -auto inline void __attribute__((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void __attribute__((always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  		      int skip_ifunc);
>  # endif

Ok.

> @@ -114,7 +116,7 @@ elf_machine_lazy_rel (struct link_map *map,
>     consumes precisely the very end of the DT_REL*, or DT_JMPREL and DT_REL*
>     are completely separate and there is a gap between them.  */
>  
> -# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, do_lazy, skip_ifunc, test_rel) \
> +# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, scope, do_lazy, skip_ifunc, test_rel) \
>    do {									      \
>      struct { ElfW(Addr) start, size;					      \
>  	     __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative; int lazy; }  \
> @@ -152,18 +154,18 @@ elf_machine_lazy_rel (struct link_map *map,
>        }									      \
>  									      \
>      if (ELF_DURING_STARTUP)						      \
> -      elf_dynamic_do_##reloc ((map), ranges[0].start, ranges[0].size,	      \
> -			      ranges[0].nrelative, 0, skip_ifunc);	      \
> +      elf_dynamic_do_##reloc ((map), scope, ranges[0].start, ranges[0].size,  \
> +			      ranges[0].nrelative, 0, skip_ifunc);  \
>      else								      \
>        {									      \
>  	int ranges_index;						      \
>  	for (ranges_index = 0; ranges_index < 2; ++ranges_index)	      \
> -	  elf_dynamic_do_##reloc ((map),				      \
> +	  elf_dynamic_do_##reloc ((map), scope,				      \
>  				  ranges[ranges_index].start,		      \
>  				  ranges[ranges_index].size,		      \
>  				  ranges[ranges_index].nrelative,	      \
>  				  ranges[ranges_index].lazy,		      \
> -				  skip_ifunc);				      \
> +				  skip_ifunc);		      \
>        }									      \
>    } while (0)
>  

Ok.

> @@ -175,29 +177,29 @@ elf_machine_lazy_rel (struct link_map *map,
>  
>  # if ! ELF_MACHINE_NO_REL
>  #  include "do-rel.h"
> -#  define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) \
> -  _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, lazy, skip_ifunc, _ELF_CHECK_REL)
> +#  define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc)	      \
> +  _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL)
>  # else
> -#  define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) /* Nothing to do.  */
> +#  define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc) /* Nothing to do.  */
>  # endif
>  
>  # if ! ELF_MACHINE_NO_RELA
>  #  define DO_RELA
>  #  include "do-rel.h"
> -#  define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) \
> -  _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, lazy, skip_ifunc, _ELF_CHECK_REL)
> +#  define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc)	      \
> +  _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL)
>  # else
> -#  define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) /* Nothing to do.  */
> +#  define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc) /* Nothing to do.  */
>  # endif
>  
>  /* This can't just be an inline function because GCC is too dumb
>     to inline functions containing inlines themselves.  */
> -# define ELF_DYNAMIC_RELOCATE(map, lazy, consider_profile, skip_ifunc) \
> +# define ELF_DYNAMIC_RELOCATE(map, scope, lazy, consider_profile, skip_ifunc) \
>    do {									      \
> -    int edr_lazy = elf_machine_runtime_setup ((map), (lazy),		      \
> +    int edr_lazy = elf_machine_runtime_setup ((map), (scope), (lazy),	      \
>  					      (consider_profile));	      \
> -    ELF_DYNAMIC_DO_REL ((map), edr_lazy, skip_ifunc);			      \
> -    ELF_DYNAMIC_DO_RELA ((map), edr_lazy, skip_ifunc);			      \
> +    ELF_DYNAMIC_DO_REL ((map), (scope), edr_lazy, skip_ifunc);		      \
> +    ELF_DYNAMIC_DO_RELA ((map), (scope), edr_lazy, skip_ifunc);		      \
>    } while (0)
>  
>  #endif

Ok.

> diff --git a/elf/get-dynamic-info.h b/elf/get-dynamic-info.h
> index 4aa2058abf..15c316b38c 100644
> --- a/elf/get-dynamic-info.h
> +++ b/elf/get-dynamic-info.h
> @@ -16,18 +16,15 @@
>     License along with the GNU C Library; if not, see
>     <https://www.gnu.org/licenses/>.  */
>  
> -/* This file is included multiple times and therefore lacks a header
> -   file inclusion guard.  */
> +/* Populate dynamic tags in l_info.  */
> +
> +#ifndef _GET_DYNAMIC_INFO_H
> +#define _GET_DYNAMIC_INFO_H
>  
>  #include <assert.h>
>  #include <libc-diag.h>
>  
> -#ifndef RESOLVE_MAP
> -static
> -#else
> -auto
> -#endif
> -inline void __attribute__ ((unused, always_inline))
> +static inline void __attribute__ ((unused, always_inline))
>  elf_get_dynamic_info (struct link_map *l)
>  {
>  #if __ELF_NATIVE_CLASS == 32
> @@ -165,3 +162,5 @@ elf_get_dynamic_info (struct link_map *l)
>      info[DT_RPATH] = NULL;
>  #endif
>  }
> +
> +#endif

Ok.

> diff --git a/elf/rtld.c b/elf/rtld.c
> index 8d2bba3d43..0c27e5d486 100644
> --- a/elf/rtld.c
> +++ b/elf/rtld.c
> @@ -500,13 +500,9 @@ _dl_start_final (void *arg, struct dl_start_final_info *info)
>    return start_addr;
>  }
>  
> -static ElfW(Addr) __attribute_used__
> -_dl_start (void *arg)
> -{
>  #ifdef DONT_USE_BOOTSTRAP_MAP
>  # define bootstrap_map GL(dl_rtld_map)
>  #else
> -  struct dl_start_final_info info;
>  # define bootstrap_map info.l
>  #endif
>  
> @@ -515,13 +511,16 @@ _dl_start (void *arg)
>       Since ld.so must not have any undefined symbols the result
>       is trivial: always the map of ld.so itself.  */
>  #define RTLD_BOOTSTRAP
> -#define BOOTSTRAP_MAP (&bootstrap_map)
> -#define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
> +#define RESOLVE_MAP(map, scope, sym, version, flags) map
>  #include "dynamic-link.h"
>  
> +static ElfW(Addr) __attribute_used__
> +_dl_start (void *arg)
> +{
>  #ifdef DONT_USE_BOOTSTRAP_MAP
>    rtld_timer_start (&start_time);
>  #else
> +  struct dl_start_final_info info;
>    rtld_timer_start (&info.start_time);
>  #endif
>  
> @@ -554,7 +553,7 @@ _dl_start (void *arg)
>  #endif
>  
>  #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
> -  ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
> +  ELF_MACHINE_BEFORE_RTLD_RELOC (&bootstrap_map, bootstrap_map.l_info);
>  #endif
>  
>    if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
> @@ -562,7 +561,7 @@ _dl_start (void *arg)
>        /* Relocate ourselves so we can do normal function calls and
>  	 data access using the global offset table.  */
>  
> -      ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0, 0);
> +      ELF_DYNAMIC_RELOCATE (&bootstrap_map, NULL, 0, 0, 0);
>      }
>    bootstrap_map.l_relocated = 1;
>  

Ok.

> diff --git a/sysdeps/aarch64/dl-machine.h b/sysdeps/aarch64/dl-machine.h
> index 3e10cb462f..e30e81c902 100644
> --- a/sysdeps/aarch64/dl-machine.h
> +++ b/sysdeps/aarch64/dl-machine.h
> @@ -59,7 +59,8 @@ elf_machine_dynamic (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    if (l->l_info[DT_JMPREL] && lazy)
>      {
> @@ -237,10 +238,11 @@ elf_machine_plt_value (struct link_map *map,
>  
>  #ifdef RESOLVE_MAP
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    ElfW(Addr) *const reloc_addr = reloc_addr_arg;

Ok.

> @@ -253,7 +255,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>    else
>      {
>        const ElfW(Sym) *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -377,9 +380,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      ElfW(Addr) l_addr,
>  		      const ElfW(Rela) *reloc,
>  		      int skip_ifunc)
> @@ -406,7 +409,7 @@ elf_machine_lazy_rel (struct link_map *map,
>  		    (const void *)D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
>  		  version = &map->l_versions[vernum[symndx] & 0x7fff];
>  		}
> -	      elf_machine_rela (map, reloc, sym, version, reloc_addr,
> +	      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
>  				skip_ifunc);
>  	      return;
>  	    }
> @@ -433,7 +436,8 @@ elf_machine_lazy_rel (struct link_map *map,
>  
>        /* Always initialize TLS descriptors completely, because lazy
>  	 initialization requires synchronization at every TLS access.  */
> -      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
> +      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
> +			skip_ifunc);
>      }
>    else if (__glibc_unlikely (r_type == AARCH64_R(IRELATIVE)))
>      {

Ok.

> diff --git a/sysdeps/alpha/dl-machine.h b/sysdeps/alpha/dl-machine.h
> index 9e327b7f17..491541326f 100644
> --- a/sysdeps/alpha/dl-machine.h
> +++ b/sysdeps/alpha/dl-machine.h
> @@ -69,7 +69,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int
> -elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    extern char _dl_runtime_resolve_new[] attribute_hidden;
>    extern char _dl_runtime_profile_new[] attribute_hidden;

Ok.

> @@ -360,9 +361,9 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>  
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>  		  const Elf64_Rela *reloc,
>  		  const Elf64_Sym *sym,
>  		  const struct r_found_version *version,
> @@ -410,7 +411,8 @@ elf_machine_rela (struct link_map *map,
>        return;
>    else
>      {
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf64_Addr sym_value;
>        Elf64_Addr sym_raw_value;
>  
> @@ -488,7 +490,7 @@ elf_machine_rela (struct link_map *map,
>     can be skipped.  */
>  #define ELF_MACHINE_REL_RELATIVE 1
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -505,9 +507,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>    memcpy (reloc_addr_arg, &reloc_addr_val, 8);
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/arc/dl-machine.h b/sysdeps/arc/dl-machine.h
> index e6ce7f0ff6..4b64ffec25 100644
> --- a/sysdeps/arc/dl-machine.h
> +++ b/sysdeps/arc/dl-machine.h
> @@ -122,7 +122,8 @@ elf_machine_load_address (void)
>  
>  static inline int
>  __attribute__ ((always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    extern void _dl_runtime_resolve (void);
>  
> @@ -228,10 +229,11 @@ elf_machine_fixup_plt (struct link_map *map, lookup_t t,
>  
>  #ifdef RESOLVE_MAP
>  
> -inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> -                  const ElfW(Sym) *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
> +		  const struct r_found_version *version,
>                    void *const reloc_addr_arg, int skip_ifunc)
>  {
>    ElfW(Addr) r_info = reloc->r_info;
> @@ -245,7 +247,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>    else
>      {
>        const ElfW(Sym) *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        switch (r_type)
> @@ -326,8 +329,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  
>  inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
> -                      const ElfW(Rela) *reloc, int skip_ifunc)
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
> +		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
> +		      int skip_ifunc)
>  {
>    ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
>    const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);

Ok.

> diff --git a/sysdeps/arm/dl-machine.h b/sysdeps/arm/dl-machine.h
> index eb13cb8b57..68a0b4b476 100644
> --- a/sysdeps/arm/dl-machine.h
> +++ b/sysdeps/arm/dl-machine.h
> @@ -57,7 +57,8 @@ elf_machine_dynamic (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf32_Addr *got;
>    extern void _dl_runtime_resolve (Elf32_Word);
> @@ -276,7 +277,7 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
>  
>  #ifdef RESOLVE_MAP
>  /* Handle a PC24 reloc, including the out-of-range case.  */
> -auto void
> +static void
>  relocate_pc24 (struct link_map *map, Elf32_Addr value,
>                 Elf32_Addr *const reloc_addr, Elf32_Sword addend)
>  {
> @@ -330,10 +331,11 @@ relocate_pc24 (struct link_map *map, Elf32_Addr value,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
> -		 const Elf32_Sym *sym, const struct r_found_version *version,
> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
> +                 const Elf32_Rel *reloc, const Elf32_Sym *sym,
> +                 const struct r_found_version *version,
>  		 void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -364,7 +366,8 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>  #endif
>      {
>        const Elf32_Sym *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -508,10 +511,11 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>  }
>  
>  # ifndef RTLD_BOOTSTRAP
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +                  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +                  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -526,7 +530,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>  # ifndef RESOLVE_CONFLICT_FIND_MAP
>        const Elf32_Sym *const refsym = sym;
>  # endif
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -601,7 +605,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>  }
>  # endif
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>  			  void *const reloc_addr_arg)
> @@ -611,7 +615,7 @@ elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>  }
>  
>  # ifndef RTLD_BOOTSTRAP
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -621,9 +625,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  }
>  # endif
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rel *reloc,
>  		      int skip_ifunc)
>  {
> @@ -653,7 +657,7 @@ elf_machine_lazy_rel (struct link_map *map,
>  
>        /* Always initialize TLS descriptors completely, because lazy
>  	 initialization requires synchronization at every TLS access.  */
> -      elf_machine_rel (map, reloc, sym, version, reloc_addr, skip_ifunc);
> +      elf_machine_rel (map, scope, reloc, sym, version, reloc_addr, skip_ifunc);
>      }
>    else
>      _dl_reloc_bad_type (map, r_type, 1);

Ok.

> diff --git a/sysdeps/csky/dl-machine.h b/sysdeps/csky/dl-machine.h
> index b08f06d74c..ec22f87577 100644
> --- a/sysdeps/csky/dl-machine.h
> +++ b/sysdeps/csky/dl-machine.h
> @@ -58,7 +58,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf32_Addr *got;
>    extern void _dl_runtime_resolve (Elf32_Word);
> @@ -215,9 +216,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void __attribute__ ((unused, always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +static inline void __attribute__ ((unused, always_inline))
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -230,7 +232,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>    else
>      {
>        const Elf32_Sym *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>        opcode16_addr = (unsigned short *)reloc_addr;
>  
> @@ -331,7 +334,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>  }
>  
> -auto inline void __attribute__ ((unused, always_inline))
> +static inline void __attribute__ ((unused, always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
>  {
> @@ -339,8 +342,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void __attribute__ ((unused, always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void __attribute__ ((unused, always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/hppa/dl-machine.h b/sysdeps/hppa/dl-machine.h
> index ded9c193d6..e6a4575fce 100644
> --- a/sysdeps/hppa/dl-machine.h
> +++ b/sysdeps/hppa/dl-machine.h
> @@ -68,8 +68,8 @@ __hppa_init_bootstrap_fdesc_table (struct link_map *map)
>    map->l_mach.fptr_table = boot_table;
>  }
>  
> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)		\
> -	__hppa_init_bootstrap_fdesc_table (BOOTSTRAP_MAP);	\
> +#define ELF_MACHINE_BEFORE_RTLD_RELOC(map, dynamic_info)	\
> +	__hppa_init_bootstrap_fdesc_table (map);		\
>  	_dl_fptr_init();
>  
>  /* Return nonzero iff ELF header is compatible with the running host.  */
> @@ -162,7 +162,8 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf32_Addr *got = NULL;
>    Elf32_Addr l_addr, iplt, jmprel, end_jmprel, r_type, r_sym;
> @@ -548,8 +549,8 @@ dl_platform_init (void)
>    (  (((as14) & 0x1fff) << 1) \
>     | (((as14) & 0x2000) >> 13))
>  
> -auto void __attribute__((always_inline))
> -elf_machine_rela (struct link_map *map,
> +static void __attribute__((always_inline))
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>  		  const Elf32_Rela *reloc,
>  		  const Elf32_Sym *sym,
>  		  const struct r_found_version *version,
> @@ -578,11 +579,9 @@ elf_machine_rela (struct link_map *map,
>       zeros, and an all zero Elf32_Sym has a binding of STB_LOCAL.)
>       See RESOLVE_MAP definition in elf/dl-reloc.c  */
>  # ifdef RTLD_BOOTSTRAP
> -  /* RESOLVE_MAP in rtld.c doesn't have the local sym test.  */
> -  sym_map = (ELF32_ST_BIND (sym->st_info) != STB_LOCAL
> -	     ? RESOLVE_MAP (&sym, version, r_type) : map);
> +  sym_map = map;
>  # else
> -  sym_map = RESOLVE_MAP (&sym, version, r_type);
> +  sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>  # endif
>  
>    if (sym_map)
> @@ -740,7 +739,7 @@ elf_machine_rela (struct link_map *map,
>  
>  /* hppa doesn't have an R_PARISC_RELATIVE reloc, but uses relocs with
>     ELF32_R_SYM (info) == 0 for a similar purpose.  */
> -auto void __attribute__((always_inline))
> +static void __attribute__((always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr,
>  			   const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -793,8 +792,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr,
>    *reloc_addr = value;
>  }
>  
> -auto void __attribute__((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static void __attribute__((always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/i386/dl-machine.h b/sysdeps/i386/dl-machine.h
> index 0401888508..9f578e536a 100644
> --- a/sysdeps/i386/dl-machine.h
> +++ b/sysdeps/i386/dl-machine.h
> @@ -54,7 +54,8 @@ elf_machine_dynamic (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused, always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf32_Addr *got;
>    extern void _dl_runtime_resolve (Elf32_Word) attribute_hidden;
> @@ -284,9 +285,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
> -elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
> +		 const Elf32_Rel *reloc,
>  		 const Elf32_Sym *sym, const struct r_found_version *version,
>  		 void *const reloc_addr_arg, int skip_ifunc)
>  {
> @@ -320,7 +322,8 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>  # ifndef RTLD_BOOTSTRAP
>        const Elf32_Sym *const refsym = sym;
>  # endif
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -491,10 +494,11 @@ and creates an unsatisfiable circular dependency.\n",
>  }
>  
>  # ifndef RTLD_BOOTSTRAP
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -507,7 +511,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>  #  ifndef RESOLVE_CONFLICT_FIND_MAP
>        const Elf32_Sym *const refsym = sym;
>  #  endif
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -640,7 +645,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>  }
>  # endif	/* !RTLD_BOOTSTRAP */
>  
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
>  elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>  			  void *const reloc_addr_arg)
> @@ -651,7 +656,7 @@ elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>  }
>  
>  # ifndef RTLD_BOOTSTRAP
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -661,9 +666,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  }
>  # endif	/* !RTLD_BOOTSTRAP */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rel *reloc,
>  		      int skip_ifunc)
>  {
> @@ -698,13 +703,13 @@ elf_machine_lazy_rel (struct link_map *map,
>  	  const ElfW(Half) *const version =
>  	    (const void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
>  	  ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
> -	  elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)],
> +	  elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)],
>  			   &map->l_versions[ndx],
>  			   (void *) (l_addr + r->r_offset), skip_ifunc);
>  	}
>  # ifndef RTLD_BOOTSTRAP
>        else
> -	elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
> +	elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
>  			 (void *) (l_addr + r->r_offset), skip_ifunc);
>  # endif
>      }
> @@ -721,9 +726,9 @@ elf_machine_lazy_rel (struct link_map *map,
>  
>  # ifndef RTLD_BOOTSTRAP
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rela (struct link_map *map,
> +elf_machine_lazy_rela (struct link_map *map, struct r_scope_elem *scope[],
>  		       Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		       int skip_ifunc)
>  {
> @@ -747,7 +752,8 @@ elf_machine_lazy_rela (struct link_map *map,
>  
>        /* Always initialize TLS descriptors completely at load time, in
>  	 case static TLS is allocated for it that requires locking.  */
> -      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
> +      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
> +			skip_ifunc);
>      }
>    else if (__glibc_unlikely (r_type == R_386_IRELATIVE))
>      {

Ok.

> diff --git a/sysdeps/ia64/dl-machine.h b/sysdeps/ia64/dl-machine.h
> index 4403e7767a..2217d0b556 100644
> --- a/sysdeps/ia64/dl-machine.h
> +++ b/sysdeps/ia64/dl-machine.h
> @@ -44,8 +44,8 @@ __ia64_init_bootstrap_fdesc_table (struct link_map *map)
>    map->l_mach.fptr_table = boot_table;
>  }
>  
> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)		\
> -	__ia64_init_bootstrap_fdesc_table (BOOTSTRAP_MAP);
> +#define ELF_MACHINE_BEFORE_RTLD_RELOC(map, dynamic_info)		\
> +	__ia64_init_bootstrap_fdesc_table (map);
>  
>  /* Return nonzero iff ELF header is compatible with the running host.  */
>  static inline int __attribute__ ((unused))
> @@ -98,7 +98,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused, always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    extern void _dl_runtime_resolve (void);
>    extern void _dl_runtime_profile (void);
> @@ -371,9 +372,9 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>  
>  /* Perform the relocation specified by RELOC and SYM (which is fully
>     resolved).  MAP is the object containing the reloc.  */
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
> -elf_machine_rela (struct link_map *map,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>  		  const Elf64_Rela *reloc,
>  		  const Elf64_Sym *sym,
>  		  const struct r_found_version *version,
> @@ -414,10 +415,11 @@ elf_machine_rela (struct link_map *map,
>        return;
>    else
>      {
> -      struct link_map *sym_map;
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>  
>        /* RESOLVE_MAP() will return NULL if it fail to locate the symbol.  */
> -      if ((sym_map = RESOLVE_MAP (&sym, version, r_type)))
> +      if (sym_map != NULL)
>  	{
>  	  value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
>  
> @@ -476,7 +478,7 @@ elf_machine_rela (struct link_map *map,
>     can be skipped.  */
>  #define ELF_MACHINE_REL_RELATIVE 1
>  
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -489,9 +491,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  }
>  
>  /* Perform a RELATIVE reloc on the .got entry that transfers to the .plt.  */
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/m68k/dl-machine.h b/sysdeps/m68k/dl-machine.h
> index 86a8c67e2a..5e34c4784e 100644
> --- a/sysdeps/m68k/dl-machine.h
> +++ b/sysdeps/m68k/dl-machine.h
> @@ -68,7 +68,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf32_Addr *got;
>    extern void _dl_runtime_resolve (Elf32_Word);
> @@ -215,9 +216,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void __attribute__ ((unused, always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +static inline void __attribute__ ((unused, always_inline))
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -228,7 +230,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>    else
>      {
>        const Elf32_Sym *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        switch (r_type)
> @@ -303,7 +306,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>  }
>  
> -auto inline void __attribute__ ((unused, always_inline))
> +static inline void __attribute__ ((unused, always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
>  {
> @@ -311,8 +314,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void __attribute__ ((unused, always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void __attribute__ ((unused, always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/microblaze/dl-machine.h b/sysdeps/microblaze/dl-machine.h
> index e460f6f195..3fd4988e60 100644
> --- a/sysdeps/microblaze/dl-machine.h
> +++ b/sysdeps/microblaze/dl-machine.h
> @@ -69,7 +69,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    extern void _dl_runtime_resolve (Elf32_Word);
>    extern void _dl_runtime_profile (Elf32_Word);
> @@ -207,9 +208,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>      ((unsigned short *)(rel_addr))[3] = (val) & 0xffff; \
>    } while (0)
>  
> -auto inline void __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +static inline void __attribute__ ((always_inline))
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -222,7 +224,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>    else
>      {
>        const Elf32_Sym *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        value += reloc->r_addend;
> @@ -277,7 +280,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
>  {
> @@ -285,8 +288,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>    PUT_REL_64 (reloc_addr, l_addr + reloc->r_addend);
>  }
>  
> -auto inline void
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/mips/dl-machine.h b/sysdeps/mips/dl-machine.h
> index b74d427d64..f8d1298b60 100644
> --- a/sysdeps/mips/dl-machine.h
> +++ b/sysdeps/mips/dl-machine.h
> @@ -187,9 +187,9 @@ elf_machine_load_address (void)
>  
>  /* We can't rely on elf_machine_got_rel because _dl_object_relocation_scope
>     fiddles with global data.  */
> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)			\
> +#define ELF_MACHINE_BEFORE_RTLD_RELOC(bootstrap_map, dynamic_info)	\
>  do {									\
> -  struct link_map *map = BOOTSTRAP_MAP;					\
> +  struct link_map *map = bootstrap_map;					\
>    ElfW(Sym) *sym;							\
>    ElfW(Addr) *got;							\
>    int i, n;								\
> @@ -474,11 +474,12 @@ elf_machine_plt_value (struct link_map *map, const ElfW(Rel) *reloc,
>     by RELOC_ADDR.  SYM is the relocation symbol specified by R_INFO and
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
> -		   const ElfW(Sym) *sym, const struct r_found_version *version,
> -		   void *reloc_addr, ElfW(Addr) r_addend, int inplace_p)
> +elf_machine_reloc (struct link_map *map, struct r_scope_elem *scope[],
> +		   ElfW(Addr) r_info, const ElfW(Sym) *sym,
> +		   const struct r_found_version *version, void *reloc_addr,
> +		   ElfW(Addr) r_addend, int inplace_p)
>  {
>    const unsigned long int r_type = ELFW(R_TYPE) (r_info);
>    ElfW(Addr) *addr_field = (ElfW(Addr) *) reloc_addr;
> @@ -506,7 +507,8 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>      case R_MIPS_TLS_TPREL32:
>  # endif
>        {
> -	struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +	struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +						r_type);
>  
>  	switch (r_type)
>  	  {
> @@ -646,7 +648,7 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>  	  _dl_signal_error (0, map->l_name, NULL,
>  			    "found jump slot relocation with non-zero addend");
>  
> -	sym_map = RESOLVE_MAP (&sym, version, r_type);
> +	sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>  	value = SYMBOL_ADDRESS (sym_map, sym, true);
>  	*addr_field = value;
>  
> @@ -660,7 +662,7 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>  	ElfW(Addr) value;
>  
>  	/* Calculate the address of the symbol.  */
> -	sym_map = RESOLVE_MAP (&sym, version, r_type);
> +	sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>  	value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>  	if (__builtin_expect (sym == NULL, 0))
> @@ -707,16 +709,17 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
> -		 const ElfW(Sym) *sym, const struct r_found_version *version,
> -		 void *const reloc_addr, int skip_ifunc)
> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
> +		 const ElfW(Rel) *reloc, const ElfW(Sym) *sym,
> +		 const struct r_found_version *version, void *const reloc_addr,
> +		 int skip_ifunc)
>  {
> -  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr, 0, 1);
> +  elf_machine_reloc (map, scope, reloc->r_info, sym, version, reloc_addr, 0, 1);
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__((always_inline))
>  elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>  			  void *const reloc_addr)
> @@ -724,9 +727,9 @@ elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>    /* XXX Nothing to do.  There is no relative relocation, right?  */
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>  		      int skip_ifunc)
>  {
> @@ -747,17 +750,17 @@ elf_machine_lazy_rel (struct link_map *map,
>      _dl_reloc_bad_type (map, r_type, 1);
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[], const ElfW(Rela) *reloc,
>  		  const ElfW(Sym) *sym, const struct r_found_version *version,
>  		  void *const reloc_addr, int skip_ifunc)
>  {
> -  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr,
> +  elf_machine_reloc (map, scope, reloc->r_info, sym, version, reloc_addr,
>  		     reloc->r_addend, 0);
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__((always_inline))
>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  			   void *const reloc_addr)
> @@ -766,9 +769,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  
>  #ifndef RTLD_BOOTSTRAP
>  /* Relocate GOT. */
> -auto inline void
> +static inline void
>  __attribute__((always_inline))
> -elf_machine_got_rel (struct link_map *map, int lazy)
> +elf_machine_got_rel (struct link_map *map, struct r_scope_elem *scope[], int lazy)
>  {
>    ElfW(Addr) *got;
>    ElfW(Sym) *sym;
> @@ -781,7 +784,7 @@ elf_machine_got_rel (struct link_map *map, int lazy)
>        const struct r_found_version *version __attribute__ ((unused))	  \
>  	= vernum ? &map->l_versions[vernum[sym_index] & 0x7fff] : NULL;	  \
>        struct link_map *sym_map;						  \
> -      sym_map = RESOLVE_MAP (&ref, version, reloc);			  \
> +      sym_map = RESOLVE_MAP (map, scope, &ref, version, reloc);		  \
>        SYMBOL_ADDRESS (sym_map, ref, true);				  \
>      })
>  
> @@ -867,9 +870,10 @@ elf_machine_got_rel (struct link_map *map, int lazy)
>  /* Set up the loaded object described by L so its stub function
>     will jump to the on-demand fixup code __dl_runtime_resolve.  */
>  
> -auto inline int
> +static inline int
>  __attribute__((always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>  # ifndef RTLD_BOOTSTRAP
>    ElfW(Addr) *got;
> @@ -899,7 +903,7 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>      }
>  
>    /* Relocate global offset table.  */
> -  elf_machine_got_rel (l, lazy);
> +  elf_machine_got_rel (l, scope, lazy);
>  
>    /* If using PLTs, fill in the first two entries of .got.plt.  */
>    if (l->l_info[DT_JMPREL] && lazy)

Ok.

> diff --git a/sysdeps/nios2/dl-machine.h b/sysdeps/nios2/dl-machine.h
> index e000cd081f..4de602b13d 100644
> --- a/sysdeps/nios2/dl-machine.h
> +++ b/sysdeps/nios2/dl-machine.h
> @@ -67,7 +67,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    extern void _dl_runtime_resolve (Elf32_Word);
>  
> @@ -234,10 +235,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>     LOADADDR is the load address of the object; INFO is an array indexed
>     by DT_* of the .dynamic section info.  */
>  
> -auto inline void __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> -                  const ElfW(Sym) *sym, const struct r_found_version *version,
> -                  void *const reloc_addr_arg, int skip_ifunc)
> +static inline void __attribute__ ((always_inline))
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
> +		  const struct r_found_version *version,
> +		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>    const unsigned int r_type = ELF32_R_TYPE (reloc->r_info);
> @@ -249,7 +251,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>    else
>      {
>        const Elf32_Sym *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        switch (r_type)
> @@ -314,7 +317,7 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>      }
>  }
>  
> -auto inline void __attribute__((always_inline))
> +static inline void __attribute__((always_inline))
>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  			   void *const reloc_addr_arg)
>  {
> @@ -322,8 +325,8 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void __attribute__((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void __attribute__((always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/powerpc/powerpc32/dl-machine.h b/sysdeps/powerpc/powerpc32/dl-machine.h
> index ced3a7b659..cda012dc1b 100644
> --- a/sysdeps/powerpc/powerpc32/dl-machine.h
> +++ b/sysdeps/powerpc/powerpc32/dl-machine.h
> @@ -109,8 +109,6 @@ elf_machine_load_address (void)
>    return runtime_dynamic - elf_machine_dynamic ();
>  }
>  
> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
> -
>  /* The PLT uses Elf32_Rela relocs.  */
>  #define elf_machine_relplt elf_machine_rela
>  

I think this snippet was already pushed in a previou patch.

> @@ -172,7 +170,7 @@ extern int __elf_machine_runtime_setup (struct link_map *map,
>  					int lazy, int profile);
>  
>  static inline int
> -elf_machine_runtime_setup (struct link_map *map,
> +elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
>  			   int lazy, int profile)
>  {
>    if (map->l_info[DT_JMPREL] == 0)
> @@ -286,9 +284,10 @@ extern void _dl_reloc_overflow (struct link_map *map,
>     LOADADDR is the load address of the object; INFO is an array indexed
>     by DT_* of the .dynamic section info.  */
>  
> -auto inline void __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +static inline void __attribute__ ((always_inline))
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -317,7 +316,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>    else
>      {
> -      sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>      }
>    value += reloc->r_addend;
> @@ -441,7 +440,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>  }
>  
> -auto inline void __attribute__ ((always_inline))
> +static inline void __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
>  {
> @@ -449,8 +448,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void __attribute__ ((always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/powerpc/powerpc64/dl-machine.h b/sysdeps/powerpc/powerpc64/dl-machine.h
> index b90f407119..3f92fbb369 100644
> --- a/sysdeps/powerpc/powerpc64/dl-machine.h
> +++ b/sysdeps/powerpc/powerpc64/dl-machine.h
> @@ -116,8 +116,6 @@ elf_machine_dynamic (void)
>    return runtime_dynamic - elf_machine_load_address() ;
>  }
>  
> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
> -
>  /* The PLT uses Elf64_Rela relocs.  */
>  #define elf_machine_relplt elf_machine_rela
>  

I think this snippet was already pushed in a previou patch.

> @@ -345,7 +343,8 @@ dl_platform_init (void)
>  /* Set up the loaded object described by MAP so its unrelocated PLT
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  static inline int __attribute__ ((always_inline))
> -elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    if (map->l_info[DT_JMPREL])
>      {
> @@ -620,7 +619,7 @@ extern void attribute_hidden _dl_reloc_overflow (struct link_map *map,
>  						 Elf64_Addr *const reloc_addr,
>  						 const Elf64_Sym *refsym);
>  
> -auto inline void __attribute__ ((always_inline))
> +static inline void __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  			   void *const reloc_addr_arg)
>  {
> @@ -629,7 +628,7 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  }
>  
>  /* This computes the value used by TPREL* relocs.  */
> -auto inline Elf64_Addr __attribute__ ((always_inline, const))
> +static inline Elf64_Addr __attribute__ ((always_inline, const))
>  elf_machine_tprel (struct link_map *map,
>  		   struct link_map *sym_map,
>  		   const Elf64_Sym *sym,
> @@ -648,7 +647,7 @@ elf_machine_tprel (struct link_map *map,
>  }
>  
>  /* Call function at address VALUE (an OPD entry) to resolve ifunc relocs.  */
> -auto inline Elf64_Addr __attribute__ ((always_inline))
> +static inline Elf64_Addr __attribute__ ((always_inline))
>  resolve_ifunc (Elf64_Addr value,
>  	       const struct link_map *map, const struct link_map *sym_map)
>  {
> @@ -678,8 +677,8 @@ resolve_ifunc (Elf64_Addr value,
>  
>  /* Perform the relocation specified by RELOC and SYM (which is fully
>     resolved).  MAP is the object containing the reloc.  */
> -auto inline void __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map,
> +static inline void __attribute__ ((always_inline))
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>  		  const Elf64_Rela *reloc,
>  		  const Elf64_Sym *sym,
>  		  const struct r_found_version *version,
> @@ -707,7 +706,7 @@ elf_machine_rela (struct link_map *map,
>  
>    /* We need SYM_MAP even in the absence of TLS, for elf_machine_fixup_plt
>       and STT_GNU_IFUNC.  */
> -  struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +  struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>    Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
>  
>    if (sym != NULL
> @@ -1037,8 +1036,8 @@ elf_machine_rela (struct link_map *map,
>    MODIFIED_CODE_NOQUEUE (reloc_addr);
>  }
>  
> -auto inline void __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +static inline void __attribute__ ((always_inline))
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  		      int skip_ifunc)
>  {

Ok.

> diff --git a/sysdeps/riscv/dl-machine.h b/sysdeps/riscv/dl-machine.h
> index 5b0746175c..e7289d7ddc 100644
> --- a/sysdeps/riscv/dl-machine.h
> +++ b/sysdeps/riscv/dl-machine.h
> @@ -161,17 +161,18 @@ elf_machine_fixup_plt (struct link_map *map, lookup_t t,
>     by RELOC_ADDR.  SYM is the relocation symbol specified by R_INFO and
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr, int skip_ifunc)
>  {
>    ElfW(Addr) r_info = reloc->r_info;
>    const unsigned long int r_type = ELFW (R_TYPE) (r_info);
>    ElfW(Addr) *addr_field = (ElfW(Addr) *) reloc_addr;
>    const ElfW(Sym) *const __attribute__ ((unused)) refsym = sym;
> -  struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +  struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>    ElfW(Addr) value = 0;
>    if (sym_map != NULL)
>      value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
> @@ -279,7 +280,7 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  			  void *const reloc_addr)
> @@ -287,10 +288,11 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>    *(ElfW(Addr) *) reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
> -		      const ElfW(Rela) *reloc, int skip_ifunc)
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
> +		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
> +		      int skip_ifunc)
>  {
>    ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
>    const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
> @@ -320,9 +322,10 @@ elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
>  /* Set up the loaded object described by L so its stub function
>     will jump to the on-demand fixup code __dl_runtime_resolve.  */
>  
> -auto inline int
> +static inline int
>  __attribute__ ((always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>  #ifndef RTLD_BOOTSTRAP
>    /* If using PLTs, fill in the first two entries of .got.plt.  */

Ok.

> diff --git a/sysdeps/s390/s390-32/dl-machine.h b/sysdeps/s390/s390-32/dl-machine.h
> index 73cc007e34..cd16cc7e00 100644
> --- a/sysdeps/s390/s390-32/dl-machine.h
> +++ b/sysdeps/s390/s390-32/dl-machine.h
> @@ -84,7 +84,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    extern void _dl_runtime_resolve (Elf32_Word);
>    extern void _dl_runtime_profile (Elf32_Word);
> @@ -320,10 +321,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -356,7 +358,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>        /* Only needed for R_390_COPY below.  */
>        const Elf32_Sym *const refsym = sym;
>  #endif
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -483,7 +486,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -492,9 +495,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {


Ok.

> diff --git a/sysdeps/s390/s390-64/dl-machine.h b/sysdeps/s390/s390-64/dl-machine.h
> index aa9d524bac..0330a8d7de 100644
> --- a/sysdeps/s390/s390-64/dl-machine.h
> +++ b/sysdeps/s390/s390-64/dl-machine.h
> @@ -74,7 +74,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    extern void _dl_runtime_resolve (Elf64_Word);
>    extern void _dl_runtime_profile (Elf64_Word);
> @@ -267,10 +268,11 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
> -		  const Elf64_Sym *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf64_Rela *reloc, const Elf64_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf64_Addr *const reloc_addr = reloc_addr_arg;
> @@ -303,7 +305,8 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>        /* Only needed for R_390_COPY below.  */
>        const Elf64_Sym *const refsym = sym;
>  #endif
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -437,7 +440,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -446,9 +449,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  		      int skip_ifunc)
>  {


Ok.

> diff --git a/sysdeps/sh/dl-machine.h b/sysdeps/sh/dl-machine.h
> index 122b417a17..0c22dfd848 100644
> --- a/sysdeps/sh/dl-machine.h
> +++ b/sysdeps/sh/dl-machine.h
> @@ -69,7 +69,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused, always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf32_Addr *got;
>    extern void _dl_runtime_resolve (Elf32_Word);
> @@ -259,10 +260,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -318,7 +320,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>    else
>      {
>        const Elf32_Sym *const refsym = sym;
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>  
>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>        value += reloc->r_addend;
> @@ -424,7 +427,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -443,9 +446,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  #undef COPY_UNALIGNED_WORD
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {


Ok.

> diff --git a/sysdeps/sparc/sparc32/dl-machine.h b/sysdeps/sparc/sparc32/dl-machine.h
> index 0269e458ea..6361cfae9e 100644
> --- a/sysdeps/sparc/sparc32/dl-machine.h
> +++ b/sysdeps/sparc/sparc32/dl-machine.h
> @@ -97,7 +97,8 @@ elf_machine_load_address (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf32_Addr *plt;
>    extern void _dl_runtime_resolve (Elf32_Word);
> @@ -327,10 +328,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
> -		  const Elf32_Sym *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
> @@ -381,7 +383,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>    else
>      {
> -      sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>      }
>  #else
> @@ -536,7 +538,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -545,9 +547,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>    *reloc_addr += l_addr + reloc->r_addend;
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>  		      int skip_ifunc)
>  {


Ok.

> diff --git a/sysdeps/sparc/sparc64/dl-machine.h b/sysdeps/sparc/sparc64/dl-machine.h
> index bbd4566d8a..3fd18c6e5e 100644
> --- a/sysdeps/sparc/sparc64/dl-machine.h
> +++ b/sysdeps/sparc/sparc64/dl-machine.h
> @@ -126,7 +126,8 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    if (l->l_info[DT_JMPREL] && lazy)
>      {
> @@ -354,10 +355,11 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
> -		  const Elf64_Sym *sym, const struct r_found_version *version,
> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
> +		  const Elf64_Rela *reloc, const Elf64_Sym *sym,
> +		  const struct r_found_version *version,
>  		  void *const reloc_addr_arg, int skip_ifunc)
>  {
>    Elf64_Addr *const reloc_addr = reloc_addr_arg;
> @@ -408,7 +410,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>      }
>    else
>      {
> -      sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>      }
>  #else
> @@ -646,7 +648,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  			   void *const reloc_addr_arg)
> @@ -655,9 +657,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>    *reloc_addr = l_addr + reloc->r_addend;
>  }
>  
> -auto inline void
> +static inline void
>  __attribute__ ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>  		      int skip_ifunc)
>  {


Ok.

> diff --git a/sysdeps/x86_64/dl-machine.h b/sysdeps/x86_64/dl-machine.h
> index b3ed4dd467..9c0182d597 100644
> --- a/sysdeps/x86_64/dl-machine.h
> +++ b/sysdeps/x86_64/dl-machine.h
> @@ -54,7 +54,8 @@ elf_machine_dynamic (void)
>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>  
>  static inline int __attribute__ ((unused, always_inline))
> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
> +			   int lazy, int profile)
>  {
>    Elf64_Addr *got;
>    extern void _dl_runtime_resolve_fxsave (ElfW(Word)) attribute_hidden;
> @@ -250,12 +251,11 @@ elf_machine_plt_value (struct link_map *map, const ElfW(Rela) *reloc,
>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>     MAP is the object containing the reloc.  */
>  
> -auto inline void
> -__attribute__ ((always_inline))
> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
> -		  void *const reloc_addr_arg, int skip_ifunc)
> -{
> +static inline void __attribute__((always_inline))
> +elf_machine_rela(struct link_map *map, struct r_scope_elem *scope[],
> +		 const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
> +		 const struct r_found_version *version,
> +		 void *const reloc_addr_arg, int skip_ifunc) {
>    ElfW(Addr) *const reloc_addr = reloc_addr_arg;
>    const unsigned long int r_type = ELFW(R_TYPE) (reloc->r_info);
>  
> @@ -292,7 +292,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>  # ifndef RTLD_BOOTSTRAP
>        const ElfW(Sym) *const refsym = sym;
>  # endif
> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
> +					      r_type);
>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>  
>        if (sym != NULL
> @@ -517,7 +518,7 @@ and creates an unsatisfiable circular dependency.\n",
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  			   void *const reloc_addr_arg)
> @@ -536,9 +537,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>      }
>  }
>  
> -auto inline void
> +static inline void
>  __attribute ((always_inline))
> -elf_machine_lazy_rel (struct link_map *map,
> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>  		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>  		      int skip_ifunc)
>  {
> @@ -572,7 +573,7 @@ elf_machine_lazy_rel (struct link_map *map,
>  
>        /* Always initialize TLS descriptors completely at load time, in
>  	 case static TLS is allocated for it that requires locking.  */
> -      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
> +      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr, skip_ifunc);
>      }
>    else if (__glibc_unlikely (r_type == R_X86_64_IRELATIVE))
>      {
> 


Ok.
H.J. Lu Sept. 29, 2021, 6:49 p.m. UTC | #3
On Wed, Sep 29, 2021 at 11:36 AM Adhemerval Zanella via Libc-alpha
<libc-alpha@sourceware.org> wrote:
>
>
>
> On 24/09/2021 17:49, Fangrui Song wrote:
> > [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
> > This version fixes all ports and doesn't add NESTING dispatches.]
> > [Available at
> > https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
> >
> > dynamic-link.h is included more than once in some elf/ files (rtld.c,
> > dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
> > functions. This harms readability and the nested functions usage
> > is the biggest obstacle prevents CC=clang (which doesn't support the
> > feature).
> >
> > The key idea for unnesting is to add extra parameters (link_map * and
> > r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
> > ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
> > elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
> > implementation in the google/grte/v5-2.27/master which uses static
> > variables.)
> >
> > Future simplification:
> > * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
> >   elf_machine_runtime_setup can drop the `scope` parameter.
> > * If TLSDESC no longer need to be in elf_machine_lazy_rel,
> >   elf_machine_lazy_rel can drop the `scope` parameter.
> >
> > Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
> >
> > Tested build-many-glibcs.py glibcs with
> > {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
> > arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
> > ---
> > Changes from v1
> > * Remove global variables: cur_l, cur_scope, cur_strtab
> > ---
> > Changes from v2
> > * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
>
> Some minor comments below.  The architecture changes are mostly
> mechanical and the bulk the change seems good, however there are
> some regressions with --enable-static-pie:
>
> $ grep ^FAIL x86_64-linux-gnu/tests.sum
> FAIL: elf/tst-tls1-static-non-pie
> FAIL: gmon/tst-gmon-static
> FAIL: gmon/tst-gmon-static-gprof
>
> $ grep ^FAIL i686-linux-gnu/tests.sum
> FAIL: elf/tst-tls1-static-non-pie
> FAIL: gmon/tst-gmon-static
> FAIL: gmon/tst-gmon-static-gprof

These must be fixed.

H.J.
Fangrui Song Oct. 2, 2021, 5:27 a.m. UTC | #4
On 2021-09-29, Adhemerval Zanella wrote:
>
>
>On 24/09/2021 17:49, Fangrui Song wrote:
>> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
>> This version fixes all ports and doesn't add NESTING dispatches.]
>> [Available at
>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
>>
>> dynamic-link.h is included more than once in some elf/ files (rtld.c,
>> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
>> functions. This harms readability and the nested functions usage
>> is the biggest obstacle prevents CC=clang (which doesn't support the
>> feature).
>>
>> The key idea for unnesting is to add extra parameters (link_map * and
>> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
>> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
>> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
>> implementation in the google/grte/v5-2.27/master which uses static
>> variables.)
>>
>> Future simplification:
>> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
>>   elf_machine_runtime_setup can drop the `scope` parameter.
>> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
>>   elf_machine_lazy_rel can drop the `scope` parameter.
>>
>> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
>>
>> Tested build-many-glibcs.py glibcs with
>> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
>> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
>> ---
>> Changes from v1
>> * Remove global variables: cur_l, cur_scope, cur_strtab
>> ---
>> Changes from v2
>> * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
>
>Some minor comments below.  The architecture changes are mostly
>mechanical and the bulk the change seems good, however there are
>some regressions with --enable-static-pie:

Many thanks for your review!
Pushed changes to https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
but not sending v4 yet.

>$ grep ^FAIL x86_64-linux-gnu/tests.sum
>FAIL: elf/tst-tls1-static-non-pie
>FAIL: gmon/tst-gmon-static
>FAIL: gmon/tst-gmon-static-gprof
>
>$ grep ^FAIL i686-linux-gnu/tests.sum
>FAIL: elf/tst-tls1-static-non-pie
>FAIL: gmon/tst-gmon-static
>FAIL: gmon/tst-gmon-static-gprof

Weird? I rebased
https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
on current origin/master.

I don't see them failing in --enable-static-pie mode.

(If non-pie static mode had any issue, more tests would fail.)

>The aarch64-linux-gnu with --enable-static-pie shows no regression.
>
>I also have tested on powerpc64le, powerpc64, powerpc32, sparc64, sparcv9,
>s390x, s390, hppa, ia64, and armhf without any regression.  I am still
>running tests on alpha and mips64, so I hopelfully see if anything
>breaks before v4.

Thanks for testing!

>> ---
>>  elf/dl-conflict.c                      | 39 ++++++++--------
>>  elf/dl-reloc-static-pie.c              | 15 ++++---
>>  elf/dl-reloc.c                         | 57 +++++++++++------------
>>  elf/do-rel.h                           | 16 +++----
>>  elf/dynamic-link.h                     | 62 +++++++++++++-------------
>>  elf/get-dynamic-info.h                 | 15 +++----
>>  elf/rtld.c                             | 15 +++----
>>  sysdeps/aarch64/dl-machine.h           | 22 +++++----
>>  sysdeps/alpha/dl-machine.h             | 16 ++++---
>>  sysdeps/arc/dl-machine.h               | 18 +++++---
>>  sysdeps/arm/dl-machine.h               | 34 +++++++-------
>>  sysdeps/csky/dl-machine.h              | 19 ++++----
>>  sysdeps/hppa/dl-machine.h              | 23 +++++-----
>>  sysdeps/i386/dl-machine.h              | 40 ++++++++++-------
>>  sysdeps/ia64/dl-machine.h              | 22 ++++-----
>>  sysdeps/m68k/dl-machine.h              | 19 ++++----
>>  sysdeps/microblaze/dl-machine.h        | 19 ++++----
>>  sysdeps/mips/dl-machine.h              | 58 +++++++++++++-----------
>>  sysdeps/nios2/dl-machine.h             | 21 +++++----
>>  sysdeps/powerpc/powerpc32/dl-machine.h | 19 ++++----
>>  sysdeps/powerpc/powerpc64/dl-machine.h | 21 +++++----
>>  sysdeps/riscv/dl-machine.h             | 23 +++++-----
>>  sysdeps/s390/s390-32/dl-machine.h      | 19 ++++----
>>  sysdeps/s390/s390-64/dl-machine.h      | 19 ++++----
>>  sysdeps/sh/dl-machine.h                | 19 ++++----
>>  sysdeps/sparc/sparc32/dl-machine.h     | 18 ++++----
>>  sysdeps/sparc/sparc64/dl-machine.h     | 18 ++++----
>>  sysdeps/x86_64/dl-machine.h            | 25 ++++++-----
>>  28 files changed, 382 insertions(+), 329 deletions(-)
>>
>> diff --git a/elf/dl-conflict.c b/elf/dl-conflict.c
>> index 64fa5793d2..1d69b5cd9f 100644
>> --- a/elf/dl-conflict.c
>> +++ b/elf/dl-conflict.c
>> @@ -26,20 +26,12 @@
>>  #include <sys/types.h>
>>  #include "dynamic-link.h"
>>
>> -void
>> -_dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
>> -		       ElfW(Rela) *conflictend)
>> -{
>> -#if ! ELF_MACHINE_NO_RELA
>> -  if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
>> -    _dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name));
>> -
>> -  {
>> -    /* Do the conflict relocation of the object and library GOT and other
>> -       data.  */
>> +/* Used by RESOLVE_CONFLICT_FIND_MAP at init time. Cannot be accessed
>
>I think it would be better to extend the comment explaining why exaclty
>it is not accessed concurrently even though the function that uses it
>(elf_machine_rela) might be used on lazy resolution.  Something like:
>
>/* Used at loading time for solely for prelink executable.  It is not
>   called concurrently so it is be safe to defined as static).  */

Thanks! Incorporated your suggestion.

>> + * concurrently.  */
>> +static struct link_map *resolve_conflict_map __attribute__ ((__unused__));
>>
>>      /* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code.  */
>> -#define RESOLVE_MAP(ref, version, flags) (*ref = NULL, NULL)
>> +#define RESOLVE_MAP(map, scope, ref, version, flags) (*ref = NULL, NULL)
>>  #define RESOLVE(ref, version, flags) (*ref = NULL, 0)
>>  #define RESOLVE_CONFLICT_FIND_MAP(map, r_offset) \
>>    do {									      \
>> @@ -50,12 +42,23 @@ _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
>>      (map) = resolve_conflict_map;					      \
>>    } while (0)
>>
>> +#include "dynamic-link.h"
>> +
>> +void
>> +_dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
>> +		       ElfW(Rela) *conflictend)
>> +{
>> +#if ! ELF_MACHINE_NO_RELA
>> +  if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
>> +    _dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name));
>> +
>> +  {
>> +    /* Do the conflict relocation of the object and library GOT and other
>> +       data.  */
>> +
>>      /* Prelinking makes no sense for anything but the main namespace.  */
>>      assert (l->l_ns == LM_ID_BASE);
>> -    struct link_map *resolve_conflict_map __attribute__ ((__unused__))
>> -      = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
>> -
>> -#include "dynamic-link.h"
>> +    resolve_conflict_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
>>
>>      /* Override these, defined in dynamic-link.h.  */
>>  #undef CHECK_STATIC_TLS
>> @@ -66,8 +69,8 @@ _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
>>      GL(dl_num_cache_relocations) += conflictend - conflict;
>>
>>      for (; conflict < conflictend; ++conflict)
>> -      elf_machine_rela (l, conflict, NULL, NULL, (void *) conflict->r_offset,
>> -			0);
>> +      elf_machine_rela (l, NULL, conflict, NULL, NULL,
>> +			(void *) conflict->r_offset, 0);
>>    }
>>  #endif
>>  }
>
>Ok.
>
>> diff --git a/elf/dl-reloc-static-pie.c b/elf/dl-reloc-static-pie.c
>> index 68ded176cd..4007580453 100644
>> --- a/elf/dl-reloc-static-pie.c
>> +++ b/elf/dl-reloc-static-pie.c
>> @@ -19,8 +19,14 @@
>>  #if ENABLE_STATIC_PIE
>>  /* Mark symbols hidden in static PIE for early self relocation to work.  */
>>  # pragma GCC visibility push(hidden)
>> +#include <assert.h>
>>  #include <unistd.h>
>>  #include <ldsodefs.h>
>> +
>> +#include <dl-machine.h>
>> +
>> +#define STATIC_PIE_BOOTSTRAP
>> +#define RESOLVE_MAP(map, scope, sym, version, flags) map
>>  #include "dynamic-link.h"
>>
>>  /* Relocate static executable with PIE.  */
>> @@ -30,11 +36,6 @@ _dl_relocate_static_pie (void)
>>  {
>>    struct link_map *main_map = _dl_get_dl_main_map ();
>>
>> -# define STATIC_PIE_BOOTSTRAP
>> -# define BOOTSTRAP_MAP (main_map)
>> -# define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
>> -# include "dynamic-link.h"
>> -
>>    /* Figure out the run-time load address of static PIE.  */
>>    main_map->l_addr = elf_machine_load_address ();
>>
>> @@ -53,12 +54,12 @@ _dl_relocate_static_pie (void)
>>    elf_get_dynamic_info (main_map);
>>
>>  # ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
>> -  ELF_MACHINE_BEFORE_RTLD_RELOC (main_map->l_info);
>> +  ELF_MACHINE_BEFORE_RTLD_RELOC (main_map, main_map->l_info);
>>  # endif
>>
>>    /* Relocate ourselves so we can do normal function calls and
>>       data access using the global offset table.  */
>> -  ELF_DYNAMIC_RELOCATE (main_map, 0, 0, 0);
>> +  ELF_DYNAMIC_RELOCATE (main_map, NULL, 0, 0, 0);
>>    main_map->l_relocated = 1;
>>
>>    /* Initialize _r_debug_extended.  */
>
>Ok.
>
>> diff --git a/elf/dl-reloc.c b/elf/dl-reloc.c
>> index 6c957456b8..8867e32c9e 100644
>> --- a/elf/dl-reloc.c
>> +++ b/elf/dl-reloc.c
>> @@ -162,6 +162,32 @@ _dl_nothread_init_static_tls (struct link_map *map)
>>  }
>>  #endif /* !PTHREAD_IN_LIBC */
>>
>> +/* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code.  */
>> +#define RESOLVE_MAP(l, scope, ref, version, r_type)			      \
>> +    ((ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL			      \
>> +      && __glibc_likely (!dl_symbol_visibility_binds_local_p (*ref)))	      \
>> +     ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0)		      \
>
>Since you changing, use __glibc_likely as well.

I think you meant __glibc_unlikely. Changed.

>> +	 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class)  \
>> +	? (bump_num_cache_relocations (),				      \
>> +	   (*ref) = l->l_lookup_cache.ret,				      \
>> +	   l->l_lookup_cache.value)					      \
>> +	: ({ lookup_t _lr;						      \
>> +	     int _tc = elf_machine_type_class (r_type);			      \
>> +	     l->l_lookup_cache.type_class = _tc;			      \
>> +	     l->l_lookup_cache.sym = (*ref);				      \
>> +	     const struct r_found_version *v = NULL;			      \
>> +	     if ((version) != NULL && (version)->hash != 0)		      \
>> +	       v = (version);						      \
>> +	     _lr = _dl_lookup_symbol_x ((const char *) D_PTR (l, l_info[DT_STRTAB]) + (*ref)->st_name, \
>> +					l, (ref), scope, v, _tc,	      \
>> +					DL_LOOKUP_ADD_DEPENDENCY	      \
>> +					| DL_LOOKUP_FOR_RELOCATE, NULL);      \
>> +	     l->l_lookup_cache.ret = (*ref);				      \
>> +	     l->l_lookup_cache.value = _lr; }))				      \
>> +     : l)
>> +
>> +#include "dynamic-link.h"
>> +
>>  void
>>  _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
>>  		     int reloc_mode, int consider_profiling)
>
>Ok.
>
>> @@ -243,36 +269,7 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
>>    {
>>      /* Do the actual relocation of the object's GOT and other data.  */
>>
>> -    /* String table object symbols.  */
>> -    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, r_type) \
>> -    ((ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL			      \
>> -      && __glibc_likely (!dl_symbol_visibility_binds_local_p (*ref)))	      \
>> -     ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0)		      \
>> -	 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class)  \
>> -	? (bump_num_cache_relocations (),				      \
>> -	   (*ref) = l->l_lookup_cache.ret,				      \
>> -	   l->l_lookup_cache.value)					      \
>> -	: ({ lookup_t _lr;						      \
>> -	     int _tc = elf_machine_type_class (r_type);			      \
>> -	     l->l_lookup_cache.type_class = _tc;			      \
>> -	     l->l_lookup_cache.sym = (*ref);				      \
>> -	     const struct r_found_version *v = NULL;			      \
>> -	     if ((version) != NULL && (version)->hash != 0)		      \
>> -	       v = (version);						      \
>> -	     _lr = _dl_lookup_symbol_x (strtab + (*ref)->st_name, l, (ref),   \
>> -					scope, v, _tc,			      \
>> -					DL_LOOKUP_ADD_DEPENDENCY	      \
>> -					| DL_LOOKUP_FOR_RELOCATE, NULL);      \
>> -	     l->l_lookup_cache.ret = (*ref);				      \
>> -	     l->l_lookup_cache.value = _lr; }))				      \
>> -     : l)
>> -
>> -#include "dynamic-link.h"
>> -
>> -    ELF_DYNAMIC_RELOCATE (l, lazy, consider_profiling, skip_ifunc);
>> +    ELF_DYNAMIC_RELOCATE (l, scope, lazy, consider_profiling, skip_ifunc);
>>
>>  #ifndef PROF
>>      if (__glibc_unlikely (consider_profiling)
>
>Ok.
>
>> diff --git a/elf/do-rel.h b/elf/do-rel.h
>> index 321ac2b359..f441b74919 100644
>> --- a/elf/do-rel.h
>> +++ b/elf/do-rel.h
>> @@ -37,8 +37,8 @@
>>     relocations; they should be set up to call _dl_runtime_resolve, rather
>>     than fully resolved now.  */
>>
>> -auto inline void __attribute__ ((always_inline))
>> -elf_dynamic_do_Rel (struct link_map *map,
>> +static inline void __attribute__ ((always_inline))
>> +elf_dynamic_do_Rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		    ElfW(Addr) reladdr, ElfW(Addr) relsize,
>>  		    __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative,
>>  		    int lazy, int skip_ifunc)
>
>Ok.
>
>> @@ -68,13 +68,13 @@ elf_dynamic_do_Rel (struct link_map *map,
>>  	  }
>>  	else
>>  # endif
>> -	  elf_machine_lazy_rel (map, l_addr, r, skip_ifunc);
>> +	  elf_machine_lazy_rel (map, scope, l_addr, r, skip_ifunc);
>>
>>  # ifdef ELF_MACHINE_IRELATIVE
>>        if (r2 != NULL)
>>  	for (; r2 <= end2; ++r2)
>>  	  if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
>> -	    elf_machine_lazy_rel (map, l_addr, r2, skip_ifunc);
>> +	    elf_machine_lazy_rel (map, scope, l_addr, r2, skip_ifunc);
>>  # endif
>>      }
>>    else
>
>Ok.
>
>> @@ -134,7 +134,7 @@ elf_dynamic_do_Rel (struct link_map *map,
>>  #endif
>>
>>  	      ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
>> -	      elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)],
>> +	      elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)],
>>  			       &map->l_versions[ndx],
>>  			       (void *) (l_addr + r->r_offset), skip_ifunc);
>>  	    }
>> @@ -146,7 +146,7 @@ elf_dynamic_do_Rel (struct link_map *map,
>>  		{
>>  		  ElfW(Half) ndx
>>  		    = version[ELFW(R_SYM) (r2->r_info)] & 0x7fff;
>> -		  elf_machine_rel (map, r2,
>> +		  elf_machine_rel (map, scope, r2,
>>  				   &symtab[ELFW(R_SYM) (r2->r_info)],
>>  				   &map->l_versions[ndx],
>>  				   (void *) (l_addr + r2->r_offset),
>
>Ok.
>
>> @@ -167,14 +167,14 @@ elf_dynamic_do_Rel (struct link_map *map,
>>  	      }
>>  	    else
>>  # endif
>> -	      elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
>> +	      elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
>>  			       (void *) (l_addr + r->r_offset), skip_ifunc);
>>
>>  # ifdef ELF_MACHINE_IRELATIVE
>>  	  if (r2 != NULL)
>>  	    for (; r2 <= end2; ++r2)
>>  	      if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
>> -		elf_machine_rel (map, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
>> +		elf_machine_rel (map, scope, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
>>  				 NULL, (void *) (l_addr + r2->r_offset),
>>  				 skip_ifunc);
>>  # endif
>
>Ok.
>
>> diff --git a/elf/dynamic-link.h b/elf/dynamic-link.h
>> index 3eb24ba3a6..f3f6c3bcac 100644
>> --- a/elf/dynamic-link.h
>> +++ b/elf/dynamic-link.h
>> @@ -59,31 +59,33 @@ int _dl_try_allocate_static_tls (struct link_map *map, bool optional)
>>     copying memory, breaking the very code written to handle the
>>     unaligned cases.  */
>>  # if ! ELF_MACHINE_NO_REL
>> -auto inline void __attribute__((always_inline))
>> -elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
>> -		 const ElfW(Sym) *sym, const struct r_found_version *version,
>> +static inline void __attribute__((always_inline))
>> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
>> +		 const ElfW(Rel) *reloc, const ElfW(Sym) *sym,
>> +		 const struct r_found_version *version,
>>  		 void *const reloc_addr, int skip_ifunc);
>> -auto inline void __attribute__((always_inline))
>> +static inline void __attribute__((always_inline))
>>  elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>>  			  void *const reloc_addr);
>>  # endif
>>  # if ! ELF_MACHINE_NO_RELA
>> -auto inline void __attribute__((always_inline))
>> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
>> -		  void *const reloc_addr, int skip_ifunc);
>> -auto inline void __attribute__((always_inline))
>> -elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>> -			   void *const reloc_addr);
>> +static inline void __attribute__((always_inline))
>> +elf_machine_rela(struct link_map *map, struct r_scope_elem *scope[],
>
>Space after name.

Updated.

>> +		 const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
>> +		 const struct r_found_version *version, void *const reloc_addr,
>> +		 int skip_ifunc);
>> +static inline void __attribute__((always_inline))
>> +elf_machine_rela_relative(ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>
>Ditto

Updated.

>> +	                  void *const reloc_addr);
>>  # endif
>>  # if ELF_MACHINE_NO_RELA || defined ELF_MACHINE_PLT_REL
>> -auto inline void __attribute__((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void __attribute__((always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>>  		      int skip_ifunc);
>>  # else
>> -auto inline void __attribute__((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void __attribute__((always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>  		      int skip_ifunc);
>>  # endif
>
>Ok.
>
>> @@ -114,7 +116,7 @@ elf_machine_lazy_rel (struct link_map *map,
>>     consumes precisely the very end of the DT_REL*, or DT_JMPREL and DT_REL*
>>     are completely separate and there is a gap between them.  */
>>
>> -# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, do_lazy, skip_ifunc, test_rel) \
>> +# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, scope, do_lazy, skip_ifunc, test_rel) \
>>    do {									      \
>>      struct { ElfW(Addr) start, size;					      \
>>  	     __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative; int lazy; }  \
>> @@ -152,18 +154,18 @@ elf_machine_lazy_rel (struct link_map *map,
>>        }									      \
>>  									      \
>>      if (ELF_DURING_STARTUP)						      \
>> -      elf_dynamic_do_##reloc ((map), ranges[0].start, ranges[0].size,	      \
>> -			      ranges[0].nrelative, 0, skip_ifunc);	      \
>> +      elf_dynamic_do_##reloc ((map), scope, ranges[0].start, ranges[0].size,  \
>> +			      ranges[0].nrelative, 0, skip_ifunc);  \
>>      else								      \
>>        {									      \
>>  	int ranges_index;						      \
>>  	for (ranges_index = 0; ranges_index < 2; ++ranges_index)	      \
>> -	  elf_dynamic_do_##reloc ((map),				      \
>> +	  elf_dynamic_do_##reloc ((map), scope,				      \
>>  				  ranges[ranges_index].start,		      \
>>  				  ranges[ranges_index].size,		      \
>>  				  ranges[ranges_index].nrelative,	      \
>>  				  ranges[ranges_index].lazy,		      \
>> -				  skip_ifunc);				      \
>> +				  skip_ifunc);		      \
>>        }									      \
>>    } while (0)
>>
>
>Ok.
>
>> @@ -175,29 +177,29 @@ elf_machine_lazy_rel (struct link_map *map,
>>
>>  # if ! ELF_MACHINE_NO_REL
>>  #  include "do-rel.h"
>> -#  define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) \
>> -  _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, lazy, skip_ifunc, _ELF_CHECK_REL)
>> +#  define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc)	      \
>> +  _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL)
>>  # else
>> -#  define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) /* Nothing to do.  */
>> +#  define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc) /* Nothing to do.  */
>>  # endif
>>
>>  # if ! ELF_MACHINE_NO_RELA
>>  #  define DO_RELA
>>  #  include "do-rel.h"
>> -#  define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) \
>> -  _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, lazy, skip_ifunc, _ELF_CHECK_REL)
>> +#  define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc)	      \
>> +  _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL)
>>  # else
>> -#  define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) /* Nothing to do.  */
>> +#  define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc) /* Nothing to do.  */
>>  # endif
>>
>>  /* This can't just be an inline function because GCC is too dumb
>>     to inline functions containing inlines themselves.  */
>> -# define ELF_DYNAMIC_RELOCATE(map, lazy, consider_profile, skip_ifunc) \
>> +# define ELF_DYNAMIC_RELOCATE(map, scope, lazy, consider_profile, skip_ifunc) \
>>    do {									      \
>> -    int edr_lazy = elf_machine_runtime_setup ((map), (lazy),		      \
>> +    int edr_lazy = elf_machine_runtime_setup ((map), (scope), (lazy),	      \
>>  					      (consider_profile));	      \
>> -    ELF_DYNAMIC_DO_REL ((map), edr_lazy, skip_ifunc);			      \
>> -    ELF_DYNAMIC_DO_RELA ((map), edr_lazy, skip_ifunc);			      \
>> +    ELF_DYNAMIC_DO_REL ((map), (scope), edr_lazy, skip_ifunc);		      \
>> +    ELF_DYNAMIC_DO_RELA ((map), (scope), edr_lazy, skip_ifunc);		      \
>>    } while (0)
>>
>>  #endif
>
>Ok.
>
>> diff --git a/elf/get-dynamic-info.h b/elf/get-dynamic-info.h
>> index 4aa2058abf..15c316b38c 100644
>> --- a/elf/get-dynamic-info.h
>> +++ b/elf/get-dynamic-info.h
>> @@ -16,18 +16,15 @@
>>     License along with the GNU C Library; if not, see
>>     <https://www.gnu.org/licenses/>.  */
>>
>> -/* This file is included multiple times and therefore lacks a header
>> -   file inclusion guard.  */
>> +/* Populate dynamic tags in l_info.  */
>> +
>> +#ifndef _GET_DYNAMIC_INFO_H
>> +#define _GET_DYNAMIC_INFO_H
>>
>>  #include <assert.h>
>>  #include <libc-diag.h>
>>
>> -#ifndef RESOLVE_MAP
>> -static
>> -#else
>> -auto
>> -#endif
>> -inline void __attribute__ ((unused, always_inline))
>> +static inline void __attribute__ ((unused, always_inline))
>>  elf_get_dynamic_info (struct link_map *l)
>>  {
>>  #if __ELF_NATIVE_CLASS == 32
>> @@ -165,3 +162,5 @@ elf_get_dynamic_info (struct link_map *l)
>>      info[DT_RPATH] = NULL;
>>  #endif
>>  }
>> +
>> +#endif
>
>Ok.
>
>> diff --git a/elf/rtld.c b/elf/rtld.c
>> index 8d2bba3d43..0c27e5d486 100644
>> --- a/elf/rtld.c
>> +++ b/elf/rtld.c
>> @@ -500,13 +500,9 @@ _dl_start_final (void *arg, struct dl_start_final_info *info)
>>    return start_addr;
>>  }
>>
>> -static ElfW(Addr) __attribute_used__
>> -_dl_start (void *arg)
>> -{
>>  #ifdef DONT_USE_BOOTSTRAP_MAP
>>  # define bootstrap_map GL(dl_rtld_map)
>>  #else
>> -  struct dl_start_final_info info;
>>  # define bootstrap_map info.l
>>  #endif
>>
>> @@ -515,13 +511,16 @@ _dl_start (void *arg)
>>       Since ld.so must not have any undefined symbols the result
>>       is trivial: always the map of ld.so itself.  */
>>  #define RTLD_BOOTSTRAP
>> -#define BOOTSTRAP_MAP (&bootstrap_map)
>> -#define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
>> +#define RESOLVE_MAP(map, scope, sym, version, flags) map
>>  #include "dynamic-link.h"
>>
>> +static ElfW(Addr) __attribute_used__
>> +_dl_start (void *arg)
>> +{
>>  #ifdef DONT_USE_BOOTSTRAP_MAP
>>    rtld_timer_start (&start_time);
>>  #else
>> +  struct dl_start_final_info info;
>>    rtld_timer_start (&info.start_time);
>>  #endif
>>
>> @@ -554,7 +553,7 @@ _dl_start (void *arg)
>>  #endif
>>
>>  #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
>> -  ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
>> +  ELF_MACHINE_BEFORE_RTLD_RELOC (&bootstrap_map, bootstrap_map.l_info);
>>  #endif
>>
>>    if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
>> @@ -562,7 +561,7 @@ _dl_start (void *arg)
>>        /* Relocate ourselves so we can do normal function calls and
>>  	 data access using the global offset table.  */
>>
>> -      ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0, 0);
>> +      ELF_DYNAMIC_RELOCATE (&bootstrap_map, NULL, 0, 0, 0);
>>      }
>>    bootstrap_map.l_relocated = 1;
>>
>
>Ok.
>
>> diff --git a/sysdeps/aarch64/dl-machine.h b/sysdeps/aarch64/dl-machine.h
>> index 3e10cb462f..e30e81c902 100644
>> --- a/sysdeps/aarch64/dl-machine.h
>> +++ b/sysdeps/aarch64/dl-machine.h
>> @@ -59,7 +59,8 @@ elf_machine_dynamic (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    if (l->l_info[DT_JMPREL] && lazy)
>>      {
>> @@ -237,10 +238,11 @@ elf_machine_plt_value (struct link_map *map,
>>
>>  #ifdef RESOLVE_MAP
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    ElfW(Addr) *const reloc_addr = reloc_addr_arg;
>
>Ok.
>
>> @@ -253,7 +255,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>>    else
>>      {
>>        const ElfW(Sym) *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -377,9 +380,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      ElfW(Addr) l_addr,
>>  		      const ElfW(Rela) *reloc,
>>  		      int skip_ifunc)
>> @@ -406,7 +409,7 @@ elf_machine_lazy_rel (struct link_map *map,
>>  		    (const void *)D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
>>  		  version = &map->l_versions[vernum[symndx] & 0x7fff];
>>  		}
>> -	      elf_machine_rela (map, reloc, sym, version, reloc_addr,
>> +	      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
>>  				skip_ifunc);
>>  	      return;
>>  	    }
>> @@ -433,7 +436,8 @@ elf_machine_lazy_rel (struct link_map *map,
>>
>>        /* Always initialize TLS descriptors completely, because lazy
>>  	 initialization requires synchronization at every TLS access.  */
>> -      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
>> +      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
>> +			skip_ifunc);
>>      }
>>    else if (__glibc_unlikely (r_type == AARCH64_R(IRELATIVE)))
>>      {
>
>Ok.
>
>> diff --git a/sysdeps/alpha/dl-machine.h b/sysdeps/alpha/dl-machine.h
>> index 9e327b7f17..491541326f 100644
>> --- a/sysdeps/alpha/dl-machine.h
>> +++ b/sysdeps/alpha/dl-machine.h
>> @@ -69,7 +69,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int
>> -elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    extern char _dl_runtime_resolve_new[] attribute_hidden;
>>    extern char _dl_runtime_profile_new[] attribute_hidden;
>
>Ok.
>
>> @@ -360,9 +361,9 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>>
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>>  		  const Elf64_Rela *reloc,
>>  		  const Elf64_Sym *sym,
>>  		  const struct r_found_version *version,
>> @@ -410,7 +411,8 @@ elf_machine_rela (struct link_map *map,
>>        return;
>>    else
>>      {
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf64_Addr sym_value;
>>        Elf64_Addr sym_raw_value;
>>
>> @@ -488,7 +490,7 @@ elf_machine_rela (struct link_map *map,
>>     can be skipped.  */
>>  #define ELF_MACHINE_REL_RELATIVE 1
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -505,9 +507,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>    memcpy (reloc_addr_arg, &reloc_addr_val, 8);
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/arc/dl-machine.h b/sysdeps/arc/dl-machine.h
>> index e6ce7f0ff6..4b64ffec25 100644
>> --- a/sysdeps/arc/dl-machine.h
>> +++ b/sysdeps/arc/dl-machine.h
>> @@ -122,7 +122,8 @@ elf_machine_load_address (void)
>>
>>  static inline int
>>  __attribute__ ((always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    extern void _dl_runtime_resolve (void);
>>
>> @@ -228,10 +229,11 @@ elf_machine_fixup_plt (struct link_map *map, lookup_t t,
>>
>>  #ifdef RESOLVE_MAP
>>
>> -inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>> -                  const ElfW(Sym) *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
>> +		  const struct r_found_version *version,
>>                    void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    ElfW(Addr) r_info = reloc->r_info;
>> @@ -245,7 +247,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>>    else
>>      {
>>        const ElfW(Sym) *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        switch (r_type)
>> @@ -326,8 +329,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>
>>  inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
>> -                      const ElfW(Rela) *reloc, int skip_ifunc)
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>> +		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>> +		      int skip_ifunc)
>>  {
>>    ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
>>    const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
>
>Ok.
>
>> diff --git a/sysdeps/arm/dl-machine.h b/sysdeps/arm/dl-machine.h
>> index eb13cb8b57..68a0b4b476 100644
>> --- a/sysdeps/arm/dl-machine.h
>> +++ b/sysdeps/arm/dl-machine.h
>> @@ -57,7 +57,8 @@ elf_machine_dynamic (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf32_Addr *got;
>>    extern void _dl_runtime_resolve (Elf32_Word);
>> @@ -276,7 +277,7 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
>>
>>  #ifdef RESOLVE_MAP
>>  /* Handle a PC24 reloc, including the out-of-range case.  */
>> -auto void
>> +static void
>>  relocate_pc24 (struct link_map *map, Elf32_Addr value,
>>                 Elf32_Addr *const reloc_addr, Elf32_Sword addend)
>>  {
>> @@ -330,10 +331,11 @@ relocate_pc24 (struct link_map *map, Elf32_Addr value,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>> -		 const Elf32_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
>> +                 const Elf32_Rel *reloc, const Elf32_Sym *sym,
>> +                 const struct r_found_version *version,
>>  		 void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -364,7 +366,8 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>>  #endif
>>      {
>>        const Elf32_Sym *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -508,10 +511,11 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>>  }
>>
>>  # ifndef RTLD_BOOTSTRAP
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +                  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +                  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -526,7 +530,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>  # ifndef RESOLVE_CONFLICT_FIND_MAP
>>        const Elf32_Sym *const refsym = sym;
>>  # endif
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -601,7 +605,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>  }
>>  # endif
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>>  			  void *const reloc_addr_arg)
>> @@ -611,7 +615,7 @@ elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>>  }
>>
>>  # ifndef RTLD_BOOTSTRAP
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -621,9 +625,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  }
>>  # endif
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rel *reloc,
>>  		      int skip_ifunc)
>>  {
>> @@ -653,7 +657,7 @@ elf_machine_lazy_rel (struct link_map *map,
>>
>>        /* Always initialize TLS descriptors completely, because lazy
>>  	 initialization requires synchronization at every TLS access.  */
>> -      elf_machine_rel (map, reloc, sym, version, reloc_addr, skip_ifunc);
>> +      elf_machine_rel (map, scope, reloc, sym, version, reloc_addr, skip_ifunc);
>>      }
>>    else
>>      _dl_reloc_bad_type (map, r_type, 1);
>
>Ok.
>
>> diff --git a/sysdeps/csky/dl-machine.h b/sysdeps/csky/dl-machine.h
>> index b08f06d74c..ec22f87577 100644
>> --- a/sysdeps/csky/dl-machine.h
>> +++ b/sysdeps/csky/dl-machine.h
>> @@ -58,7 +58,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf32_Addr *got;
>>    extern void _dl_runtime_resolve (Elf32_Word);
>> @@ -215,9 +216,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void __attribute__ ((unused, always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +static inline void __attribute__ ((unused, always_inline))
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -230,7 +232,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>    else
>>      {
>>        const Elf32_Sym *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>>        opcode16_addr = (unsigned short *)reloc_addr;
>>
>> @@ -331,7 +334,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void __attribute__ ((unused, always_inline))
>> +static inline void __attribute__ ((unused, always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>>  {
>> @@ -339,8 +342,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void __attribute__ ((unused, always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void __attribute__ ((unused, always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/hppa/dl-machine.h b/sysdeps/hppa/dl-machine.h
>> index ded9c193d6..e6a4575fce 100644
>> --- a/sysdeps/hppa/dl-machine.h
>> +++ b/sysdeps/hppa/dl-machine.h
>> @@ -68,8 +68,8 @@ __hppa_init_bootstrap_fdesc_table (struct link_map *map)
>>    map->l_mach.fptr_table = boot_table;
>>  }
>>
>> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)		\
>> -	__hppa_init_bootstrap_fdesc_table (BOOTSTRAP_MAP);	\
>> +#define ELF_MACHINE_BEFORE_RTLD_RELOC(map, dynamic_info)	\
>> +	__hppa_init_bootstrap_fdesc_table (map);		\
>>  	_dl_fptr_init();
>>
>>  /* Return nonzero iff ELF header is compatible with the running host.  */
>> @@ -162,7 +162,8 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf32_Addr *got = NULL;
>>    Elf32_Addr l_addr, iplt, jmprel, end_jmprel, r_type, r_sym;
>> @@ -548,8 +549,8 @@ dl_platform_init (void)
>>    (  (((as14) & 0x1fff) << 1) \
>>     | (((as14) & 0x2000) >> 13))
>>
>> -auto void __attribute__((always_inline))
>> -elf_machine_rela (struct link_map *map,
>> +static void __attribute__((always_inline))
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>>  		  const Elf32_Rela *reloc,
>>  		  const Elf32_Sym *sym,
>>  		  const struct r_found_version *version,
>> @@ -578,11 +579,9 @@ elf_machine_rela (struct link_map *map,
>>       zeros, and an all zero Elf32_Sym has a binding of STB_LOCAL.)
>>       See RESOLVE_MAP definition in elf/dl-reloc.c  */
>>  # ifdef RTLD_BOOTSTRAP
>> -  /* RESOLVE_MAP in rtld.c doesn't have the local sym test.  */
>> -  sym_map = (ELF32_ST_BIND (sym->st_info) != STB_LOCAL
>> -	     ? RESOLVE_MAP (&sym, version, r_type) : map);
>> +  sym_map = map;
>>  # else
>> -  sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +  sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>  # endif
>>
>>    if (sym_map)
>> @@ -740,7 +739,7 @@ elf_machine_rela (struct link_map *map,
>>
>>  /* hppa doesn't have an R_PARISC_RELATIVE reloc, but uses relocs with
>>     ELF32_R_SYM (info) == 0 for a similar purpose.  */
>> -auto void __attribute__((always_inline))
>> +static void __attribute__((always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr,
>>  			   const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -793,8 +792,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr,
>>    *reloc_addr = value;
>>  }
>>
>> -auto void __attribute__((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static void __attribute__((always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/i386/dl-machine.h b/sysdeps/i386/dl-machine.h
>> index 0401888508..9f578e536a 100644
>> --- a/sysdeps/i386/dl-machine.h
>> +++ b/sysdeps/i386/dl-machine.h
>> @@ -54,7 +54,8 @@ elf_machine_dynamic (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused, always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf32_Addr *got;
>>    extern void _dl_runtime_resolve (Elf32_Word) attribute_hidden;
>> @@ -284,9 +285,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>> -elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
>> +		 const Elf32_Rel *reloc,
>>  		 const Elf32_Sym *sym, const struct r_found_version *version,
>>  		 void *const reloc_addr_arg, int skip_ifunc)
>>  {
>> @@ -320,7 +322,8 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
>>  # ifndef RTLD_BOOTSTRAP
>>        const Elf32_Sym *const refsym = sym;
>>  # endif
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -491,10 +494,11 @@ and creates an unsatisfiable circular dependency.\n",
>>  }
>>
>>  # ifndef RTLD_BOOTSTRAP
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -507,7 +511,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>  #  ifndef RESOLVE_CONFLICT_FIND_MAP
>>        const Elf32_Sym *const refsym = sym;
>>  #  endif
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -640,7 +645,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>  }
>>  # endif	/* !RTLD_BOOTSTRAP */
>>
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>>  elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>>  			  void *const reloc_addr_arg)
>> @@ -651,7 +656,7 @@ elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
>>  }
>>
>>  # ifndef RTLD_BOOTSTRAP
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -661,9 +666,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  }
>>  # endif	/* !RTLD_BOOTSTRAP */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rel *reloc,
>>  		      int skip_ifunc)
>>  {
>> @@ -698,13 +703,13 @@ elf_machine_lazy_rel (struct link_map *map,
>>  	  const ElfW(Half) *const version =
>>  	    (const void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
>>  	  ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
>> -	  elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)],
>> +	  elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)],
>>  			   &map->l_versions[ndx],
>>  			   (void *) (l_addr + r->r_offset), skip_ifunc);
>>  	}
>>  # ifndef RTLD_BOOTSTRAP
>>        else
>> -	elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
>> +	elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
>>  			 (void *) (l_addr + r->r_offset), skip_ifunc);
>>  # endif
>>      }
>> @@ -721,9 +726,9 @@ elf_machine_lazy_rel (struct link_map *map,
>>
>>  # ifndef RTLD_BOOTSTRAP
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rela (struct link_map *map,
>> +elf_machine_lazy_rela (struct link_map *map, struct r_scope_elem *scope[],
>>  		       Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		       int skip_ifunc)
>>  {
>> @@ -747,7 +752,8 @@ elf_machine_lazy_rela (struct link_map *map,
>>
>>        /* Always initialize TLS descriptors completely at load time, in
>>  	 case static TLS is allocated for it that requires locking.  */
>> -      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
>> +      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
>> +			skip_ifunc);
>>      }
>>    else if (__glibc_unlikely (r_type == R_386_IRELATIVE))
>>      {
>
>Ok.
>
>> diff --git a/sysdeps/ia64/dl-machine.h b/sysdeps/ia64/dl-machine.h
>> index 4403e7767a..2217d0b556 100644
>> --- a/sysdeps/ia64/dl-machine.h
>> +++ b/sysdeps/ia64/dl-machine.h
>> @@ -44,8 +44,8 @@ __ia64_init_bootstrap_fdesc_table (struct link_map *map)
>>    map->l_mach.fptr_table = boot_table;
>>  }
>>
>> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)		\
>> -	__ia64_init_bootstrap_fdesc_table (BOOTSTRAP_MAP);
>> +#define ELF_MACHINE_BEFORE_RTLD_RELOC(map, dynamic_info)		\
>> +	__ia64_init_bootstrap_fdesc_table (map);
>>
>>  /* Return nonzero iff ELF header is compatible with the running host.  */
>>  static inline int __attribute__ ((unused))
>> @@ -98,7 +98,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused, always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    extern void _dl_runtime_resolve (void);
>>    extern void _dl_runtime_profile (void);
>> @@ -371,9 +372,9 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>>
>>  /* Perform the relocation specified by RELOC and SYM (which is fully
>>     resolved).  MAP is the object containing the reloc.  */
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>> -elf_machine_rela (struct link_map *map,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>>  		  const Elf64_Rela *reloc,
>>  		  const Elf64_Sym *sym,
>>  		  const struct r_found_version *version,
>> @@ -414,10 +415,11 @@ elf_machine_rela (struct link_map *map,
>>        return;
>>    else
>>      {
>> -      struct link_map *sym_map;
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>
>>        /* RESOLVE_MAP() will return NULL if it fail to locate the symbol.  */
>> -      if ((sym_map = RESOLVE_MAP (&sym, version, r_type)))
>> +      if (sym_map != NULL)
>>  	{
>>  	  value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
>>
>> @@ -476,7 +478,7 @@ elf_machine_rela (struct link_map *map,
>>     can be skipped.  */
>>  #define ELF_MACHINE_REL_RELATIVE 1
>>
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -489,9 +491,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  }
>>
>>  /* Perform a RELATIVE reloc on the .got entry that transfers to the .plt.  */
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/m68k/dl-machine.h b/sysdeps/m68k/dl-machine.h
>> index 86a8c67e2a..5e34c4784e 100644
>> --- a/sysdeps/m68k/dl-machine.h
>> +++ b/sysdeps/m68k/dl-machine.h
>> @@ -68,7 +68,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf32_Addr *got;
>>    extern void _dl_runtime_resolve (Elf32_Word);
>> @@ -215,9 +216,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void __attribute__ ((unused, always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +static inline void __attribute__ ((unused, always_inline))
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -228,7 +230,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>    else
>>      {
>>        const Elf32_Sym *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        switch (r_type)
>> @@ -303,7 +306,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void __attribute__ ((unused, always_inline))
>> +static inline void __attribute__ ((unused, always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>>  {
>> @@ -311,8 +314,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void __attribute__ ((unused, always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void __attribute__ ((unused, always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/microblaze/dl-machine.h b/sysdeps/microblaze/dl-machine.h
>> index e460f6f195..3fd4988e60 100644
>> --- a/sysdeps/microblaze/dl-machine.h
>> +++ b/sysdeps/microblaze/dl-machine.h
>> @@ -69,7 +69,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    extern void _dl_runtime_resolve (Elf32_Word);
>>    extern void _dl_runtime_profile (Elf32_Word);
>> @@ -207,9 +208,10 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>      ((unsigned short *)(rel_addr))[3] = (val) & 0xffff; \
>>    } while (0)
>>
>> -auto inline void __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +static inline void __attribute__ ((always_inline))
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -222,7 +224,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>    else
>>      {
>>        const Elf32_Sym *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        value += reloc->r_addend;
>> @@ -277,7 +280,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>>  {
>> @@ -285,8 +288,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>    PUT_REL_64 (reloc_addr, l_addr + reloc->r_addend);
>>  }
>>
>> -auto inline void
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/mips/dl-machine.h b/sysdeps/mips/dl-machine.h
>> index b74d427d64..f8d1298b60 100644
>> --- a/sysdeps/mips/dl-machine.h
>> +++ b/sysdeps/mips/dl-machine.h
>> @@ -187,9 +187,9 @@ elf_machine_load_address (void)
>>
>>  /* We can't rely on elf_machine_got_rel because _dl_object_relocation_scope
>>     fiddles with global data.  */
>> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)			\
>> +#define ELF_MACHINE_BEFORE_RTLD_RELOC(bootstrap_map, dynamic_info)	\
>>  do {									\
>> -  struct link_map *map = BOOTSTRAP_MAP;					\
>> +  struct link_map *map = bootstrap_map;					\
>>    ElfW(Sym) *sym;							\
>>    ElfW(Addr) *got;							\
>>    int i, n;								\
>> @@ -474,11 +474,12 @@ elf_machine_plt_value (struct link_map *map, const ElfW(Rel) *reloc,
>>     by RELOC_ADDR.  SYM is the relocation symbol specified by R_INFO and
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>> -		   const ElfW(Sym) *sym, const struct r_found_version *version,
>> -		   void *reloc_addr, ElfW(Addr) r_addend, int inplace_p)
>> +elf_machine_reloc (struct link_map *map, struct r_scope_elem *scope[],
>> +		   ElfW(Addr) r_info, const ElfW(Sym) *sym,
>> +		   const struct r_found_version *version, void *reloc_addr,
>> +		   ElfW(Addr) r_addend, int inplace_p)
>>  {
>>    const unsigned long int r_type = ELFW(R_TYPE) (r_info);
>>    ElfW(Addr) *addr_field = (ElfW(Addr) *) reloc_addr;
>> @@ -506,7 +507,8 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>>      case R_MIPS_TLS_TPREL32:
>>  # endif
>>        {
>> -	struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +	struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +						r_type);
>>
>>  	switch (r_type)
>>  	  {
>> @@ -646,7 +648,7 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>>  	  _dl_signal_error (0, map->l_name, NULL,
>>  			    "found jump slot relocation with non-zero addend");
>>
>> -	sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +	sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>  	value = SYMBOL_ADDRESS (sym_map, sym, true);
>>  	*addr_field = value;
>>
>> @@ -660,7 +662,7 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>>  	ElfW(Addr) value;
>>
>>  	/* Calculate the address of the symbol.  */
>> -	sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +	sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>  	value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>  	if (__builtin_expect (sym == NULL, 0))
>> @@ -707,16 +709,17 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
>> -		 const ElfW(Sym) *sym, const struct r_found_version *version,
>> -		 void *const reloc_addr, int skip_ifunc)
>> +elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
>> +		 const ElfW(Rel) *reloc, const ElfW(Sym) *sym,
>> +		 const struct r_found_version *version, void *const reloc_addr,
>> +		 int skip_ifunc)
>>  {
>> -  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr, 0, 1);
>> +  elf_machine_reloc (map, scope, reloc->r_info, sym, version, reloc_addr, 0, 1);
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__((always_inline))
>>  elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>>  			  void *const reloc_addr)
>> @@ -724,9 +727,9 @@ elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>>    /* XXX Nothing to do.  There is no relative relocation, right?  */
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
>>  		      int skip_ifunc)
>>  {
>> @@ -747,17 +750,17 @@ elf_machine_lazy_rel (struct link_map *map,
>>      _dl_reloc_bad_type (map, r_type, 1);
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[], const ElfW(Rela) *reloc,
>>  		  const ElfW(Sym) *sym, const struct r_found_version *version,
>>  		  void *const reloc_addr, int skip_ifunc)
>>  {
>> -  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr,
>> +  elf_machine_reloc (map, scope, reloc->r_info, sym, version, reloc_addr,
>>  		     reloc->r_addend, 0);
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__((always_inline))
>>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>  			   void *const reloc_addr)
>> @@ -766,9 +769,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>
>>  #ifndef RTLD_BOOTSTRAP
>>  /* Relocate GOT. */
>> -auto inline void
>> +static inline void
>>  __attribute__((always_inline))
>> -elf_machine_got_rel (struct link_map *map, int lazy)
>> +elf_machine_got_rel (struct link_map *map, struct r_scope_elem *scope[], int lazy)
>>  {
>>    ElfW(Addr) *got;
>>    ElfW(Sym) *sym;
>> @@ -781,7 +784,7 @@ elf_machine_got_rel (struct link_map *map, int lazy)
>>        const struct r_found_version *version __attribute__ ((unused))	  \
>>  	= vernum ? &map->l_versions[vernum[sym_index] & 0x7fff] : NULL;	  \
>>        struct link_map *sym_map;						  \
>> -      sym_map = RESOLVE_MAP (&ref, version, reloc);			  \
>> +      sym_map = RESOLVE_MAP (map, scope, &ref, version, reloc);		  \
>>        SYMBOL_ADDRESS (sym_map, ref, true);				  \
>>      })
>>
>> @@ -867,9 +870,10 @@ elf_machine_got_rel (struct link_map *map, int lazy)
>>  /* Set up the loaded object described by L so its stub function
>>     will jump to the on-demand fixup code __dl_runtime_resolve.  */
>>
>> -auto inline int
>> +static inline int
>>  __attribute__((always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>  # ifndef RTLD_BOOTSTRAP
>>    ElfW(Addr) *got;
>> @@ -899,7 +903,7 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>>      }
>>
>>    /* Relocate global offset table.  */
>> -  elf_machine_got_rel (l, lazy);
>> +  elf_machine_got_rel (l, scope, lazy);
>>
>>    /* If using PLTs, fill in the first two entries of .got.plt.  */
>>    if (l->l_info[DT_JMPREL] && lazy)
>
>Ok.
>
>> diff --git a/sysdeps/nios2/dl-machine.h b/sysdeps/nios2/dl-machine.h
>> index e000cd081f..4de602b13d 100644
>> --- a/sysdeps/nios2/dl-machine.h
>> +++ b/sysdeps/nios2/dl-machine.h
>> @@ -67,7 +67,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    extern void _dl_runtime_resolve (Elf32_Word);
>>
>> @@ -234,10 +235,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>     LOADADDR is the load address of the object; INFO is an array indexed
>>     by DT_* of the .dynamic section info.  */
>>
>> -auto inline void __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>> -                  const ElfW(Sym) *sym, const struct r_found_version *version,
>> -                  void *const reloc_addr_arg, int skip_ifunc)
>> +static inline void __attribute__ ((always_inline))
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
>> +		  const struct r_found_version *version,
>> +		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>>    const unsigned int r_type = ELF32_R_TYPE (reloc->r_info);
>> @@ -249,7 +251,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>>    else
>>      {
>>        const Elf32_Sym *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        switch (r_type)
>> @@ -314,7 +317,7 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>>      }
>>  }
>>
>> -auto inline void __attribute__((always_inline))
>> +static inline void __attribute__((always_inline))
>>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>  			   void *const reloc_addr_arg)
>>  {
>> @@ -322,8 +325,8 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void __attribute__((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void __attribute__((always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/powerpc/powerpc32/dl-machine.h b/sysdeps/powerpc/powerpc32/dl-machine.h
>> index ced3a7b659..cda012dc1b 100644
>> --- a/sysdeps/powerpc/powerpc32/dl-machine.h
>> +++ b/sysdeps/powerpc/powerpc32/dl-machine.h
>> @@ -109,8 +109,6 @@ elf_machine_load_address (void)
>>    return runtime_dynamic - elf_machine_dynamic ();
>>  }
>>
>> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
>> -
>>  /* The PLT uses Elf32_Rela relocs.  */
>>  #define elf_machine_relplt elf_machine_rela
>>
>
>I think this snippet was already pushed in a previou patch.
>
>> @@ -172,7 +170,7 @@ extern int __elf_machine_runtime_setup (struct link_map *map,
>>  					int lazy, int profile);
>>
>>  static inline int
>> -elf_machine_runtime_setup (struct link_map *map,
>> +elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
>>  			   int lazy, int profile)
>>  {
>>    if (map->l_info[DT_JMPREL] == 0)
>> @@ -286,9 +284,10 @@ extern void _dl_reloc_overflow (struct link_map *map,
>>     LOADADDR is the load address of the object; INFO is an array indexed
>>     by DT_* of the .dynamic section info.  */
>>
>> -auto inline void __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +static inline void __attribute__ ((always_inline))
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -317,7 +316,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>    else
>>      {
>> -      sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>>      }
>>    value += reloc->r_addend;
>> @@ -441,7 +440,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void __attribute__ ((always_inline))
>> +static inline void __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>>  {
>> @@ -449,8 +448,8 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void __attribute__ ((always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/powerpc/powerpc64/dl-machine.h b/sysdeps/powerpc/powerpc64/dl-machine.h
>> index b90f407119..3f92fbb369 100644
>> --- a/sysdeps/powerpc/powerpc64/dl-machine.h
>> +++ b/sysdeps/powerpc/powerpc64/dl-machine.h
>> @@ -116,8 +116,6 @@ elf_machine_dynamic (void)
>>    return runtime_dynamic - elf_machine_load_address() ;
>>  }
>>
>> -#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
>> -
>>  /* The PLT uses Elf64_Rela relocs.  */
>>  #define elf_machine_relplt elf_machine_rela
>>
>
>I think this snippet was already pushed in a previou patch.

Yes. The diff appeared after rebase :)

>> @@ -345,7 +343,8 @@ dl_platform_init (void)
>>  /* Set up the loaded object described by MAP so its unrelocated PLT
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>  static inline int __attribute__ ((always_inline))
>> -elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    if (map->l_info[DT_JMPREL])
>>      {
>> @@ -620,7 +619,7 @@ extern void attribute_hidden _dl_reloc_overflow (struct link_map *map,
>>  						 Elf64_Addr *const reloc_addr,
>>  						 const Elf64_Sym *refsym);
>>
>> -auto inline void __attribute__ ((always_inline))
>> +static inline void __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>>  {
>> @@ -629,7 +628,7 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  }
>>
>>  /* This computes the value used by TPREL* relocs.  */
>> -auto inline Elf64_Addr __attribute__ ((always_inline, const))
>> +static inline Elf64_Addr __attribute__ ((always_inline, const))
>>  elf_machine_tprel (struct link_map *map,
>>  		   struct link_map *sym_map,
>>  		   const Elf64_Sym *sym,
>> @@ -648,7 +647,7 @@ elf_machine_tprel (struct link_map *map,
>>  }
>>
>>  /* Call function at address VALUE (an OPD entry) to resolve ifunc relocs.  */
>> -auto inline Elf64_Addr __attribute__ ((always_inline))
>> +static inline Elf64_Addr __attribute__ ((always_inline))
>>  resolve_ifunc (Elf64_Addr value,
>>  	       const struct link_map *map, const struct link_map *sym_map)
>>  {
>> @@ -678,8 +677,8 @@ resolve_ifunc (Elf64_Addr value,
>>
>>  /* Perform the relocation specified by RELOC and SYM (which is fully
>>     resolved).  MAP is the object containing the reloc.  */
>> -auto inline void __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map,
>> +static inline void __attribute__ ((always_inline))
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>>  		  const Elf64_Rela *reloc,
>>  		  const Elf64_Sym *sym,
>>  		  const struct r_found_version *version,
>> @@ -707,7 +706,7 @@ elf_machine_rela (struct link_map *map,
>>
>>    /* We need SYM_MAP even in the absence of TLS, for elf_machine_fixup_plt
>>       and STT_GNU_IFUNC.  */
>> -  struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +  struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>    Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
>>
>>    if (sym != NULL
>> @@ -1037,8 +1036,8 @@ elf_machine_rela (struct link_map *map,
>>    MODIFIED_CODE_NOQUEUE (reloc_addr);
>>  }
>>
>> -auto inline void __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +static inline void __attribute__ ((always_inline))
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>Ok.
>
>> diff --git a/sysdeps/riscv/dl-machine.h b/sysdeps/riscv/dl-machine.h
>> index 5b0746175c..e7289d7ddc 100644
>> --- a/sysdeps/riscv/dl-machine.h
>> +++ b/sysdeps/riscv/dl-machine.h
>> @@ -161,17 +161,18 @@ elf_machine_fixup_plt (struct link_map *map, lookup_t t,
>>     by RELOC_ADDR.  SYM is the relocation symbol specified by R_INFO and
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr, int skip_ifunc)
>>  {
>>    ElfW(Addr) r_info = reloc->r_info;
>>    const unsigned long int r_type = ELFW (R_TYPE) (r_info);
>>    ElfW(Addr) *addr_field = (ElfW(Addr) *) reloc_addr;
>>    const ElfW(Sym) *const __attribute__ ((unused)) refsym = sym;
>> -  struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +  struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>    ElfW(Addr) value = 0;
>>    if (sym_map != NULL)
>>      value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
>> @@ -279,7 +280,7 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>  			  void *const reloc_addr)
>> @@ -287,10 +288,11 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>    *(ElfW(Addr) *) reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
>> -		      const ElfW(Rela) *reloc, int skip_ifunc)
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>> +		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>> +		      int skip_ifunc)
>>  {
>>    ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
>>    const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
>> @@ -320,9 +322,10 @@ elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
>>  /* Set up the loaded object described by L so its stub function
>>     will jump to the on-demand fixup code __dl_runtime_resolve.  */
>>
>> -auto inline int
>> +static inline int
>>  __attribute__ ((always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>  #ifndef RTLD_BOOTSTRAP
>>    /* If using PLTs, fill in the first two entries of .got.plt.  */
>
>Ok.
>
>> diff --git a/sysdeps/s390/s390-32/dl-machine.h b/sysdeps/s390/s390-32/dl-machine.h
>> index 73cc007e34..cd16cc7e00 100644
>> --- a/sysdeps/s390/s390-32/dl-machine.h
>> +++ b/sysdeps/s390/s390-32/dl-machine.h
>> @@ -84,7 +84,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    extern void _dl_runtime_resolve (Elf32_Word);
>>    extern void _dl_runtime_profile (Elf32_Word);
>> @@ -320,10 +321,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -356,7 +358,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>        /* Only needed for R_390_COPY below.  */
>>        const Elf32_Sym *const refsym = sym;
>>  #endif
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -483,7 +486,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -492,9 +495,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>
>Ok.
>
>> diff --git a/sysdeps/s390/s390-64/dl-machine.h b/sysdeps/s390/s390-64/dl-machine.h
>> index aa9d524bac..0330a8d7de 100644
>> --- a/sysdeps/s390/s390-64/dl-machine.h
>> +++ b/sysdeps/s390/s390-64/dl-machine.h
>> @@ -74,7 +74,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    extern void _dl_runtime_resolve (Elf64_Word);
>>    extern void _dl_runtime_profile (Elf64_Word);
>> @@ -267,10 +268,11 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>> -		  const Elf64_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf64_Rela *reloc, const Elf64_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf64_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -303,7 +305,8 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>>        /* Only needed for R_390_COPY below.  */
>>        const Elf64_Sym *const refsym = sym;
>>  #endif
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -437,7 +440,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -446,9 +449,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>
>Ok.
>
>> diff --git a/sysdeps/sh/dl-machine.h b/sysdeps/sh/dl-machine.h
>> index 122b417a17..0c22dfd848 100644
>> --- a/sysdeps/sh/dl-machine.h
>> +++ b/sysdeps/sh/dl-machine.h
>> @@ -69,7 +69,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused, always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf32_Addr *got;
>>    extern void _dl_runtime_resolve (Elf32_Word);
>> @@ -259,10 +260,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -318,7 +320,8 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>    else
>>      {
>>        const Elf32_Sym *const refsym = sym;
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>
>>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>>        value += reloc->r_addend;
>> @@ -424,7 +427,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -443,9 +446,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  #undef COPY_UNALIGNED_WORD
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>
>Ok.
>
>> diff --git a/sysdeps/sparc/sparc32/dl-machine.h b/sysdeps/sparc/sparc32/dl-machine.h
>> index 0269e458ea..6361cfae9e 100644
>> --- a/sysdeps/sparc/sparc32/dl-machine.h
>> +++ b/sysdeps/sparc/sparc32/dl-machine.h
>> @@ -97,7 +97,8 @@ elf_machine_load_address (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf32_Addr *plt;
>>    extern void _dl_runtime_resolve (Elf32_Word);
>> @@ -327,10 +328,11 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>> -		  const Elf32_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf32_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -381,7 +383,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>    else
>>      {
>> -      sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>>      }
>>  #else
>> @@ -536,7 +538,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -545,9 +547,9 @@ elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>    *reloc_addr += l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>
>Ok.
>
>> diff --git a/sysdeps/sparc/sparc64/dl-machine.h b/sysdeps/sparc/sparc64/dl-machine.h
>> index bbd4566d8a..3fd18c6e5e 100644
>> --- a/sysdeps/sparc/sparc64/dl-machine.h
>> +++ b/sysdeps/sparc/sparc64/dl-machine.h
>> @@ -126,7 +126,8 @@ elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    if (l->l_info[DT_JMPREL] && lazy)
>>      {
>> @@ -354,10 +355,11 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>> -		  const Elf64_Sym *sym, const struct r_found_version *version,
>> +elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>> +		  const Elf64_Rela *reloc, const Elf64_Sym *sym,
>> +		  const struct r_found_version *version,
>>  		  void *const reloc_addr_arg, int skip_ifunc)
>>  {
>>    Elf64_Addr *const reloc_addr = reloc_addr_arg;
>> @@ -408,7 +410,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>>      }
>>    else
>>      {
>> -      sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
>>        value = SYMBOL_ADDRESS (sym_map, sym, true);
>>      }
>>  #else
>> @@ -646,7 +648,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>>  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -655,9 +657,9 @@ elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>    *reloc_addr = l_addr + reloc->r_addend;
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute__ ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
>>  		      int skip_ifunc)
>>  {
>
>
>Ok.
>
>> diff --git a/sysdeps/x86_64/dl-machine.h b/sysdeps/x86_64/dl-machine.h
>> index b3ed4dd467..9c0182d597 100644
>> --- a/sysdeps/x86_64/dl-machine.h
>> +++ b/sysdeps/x86_64/dl-machine.h
>> @@ -54,7 +54,8 @@ elf_machine_dynamic (void)
>>     entries will jump to the on-demand fixup code in dl-runtime.c.  */
>>
>>  static inline int __attribute__ ((unused, always_inline))
>> -elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
>> +elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
>> +			   int lazy, int profile)
>>  {
>>    Elf64_Addr *got;
>>    extern void _dl_runtime_resolve_fxsave (ElfW(Word)) attribute_hidden;
>> @@ -250,12 +251,11 @@ elf_machine_plt_value (struct link_map *map, const ElfW(Rela) *reloc,
>>  /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
>>     MAP is the object containing the reloc.  */
>>
>> -auto inline void
>> -__attribute__ ((always_inline))
>> -elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>> -		  const ElfW(Sym) *sym, const struct r_found_version *version,
>> -		  void *const reloc_addr_arg, int skip_ifunc)
>> -{
>> +static inline void __attribute__((always_inline))
>> +elf_machine_rela(struct link_map *map, struct r_scope_elem *scope[],
>> +		 const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
>> +		 const struct r_found_version *version,
>> +		 void *const reloc_addr_arg, int skip_ifunc) {
>>    ElfW(Addr) *const reloc_addr = reloc_addr_arg;
>>    const unsigned long int r_type = ELFW(R_TYPE) (reloc->r_info);
>>
>> @@ -292,7 +292,8 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
>>  # ifndef RTLD_BOOTSTRAP
>>        const ElfW(Sym) *const refsym = sym;
>>  # endif
>> -      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
>> +      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
>> +					      r_type);
>>        ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
>>
>>        if (sym != NULL
>> @@ -517,7 +518,7 @@ and creates an unsatisfiable circular dependency.\n",
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>>  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>  			   void *const reloc_addr_arg)
>> @@ -536,9 +537,9 @@ elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>      }
>>  }
>>
>> -auto inline void
>> +static inline void
>>  __attribute ((always_inline))
>> -elf_machine_lazy_rel (struct link_map *map,
>> +elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>>  		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
>>  		      int skip_ifunc)
>>  {
>> @@ -572,7 +573,7 @@ elf_machine_lazy_rel (struct link_map *map,
>>
>>        /* Always initialize TLS descriptors completely at load time, in
>>  	 case static TLS is allocated for it that requires locking.  */
>> -      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
>> +      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr, skip_ifunc);
>>      }
>>    else if (__glibc_unlikely (r_type == R_X86_64_IRELATIVE))
>>      {
>>
>
>
>Ok.
H.J. Lu Oct. 2, 2021, 8:49 p.m. UTC | #5
On Fri, Oct 1, 2021 at 10:28 PM Fangrui Song via Libc-alpha
<libc-alpha@sourceware.org> wrote:
>
> On 2021-09-29, Adhemerval Zanella wrote:
> >
> >
> >On 24/09/2021 17:49, Fangrui Song wrote:
> >> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
> >> This version fixes all ports and doesn't add NESTING dispatches.]
> >> [Available at
> >> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
> >>
> >> dynamic-link.h is included more than once in some elf/ files (rtld.c,
> >> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
> >> functions. This harms readability and the nested functions usage
> >> is the biggest obstacle prevents CC=clang (which doesn't support the
> >> feature).
> >>
> >> The key idea for unnesting is to add extra parameters (link_map * and
> >> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
> >> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
> >> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
> >> implementation in the google/grte/v5-2.27/master which uses static
> >> variables.)
> >>
> >> Future simplification:
> >> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
> >>   elf_machine_runtime_setup can drop the `scope` parameter.
> >> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
> >>   elf_machine_lazy_rel can drop the `scope` parameter.
> >>
> >> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
> >>
> >> Tested build-many-glibcs.py glibcs with
> >> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
> >> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
> >> ---
> >> Changes from v1
> >> * Remove global variables: cur_l, cur_scope, cur_strtab
> >> ---
> >> Changes from v2
> >> * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
> >
> >Some minor comments below.  The architecture changes are mostly
> >mechanical and the bulk the change seems good, however there are
> >some regressions with --enable-static-pie:
>
> Many thanks for your review!
> Pushed changes to https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
> but not sending v4 yet.
>
> >$ grep ^FAIL x86_64-linux-gnu/tests.sum
> >FAIL: elf/tst-tls1-static-non-pie
> >FAIL: gmon/tst-gmon-static
> >FAIL: gmon/tst-gmon-static-gprof
> >
> >$ grep ^FAIL i686-linux-gnu/tests.sum
> >FAIL: elf/tst-tls1-static-non-pie
> >FAIL: gmon/tst-gmon-static
> >FAIL: gmon/tst-gmon-static-gprof
>
> Weird? I rebased
> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
> on current origin/master.
>
> I don't see them failing in --enable-static-pie mode.
>
> (If non-pie static mode had any issue, more tests would fail.)
>

maskray/unnest branch is OK on i686, x32 and x86-64.

Thanks.

H.J.
Adhemerval Zanella Oct. 4, 2021, 11:29 a.m. UTC | #6
On 02/10/2021 17:49, H.J. Lu wrote:
> On Fri, Oct 1, 2021 at 10:28 PM Fangrui Song via Libc-alpha
> <libc-alpha@sourceware.org> wrote:
>>
>> On 2021-09-29, Adhemerval Zanella wrote:
>>>
>>>
>>> On 24/09/2021 17:49, Fangrui Song wrote:
>>>> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
>>>> This version fixes all ports and doesn't add NESTING dispatches.]
>>>> [Available at
>>>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
>>>>
>>>> dynamic-link.h is included more than once in some elf/ files (rtld.c,
>>>> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
>>>> functions. This harms readability and the nested functions usage
>>>> is the biggest obstacle prevents CC=clang (which doesn't support the
>>>> feature).
>>>>
>>>> The key idea for unnesting is to add extra parameters (link_map * and
>>>> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
>>>> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
>>>> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
>>>> implementation in the google/grte/v5-2.27/master which uses static
>>>> variables.)
>>>>
>>>> Future simplification:
>>>> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
>>>>   elf_machine_runtime_setup can drop the `scope` parameter.
>>>> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
>>>>   elf_machine_lazy_rel can drop the `scope` parameter.
>>>>
>>>> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
>>>>
>>>> Tested build-many-glibcs.py glibcs with
>>>> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
>>>> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
>>>> ---
>>>> Changes from v1
>>>> * Remove global variables: cur_l, cur_scope, cur_strtab
>>>> ---
>>>> Changes from v2
>>>> * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
>>>
>>> Some minor comments below.  The architecture changes are mostly
>>> mechanical and the bulk the change seems good, however there are
>>> some regressions with --enable-static-pie:
>>
>> Many thanks for your review!
>> Pushed changes to https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
>> but not sending v4 yet.
>>
>>> $ grep ^FAIL x86_64-linux-gnu/tests.sum
>>> FAIL: elf/tst-tls1-static-non-pie
>>> FAIL: gmon/tst-gmon-static
>>> FAIL: gmon/tst-gmon-static-gprof
>>>
>>> $ grep ^FAIL i686-linux-gnu/tests.sum
>>> FAIL: elf/tst-tls1-static-non-pie
>>> FAIL: gmon/tst-gmon-static
>>> FAIL: gmon/tst-gmon-static-gprof
>>
>> Weird? I rebased
>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
>> on current origin/master.
>>
>> I don't see them failing in --enable-static-pie mode.
>>
>> (If non-pie static mode had any issue, more tests would fail.)
>>
> 
> maskray/unnest branch is OK on i686, x32 and x86-64.

I am still seeing the same issues on x86_64 and i686:

$ grep ^FAIL tests.sum 
FAIL: elf/tst-tls1-static-non-pie
FAIL: gmon/tst-gmon-static
FAIL: gmon/tst-gmon-static-gprof
FAIL: nptl/tst-thread-affinity-pthread2

$ x86_64-glibc-linux-gnu-gcc -v
[...]
gcc version 11.1.1 20210618 [releases/gcc-11 revision 956077257ad:6fb87338c2e:94d5c3a781ccfb70d5b0c2401be8a5bb7af396bb] (GCC) 
$ x86_64-glibc-linux-gnu-ld -v
GNU ld (GNU Binutils) 2.36.1.20210618

$ gdb elf/tst-tls1-static-non-pie
[...]
(gdb) r
[...]
Program received signal SIGSEGV, Segmentation fault.
0x00000000004017c4 in _dl_relocate_static_pie () at static-reloc.c:24
24	{
(gdb) disas
Dump of assembler code for function _dl_relocate_static_pie:
   0x00000000004017c0 <+0>:	sub    $0x18,%rsp
=> 0x00000000004017c4 <+4>:	mov    %fs:0x28,%rax
   0x00000000004017cd <+13>:	mov    %rax,0x8(%rsp)
   0x00000000004017d2 <+18>:	xor    %eax,%eax
   0x00000000004017d4 <+20>:	mov    0x8(%rsp),%rax
   0x00000000004017d9 <+25>:	sub    %fs:0x28,%rax
   0x00000000004017e2 <+34>:	jne    0x4017e9 <_dl_relocate_static_pie+41>
   0x00000000004017e4 <+36>:	add    $0x18,%rsp
   0x00000000004017e8 <+40>:	ret    
   0x00000000004017e9 <+41>:	call   0x4573b0 <__stack_chk_fail>
(gdb) i r fs rax
fs             0x0                 0
rax            0x80000             524288
 
I am not sure why the thread pointer is not being initialized here.  However
it does seem to be failing on master as well with my environment (I didn't
see it earlier because I don't check with --enable-static-pie as default).
H.J. Lu Oct. 4, 2021, 1:34 p.m. UTC | #7
On Mon, Oct 4, 2021 at 4:29 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 02/10/2021 17:49, H.J. Lu wrote:
> > On Fri, Oct 1, 2021 at 10:28 PM Fangrui Song via Libc-alpha
> > <libc-alpha@sourceware.org> wrote:
> >>
> >> On 2021-09-29, Adhemerval Zanella wrote:
> >>>
> >>>
> >>> On 24/09/2021 17:49, Fangrui Song wrote:
> >>>> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
> >>>> This version fixes all ports and doesn't add NESTING dispatches.]
> >>>> [Available at
> >>>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
> >>>>
> >>>> dynamic-link.h is included more than once in some elf/ files (rtld.c,
> >>>> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
> >>>> functions. This harms readability and the nested functions usage
> >>>> is the biggest obstacle prevents CC=clang (which doesn't support the
> >>>> feature).
> >>>>
> >>>> The key idea for unnesting is to add extra parameters (link_map * and
> >>>> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
> >>>> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
> >>>> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
> >>>> implementation in the google/grte/v5-2.27/master which uses static
> >>>> variables.)
> >>>>
> >>>> Future simplification:
> >>>> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
> >>>>   elf_machine_runtime_setup can drop the `scope` parameter.
> >>>> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
> >>>>   elf_machine_lazy_rel can drop the `scope` parameter.
> >>>>
> >>>> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
> >>>>
> >>>> Tested build-many-glibcs.py glibcs with
> >>>> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
> >>>> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
> >>>> ---
> >>>> Changes from v1
> >>>> * Remove global variables: cur_l, cur_scope, cur_strtab
> >>>> ---
> >>>> Changes from v2
> >>>> * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
> >>>
> >>> Some minor comments below.  The architecture changes are mostly
> >>> mechanical and the bulk the change seems good, however there are
> >>> some regressions with --enable-static-pie:
> >>
> >> Many thanks for your review!
> >> Pushed changes to https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
> >> but not sending v4 yet.
> >>
> >>> $ grep ^FAIL x86_64-linux-gnu/tests.sum
> >>> FAIL: elf/tst-tls1-static-non-pie
> >>> FAIL: gmon/tst-gmon-static
> >>> FAIL: gmon/tst-gmon-static-gprof
> >>>
> >>> $ grep ^FAIL i686-linux-gnu/tests.sum
> >>> FAIL: elf/tst-tls1-static-non-pie
> >>> FAIL: gmon/tst-gmon-static
> >>> FAIL: gmon/tst-gmon-static-gprof
> >>
> >> Weird? I rebased
> >> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
> >> on current origin/master.
> >>
> >> I don't see them failing in --enable-static-pie mode.
> >>
> >> (If non-pie static mode had any issue, more tests would fail.)
> >>
> >
> > maskray/unnest branch is OK on i686, x32 and x86-64.
>
> I am still seeing the same issues on x86_64 and i686:
>
> $ grep ^FAIL tests.sum
> FAIL: elf/tst-tls1-static-non-pie
> FAIL: gmon/tst-gmon-static
> FAIL: gmon/tst-gmon-static-gprof
> FAIL: nptl/tst-thread-affinity-pthread2
>
> $ x86_64-glibc-linux-gnu-gcc -v
> [...]
> gcc version 11.1.1 20210618 [releases/gcc-11 revision 956077257ad:6fb87338c2e:94d5c3a781ccfb70d5b0c2401be8a5bb7af396bb] (GCC)
> $ x86_64-glibc-linux-gnu-ld -v
> GNU ld (GNU Binutils) 2.36.1.20210618
>
> $ gdb elf/tst-tls1-static-non-pie
> [...]
> (gdb) r
> [...]
> Program received signal SIGSEGV, Segmentation fault.
> 0x00000000004017c4 in _dl_relocate_static_pie () at static-reloc.c:24
> 24      {
> (gdb) disas
> Dump of assembler code for function _dl_relocate_static_pie:
>    0x00000000004017c0 <+0>:     sub    $0x18,%rsp
> => 0x00000000004017c4 <+4>:     mov    %fs:0x28,%rax
>    0x00000000004017cd <+13>:    mov    %rax,0x8(%rsp)
>    0x00000000004017d2 <+18>:    xor    %eax,%eax
>    0x00000000004017d4 <+20>:    mov    0x8(%rsp),%rax
>    0x00000000004017d9 <+25>:    sub    %fs:0x28,%rax
>    0x00000000004017e2 <+34>:    jne    0x4017e9 <_dl_relocate_static_pie+41>
>    0x00000000004017e4 <+36>:    add    $0x18,%rsp
>    0x00000000004017e8 <+40>:    ret
>    0x00000000004017e9 <+41>:    call   0x4573b0 <__stack_chk_fail>
> (gdb) i r fs rax
> fs             0x0                 0
> rax            0x80000             524288
>
> I am not sure why the thread pointer is not being initialized here.  However
> it does seem to be failing on master as well with my environment (I didn't
> see it earlier because I don't check with --enable-static-pie as default).
>

Did you run into:

https://sourceware.org/bugzilla/show_bug.cgi?id=27004
Adhemerval Zanella Oct. 4, 2021, 1:39 p.m. UTC | #8
On 04/10/2021 10:34, H.J. Lu wrote:
> On Mon, Oct 4, 2021 at 4:29 AM Adhemerval Zanella
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 02/10/2021 17:49, H.J. Lu wrote:
>>> On Fri, Oct 1, 2021 at 10:28 PM Fangrui Song via Libc-alpha
>>> <libc-alpha@sourceware.org> wrote:
>>>>
>>>> On 2021-09-29, Adhemerval Zanella wrote:
>>>>>
>>>>>
>>>>> On 24/09/2021 17:49, Fangrui Song wrote:
>>>>>> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
>>>>>> This version fixes all ports and doesn't add NESTING dispatches.]
>>>>>> [Available at
>>>>>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
>>>>>>
>>>>>> dynamic-link.h is included more than once in some elf/ files (rtld.c,
>>>>>> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
>>>>>> functions. This harms readability and the nested functions usage
>>>>>> is the biggest obstacle prevents CC=clang (which doesn't support the
>>>>>> feature).
>>>>>>
>>>>>> The key idea for unnesting is to add extra parameters (link_map * and
>>>>>> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
>>>>>> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
>>>>>> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
>>>>>> implementation in the google/grte/v5-2.27/master which uses static
>>>>>> variables.)
>>>>>>
>>>>>> Future simplification:
>>>>>> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
>>>>>>   elf_machine_runtime_setup can drop the `scope` parameter.
>>>>>> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
>>>>>>   elf_machine_lazy_rel can drop the `scope` parameter.
>>>>>>
>>>>>> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
>>>>>>
>>>>>> Tested build-many-glibcs.py glibcs with
>>>>>> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
>>>>>> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
>>>>>> ---
>>>>>> Changes from v1
>>>>>> * Remove global variables: cur_l, cur_scope, cur_strtab
>>>>>> ---
>>>>>> Changes from v2
>>>>>> * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
>>>>>
>>>>> Some minor comments below.  The architecture changes are mostly
>>>>> mechanical and the bulk the change seems good, however there are
>>>>> some regressions with --enable-static-pie:
>>>>
>>>> Many thanks for your review!
>>>> Pushed changes to https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
>>>> but not sending v4 yet.
>>>>
>>>>> $ grep ^FAIL x86_64-linux-gnu/tests.sum
>>>>> FAIL: elf/tst-tls1-static-non-pie
>>>>> FAIL: gmon/tst-gmon-static
>>>>> FAIL: gmon/tst-gmon-static-gprof
>>>>>
>>>>> $ grep ^FAIL i686-linux-gnu/tests.sum
>>>>> FAIL: elf/tst-tls1-static-non-pie
>>>>> FAIL: gmon/tst-gmon-static
>>>>> FAIL: gmon/tst-gmon-static-gprof
>>>>
>>>> Weird? I rebased
>>>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
>>>> on current origin/master.
>>>>
>>>> I don't see them failing in --enable-static-pie mode.
>>>>
>>>> (If non-pie static mode had any issue, more tests would fail.)
>>>>
>>>
>>> maskray/unnest branch is OK on i686, x32 and x86-64.
>>
>> I am still seeing the same issues on x86_64 and i686:
>>
>> $ grep ^FAIL tests.sum
>> FAIL: elf/tst-tls1-static-non-pie
>> FAIL: gmon/tst-gmon-static
>> FAIL: gmon/tst-gmon-static-gprof
>> FAIL: nptl/tst-thread-affinity-pthread2
>>
>> $ x86_64-glibc-linux-gnu-gcc -v
>> [...]
>> gcc version 11.1.1 20210618 [releases/gcc-11 revision 956077257ad:6fb87338c2e:94d5c3a781ccfb70d5b0c2401be8a5bb7af396bb] (GCC)
>> $ x86_64-glibc-linux-gnu-ld -v
>> GNU ld (GNU Binutils) 2.36.1.20210618
>>
>> $ gdb elf/tst-tls1-static-non-pie
>> [...]
>> (gdb) r
>> [...]
>> Program received signal SIGSEGV, Segmentation fault.
>> 0x00000000004017c4 in _dl_relocate_static_pie () at static-reloc.c:24
>> 24      {
>> (gdb) disas
>> Dump of assembler code for function _dl_relocate_static_pie:
>>    0x00000000004017c0 <+0>:     sub    $0x18,%rsp
>> => 0x00000000004017c4 <+4>:     mov    %fs:0x28,%rax
>>    0x00000000004017cd <+13>:    mov    %rax,0x8(%rsp)
>>    0x00000000004017d2 <+18>:    xor    %eax,%eax
>>    0x00000000004017d4 <+20>:    mov    0x8(%rsp),%rax
>>    0x00000000004017d9 <+25>:    sub    %fs:0x28,%rax
>>    0x00000000004017e2 <+34>:    jne    0x4017e9 <_dl_relocate_static_pie+41>
>>    0x00000000004017e4 <+36>:    add    $0x18,%rsp
>>    0x00000000004017e8 <+40>:    ret
>>    0x00000000004017e9 <+41>:    call   0x4573b0 <__stack_chk_fail>
>> (gdb) i r fs rax
>> fs             0x0                 0
>> rax            0x80000             524288
>>
>> I am not sure why the thread pointer is not being initialized here.  However
>> it does seem to be failing on master as well with my environment (I didn't
>> see it earlier because I don't check with --enable-static-pie as default).
>>
> 
> Did you run into:
> 
> https://sourceware.org/bugzilla/show_bug.cgi?id=27004
> 

It does looks like, I will rebuild my gcc and re-ran the branch.
Adhemerval Zanella Oct. 4, 2021, 5:44 p.m. UTC | #9
On 04/10/2021 10:39, Adhemerval Zanella wrote:
> 
> 
> On 04/10/2021 10:34, H.J. Lu wrote:
>> On Mon, Oct 4, 2021 at 4:29 AM Adhemerval Zanella
>> <adhemerval.zanella@linaro.org> wrote:
>>>
>>>
>>>
>>> On 02/10/2021 17:49, H.J. Lu wrote:
>>>> On Fri, Oct 1, 2021 at 10:28 PM Fangrui Song via Libc-alpha
>>>> <libc-alpha@sourceware.org> wrote:
>>>>>
>>>>> On 2021-09-29, Adhemerval Zanella wrote:
>>>>>>
>>>>>>
>>>>>> On 24/09/2021 17:49, Fangrui Song wrote:
>>>>>>> [Alternative to https://sourceware.org/pipermail/libc-alpha/2021-August/130340.html
>>>>>>> This version fixes all ports and doesn't add NESTING dispatches.]
>>>>>>> [Available at
>>>>>>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest ]
>>>>>>>
>>>>>>> dynamic-link.h is included more than once in some elf/ files (rtld.c,
>>>>>>> dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
>>>>>>> functions. This harms readability and the nested functions usage
>>>>>>> is the biggest obstacle prevents CC=clang (which doesn't support the
>>>>>>> feature).
>>>>>>>
>>>>>>> The key idea for unnesting is to add extra parameters (link_map * and
>>>>>>> r_scope_elm *[]) to RESOLVE_MAP, ELF_MACHINE_BEFORE_RTLD_RELOC,
>>>>>>> ELF_DYNAMIC_RELOCATE, elf_machine_rela?, elf_machine_lazy_rel, and
>>>>>>> elf_machine_runtime_setup. (This is inspired by Stan Shebs' ppc64/x86-64
>>>>>>> implementation in the google/grte/v5-2.27/master which uses static
>>>>>>> variables.)
>>>>>>>
>>>>>>> Future simplification:
>>>>>>> * If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
>>>>>>>   elf_machine_runtime_setup can drop the `scope` parameter.
>>>>>>> * If TLSDESC no longer need to be in elf_machine_lazy_rel,
>>>>>>>   elf_machine_lazy_rel can drop the `scope` parameter.
>>>>>>>
>>>>>>> Tested on aarch64-linux-gnu, powerpc64le-linux-gnu and x86_64-linux-gnu.
>>>>>>>
>>>>>>> Tested build-many-glibcs.py glibcs with
>>>>>>> {alpha,arc,csky,hppa,ia64,microblaze,nios2,s390x,sh4,sparc64,sparc64}-linux-gnu,
>>>>>>> arm-linux-gnueabi, csky-linux-gnuabiv2, mips64-linux-gnu-n64, and riscv64-linux-gnu-rv64imafdc-lp64.
>>>>>>> ---
>>>>>>> Changes from v1
>>>>>>> * Remove global variables: cur_l, cur_scope, cur_strtab
>>>>>>> ---
>>>>>>> Changes from v2
>>>>>>> * Remove STATIC_PIE_BOOTSTRAP ifdefs and boot_map parameters. It is less intrusive now.
>>>>>>
>>>>>> Some minor comments below.  The architecture changes are mostly
>>>>>> mechanical and the bulk the change seems good, however there are
>>>>>> some regressions with --enable-static-pie:
>>>>>
>>>>> Many thanks for your review!
>>>>> Pushed changes to https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
>>>>> but not sending v4 yet.
>>>>>
>>>>>> $ grep ^FAIL x86_64-linux-gnu/tests.sum
>>>>>> FAIL: elf/tst-tls1-static-non-pie
>>>>>> FAIL: gmon/tst-gmon-static
>>>>>> FAIL: gmon/tst-gmon-static-gprof
>>>>>>
>>>>>> $ grep ^FAIL i686-linux-gnu/tests.sum
>>>>>> FAIL: elf/tst-tls1-static-non-pie
>>>>>> FAIL: gmon/tst-gmon-static
>>>>>> FAIL: gmon/tst-gmon-static-gprof
>>>>>
>>>>> Weird? I rebased
>>>>> https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/maskray/unnest
>>>>> on current origin/master.
>>>>>
>>>>> I don't see them failing in --enable-static-pie mode.
>>>>>
>>>>> (If non-pie static mode had any issue, more tests would fail.)
>>>>>
>>>>
>>>> maskray/unnest branch is OK on i686, x32 and x86-64.
>>>
>>> I am still seeing the same issues on x86_64 and i686:
>>>
>>> $ grep ^FAIL tests.sum
>>> FAIL: elf/tst-tls1-static-non-pie
>>> FAIL: gmon/tst-gmon-static
>>> FAIL: gmon/tst-gmon-static-gprof
>>> FAIL: nptl/tst-thread-affinity-pthread2
>>>
>>> $ x86_64-glibc-linux-gnu-gcc -v
>>> [...]
>>> gcc version 11.1.1 20210618 [releases/gcc-11 revision 956077257ad:6fb87338c2e:94d5c3a781ccfb70d5b0c2401be8a5bb7af396bb] (GCC)
>>> $ x86_64-glibc-linux-gnu-ld -v
>>> GNU ld (GNU Binutils) 2.36.1.20210618
>>>
>>> $ gdb elf/tst-tls1-static-non-pie
>>> [...]
>>> (gdb) r
>>> [...]
>>> Program received signal SIGSEGV, Segmentation fault.
>>> 0x00000000004017c4 in _dl_relocate_static_pie () at static-reloc.c:24
>>> 24      {
>>> (gdb) disas
>>> Dump of assembler code for function _dl_relocate_static_pie:
>>>    0x00000000004017c0 <+0>:     sub    $0x18,%rsp
>>> => 0x00000000004017c4 <+4>:     mov    %fs:0x28,%rax
>>>    0x00000000004017cd <+13>:    mov    %rax,0x8(%rsp)
>>>    0x00000000004017d2 <+18>:    xor    %eax,%eax
>>>    0x00000000004017d4 <+20>:    mov    0x8(%rsp),%rax
>>>    0x00000000004017d9 <+25>:    sub    %fs:0x28,%rax
>>>    0x00000000004017e2 <+34>:    jne    0x4017e9 <_dl_relocate_static_pie+41>
>>>    0x00000000004017e4 <+36>:    add    $0x18,%rsp
>>>    0x00000000004017e8 <+40>:    ret
>>>    0x00000000004017e9 <+41>:    call   0x4573b0 <__stack_chk_fail>
>>> (gdb) i r fs rax
>>> fs             0x0                 0
>>> rax            0x80000             524288
>>>
>>> I am not sure why the thread pointer is not being initialized here.  However
>>> it does seem to be failing on master as well with my environment (I didn't
>>> see it earlier because I don't check with --enable-static-pie as default).
>>>
>>
>> Did you run into:
>>
>> https://sourceware.org/bugzilla/show_bug.cgi?id=27004
>>
> 
> It does looks like, I will rebuild my gcc and re-ran the branch.
> 

It is indeed due gcc11, even when used top of release/gcc-11 branch
(d75fcbf89b833ed59980e6a6cd9a79dcec1c83b0) I am seeing this failure.

With gcc-10 I don't see any issue (783f3f2734e3d926b1d284582a16b6ecf34504e9).
diff mbox series

Patch

diff --git a/elf/dl-conflict.c b/elf/dl-conflict.c
index 64fa5793d2..1d69b5cd9f 100644
--- a/elf/dl-conflict.c
+++ b/elf/dl-conflict.c
@@ -26,20 +26,12 @@ 
 #include <sys/types.h>
 #include "dynamic-link.h"
 
-void
-_dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
-		       ElfW(Rela) *conflictend)
-{
-#if ! ELF_MACHINE_NO_RELA
-  if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
-    _dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name));
-
-  {
-    /* Do the conflict relocation of the object and library GOT and other
-       data.  */
+/* Used by RESOLVE_CONFLICT_FIND_MAP at init time. Cannot be accessed
+ * concurrently.  */
+static struct link_map *resolve_conflict_map __attribute__ ((__unused__));
 
     /* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code.  */
-#define RESOLVE_MAP(ref, version, flags) (*ref = NULL, NULL)
+#define RESOLVE_MAP(map, scope, ref, version, flags) (*ref = NULL, NULL)
 #define RESOLVE(ref, version, flags) (*ref = NULL, 0)
 #define RESOLVE_CONFLICT_FIND_MAP(map, r_offset) \
   do {									      \
@@ -50,12 +42,23 @@  _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
     (map) = resolve_conflict_map;					      \
   } while (0)
 
+#include "dynamic-link.h"
+
+void
+_dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
+		       ElfW(Rela) *conflictend)
+{
+#if ! ELF_MACHINE_NO_RELA
+  if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
+    _dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name));
+
+  {
+    /* Do the conflict relocation of the object and library GOT and other
+       data.  */
+
     /* Prelinking makes no sense for anything but the main namespace.  */
     assert (l->l_ns == LM_ID_BASE);
-    struct link_map *resolve_conflict_map __attribute__ ((__unused__))
-      = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
-
-#include "dynamic-link.h"
+    resolve_conflict_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 
     /* Override these, defined in dynamic-link.h.  */
 #undef CHECK_STATIC_TLS
@@ -66,8 +69,8 @@  _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
     GL(dl_num_cache_relocations) += conflictend - conflict;
 
     for (; conflict < conflictend; ++conflict)
-      elf_machine_rela (l, conflict, NULL, NULL, (void *) conflict->r_offset,
-			0);
+      elf_machine_rela (l, NULL, conflict, NULL, NULL,
+			(void *) conflict->r_offset, 0);
   }
 #endif
 }
diff --git a/elf/dl-reloc-static-pie.c b/elf/dl-reloc-static-pie.c
index 68ded176cd..4007580453 100644
--- a/elf/dl-reloc-static-pie.c
+++ b/elf/dl-reloc-static-pie.c
@@ -19,8 +19,14 @@ 
 #if ENABLE_STATIC_PIE
 /* Mark symbols hidden in static PIE for early self relocation to work.  */
 # pragma GCC visibility push(hidden)
+#include <assert.h>
 #include <unistd.h>
 #include <ldsodefs.h>
+
+#include <dl-machine.h>
+
+#define STATIC_PIE_BOOTSTRAP
+#define RESOLVE_MAP(map, scope, sym, version, flags) map
 #include "dynamic-link.h"
 
 /* Relocate static executable with PIE.  */
@@ -30,11 +36,6 @@  _dl_relocate_static_pie (void)
 {
   struct link_map *main_map = _dl_get_dl_main_map ();
 
-# define STATIC_PIE_BOOTSTRAP
-# define BOOTSTRAP_MAP (main_map)
-# define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
-# include "dynamic-link.h"
-
   /* Figure out the run-time load address of static PIE.  */
   main_map->l_addr = elf_machine_load_address ();
 
@@ -53,12 +54,12 @@  _dl_relocate_static_pie (void)
   elf_get_dynamic_info (main_map);
 
 # ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
-  ELF_MACHINE_BEFORE_RTLD_RELOC (main_map->l_info);
+  ELF_MACHINE_BEFORE_RTLD_RELOC (main_map, main_map->l_info);
 # endif
 
   /* Relocate ourselves so we can do normal function calls and
      data access using the global offset table.  */
-  ELF_DYNAMIC_RELOCATE (main_map, 0, 0, 0);
+  ELF_DYNAMIC_RELOCATE (main_map, NULL, 0, 0, 0);
   main_map->l_relocated = 1;
 
   /* Initialize _r_debug_extended.  */
diff --git a/elf/dl-reloc.c b/elf/dl-reloc.c
index 6c957456b8..8867e32c9e 100644
--- a/elf/dl-reloc.c
+++ b/elf/dl-reloc.c
@@ -162,6 +162,32 @@  _dl_nothread_init_static_tls (struct link_map *map)
 }
 #endif /* !PTHREAD_IN_LIBC */
 
+/* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code.  */
+#define RESOLVE_MAP(l, scope, ref, version, r_type)			      \
+    ((ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL			      \
+      && __glibc_likely (!dl_symbol_visibility_binds_local_p (*ref)))	      \
+     ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0)		      \
+	 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class)  \
+	? (bump_num_cache_relocations (),				      \
+	   (*ref) = l->l_lookup_cache.ret,				      \
+	   l->l_lookup_cache.value)					      \
+	: ({ lookup_t _lr;						      \
+	     int _tc = elf_machine_type_class (r_type);			      \
+	     l->l_lookup_cache.type_class = _tc;			      \
+	     l->l_lookup_cache.sym = (*ref);				      \
+	     const struct r_found_version *v = NULL;			      \
+	     if ((version) != NULL && (version)->hash != 0)		      \
+	       v = (version);						      \
+	     _lr = _dl_lookup_symbol_x ((const char *) D_PTR (l, l_info[DT_STRTAB]) + (*ref)->st_name, \
+					l, (ref), scope, v, _tc,	      \
+					DL_LOOKUP_ADD_DEPENDENCY	      \
+					| DL_LOOKUP_FOR_RELOCATE, NULL);      \
+	     l->l_lookup_cache.ret = (*ref);				      \
+	     l->l_lookup_cache.value = _lr; }))				      \
+     : l)
+
+#include "dynamic-link.h"
+
 void
 _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
 		     int reloc_mode, int consider_profiling)
@@ -243,36 +269,7 @@  _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
   {
     /* Do the actual relocation of the object's GOT and other data.  */
 
-    /* String table object symbols.  */
-    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, r_type) \
-    ((ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL			      \
-      && __glibc_likely (!dl_symbol_visibility_binds_local_p (*ref)))	      \
-     ? ((__builtin_expect ((*ref) == l->l_lookup_cache.sym, 0)		      \
-	 && elf_machine_type_class (r_type) == l->l_lookup_cache.type_class)  \
-	? (bump_num_cache_relocations (),				      \
-	   (*ref) = l->l_lookup_cache.ret,				      \
-	   l->l_lookup_cache.value)					      \
-	: ({ lookup_t _lr;						      \
-	     int _tc = elf_machine_type_class (r_type);			      \
-	     l->l_lookup_cache.type_class = _tc;			      \
-	     l->l_lookup_cache.sym = (*ref);				      \
-	     const struct r_found_version *v = NULL;			      \
-	     if ((version) != NULL && (version)->hash != 0)		      \
-	       v = (version);						      \
-	     _lr = _dl_lookup_symbol_x (strtab + (*ref)->st_name, l, (ref),   \
-					scope, v, _tc,			      \
-					DL_LOOKUP_ADD_DEPENDENCY	      \
-					| DL_LOOKUP_FOR_RELOCATE, NULL);      \
-	     l->l_lookup_cache.ret = (*ref);				      \
-	     l->l_lookup_cache.value = _lr; }))				      \
-     : l)
-
-#include "dynamic-link.h"
-
-    ELF_DYNAMIC_RELOCATE (l, lazy, consider_profiling, skip_ifunc);
+    ELF_DYNAMIC_RELOCATE (l, scope, lazy, consider_profiling, skip_ifunc);
 
 #ifndef PROF
     if (__glibc_unlikely (consider_profiling)
diff --git a/elf/do-rel.h b/elf/do-rel.h
index 321ac2b359..f441b74919 100644
--- a/elf/do-rel.h
+++ b/elf/do-rel.h
@@ -37,8 +37,8 @@ 
    relocations; they should be set up to call _dl_runtime_resolve, rather
    than fully resolved now.  */
 
-auto inline void __attribute__ ((always_inline))
-elf_dynamic_do_Rel (struct link_map *map,
+static inline void __attribute__ ((always_inline))
+elf_dynamic_do_Rel (struct link_map *map, struct r_scope_elem *scope[],
 		    ElfW(Addr) reladdr, ElfW(Addr) relsize,
 		    __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative,
 		    int lazy, int skip_ifunc)
@@ -68,13 +68,13 @@  elf_dynamic_do_Rel (struct link_map *map,
 	  }
 	else
 # endif
-	  elf_machine_lazy_rel (map, l_addr, r, skip_ifunc);
+	  elf_machine_lazy_rel (map, scope, l_addr, r, skip_ifunc);
 
 # ifdef ELF_MACHINE_IRELATIVE
       if (r2 != NULL)
 	for (; r2 <= end2; ++r2)
 	  if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
-	    elf_machine_lazy_rel (map, l_addr, r2, skip_ifunc);
+	    elf_machine_lazy_rel (map, scope, l_addr, r2, skip_ifunc);
 # endif
     }
   else
@@ -134,7 +134,7 @@  elf_dynamic_do_Rel (struct link_map *map,
 #endif
 
 	      ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
-	      elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)],
+	      elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)],
 			       &map->l_versions[ndx],
 			       (void *) (l_addr + r->r_offset), skip_ifunc);
 	    }
@@ -146,7 +146,7 @@  elf_dynamic_do_Rel (struct link_map *map,
 		{
 		  ElfW(Half) ndx
 		    = version[ELFW(R_SYM) (r2->r_info)] & 0x7fff;
-		  elf_machine_rel (map, r2,
+		  elf_machine_rel (map, scope, r2,
 				   &symtab[ELFW(R_SYM) (r2->r_info)],
 				   &map->l_versions[ndx],
 				   (void *) (l_addr + r2->r_offset),
@@ -167,14 +167,14 @@  elf_dynamic_do_Rel (struct link_map *map,
 	      }
 	    else
 # endif
-	      elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
+	      elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
 			       (void *) (l_addr + r->r_offset), skip_ifunc);
 
 # ifdef ELF_MACHINE_IRELATIVE
 	  if (r2 != NULL)
 	    for (; r2 <= end2; ++r2)
 	      if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
-		elf_machine_rel (map, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
+		elf_machine_rel (map, scope, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
 				 NULL, (void *) (l_addr + r2->r_offset),
 				 skip_ifunc);
 # endif
diff --git a/elf/dynamic-link.h b/elf/dynamic-link.h
index 3eb24ba3a6..f3f6c3bcac 100644
--- a/elf/dynamic-link.h
+++ b/elf/dynamic-link.h
@@ -59,31 +59,33 @@  int _dl_try_allocate_static_tls (struct link_map *map, bool optional)
    copying memory, breaking the very code written to handle the
    unaligned cases.  */
 # if ! ELF_MACHINE_NO_REL
-auto inline void __attribute__((always_inline))
-elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
-		 const ElfW(Sym) *sym, const struct r_found_version *version,
+static inline void __attribute__((always_inline))
+elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
+		 const ElfW(Rel) *reloc, const ElfW(Sym) *sym,
+		 const struct r_found_version *version,
 		 void *const reloc_addr, int skip_ifunc);
-auto inline void __attribute__((always_inline))
+static inline void __attribute__((always_inline))
 elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
 			  void *const reloc_addr);
 # endif
 # if ! ELF_MACHINE_NO_RELA
-auto inline void __attribute__((always_inline))
-elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
-		  const ElfW(Sym) *sym, const struct r_found_version *version,
-		  void *const reloc_addr, int skip_ifunc);
-auto inline void __attribute__((always_inline))
-elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
-			   void *const reloc_addr);
+static inline void __attribute__((always_inline))
+elf_machine_rela(struct link_map *map, struct r_scope_elem *scope[],
+		 const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
+		 const struct r_found_version *version, void *const reloc_addr,
+		 int skip_ifunc);
+static inline void __attribute__((always_inline))
+elf_machine_rela_relative(ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
+	                  void *const reloc_addr);
 # endif
 # if ELF_MACHINE_NO_RELA || defined ELF_MACHINE_PLT_REL
-auto inline void __attribute__((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static inline void __attribute__((always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
 		      int skip_ifunc);
 # else
-auto inline void __attribute__((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static inline void __attribute__((always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 		      int skip_ifunc);
 # endif
@@ -114,7 +116,7 @@  elf_machine_lazy_rel (struct link_map *map,
    consumes precisely the very end of the DT_REL*, or DT_JMPREL and DT_REL*
    are completely separate and there is a gap between them.  */
 
-# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, do_lazy, skip_ifunc, test_rel) \
+# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, scope, do_lazy, skip_ifunc, test_rel) \
   do {									      \
     struct { ElfW(Addr) start, size;					      \
 	     __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative; int lazy; }  \
@@ -152,18 +154,18 @@  elf_machine_lazy_rel (struct link_map *map,
       }									      \
 									      \
     if (ELF_DURING_STARTUP)						      \
-      elf_dynamic_do_##reloc ((map), ranges[0].start, ranges[0].size,	      \
-			      ranges[0].nrelative, 0, skip_ifunc);	      \
+      elf_dynamic_do_##reloc ((map), scope, ranges[0].start, ranges[0].size,  \
+			      ranges[0].nrelative, 0, skip_ifunc);  \
     else								      \
       {									      \
 	int ranges_index;						      \
 	for (ranges_index = 0; ranges_index < 2; ++ranges_index)	      \
-	  elf_dynamic_do_##reloc ((map),				      \
+	  elf_dynamic_do_##reloc ((map), scope,				      \
 				  ranges[ranges_index].start,		      \
 				  ranges[ranges_index].size,		      \
 				  ranges[ranges_index].nrelative,	      \
 				  ranges[ranges_index].lazy,		      \
-				  skip_ifunc);				      \
+				  skip_ifunc);		      \
       }									      \
   } while (0)
 
@@ -175,29 +177,29 @@  elf_machine_lazy_rel (struct link_map *map,
 
 # if ! ELF_MACHINE_NO_REL
 #  include "do-rel.h"
-#  define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) \
-  _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, lazy, skip_ifunc, _ELF_CHECK_REL)
+#  define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc)	      \
+  _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL)
 # else
-#  define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) /* Nothing to do.  */
+#  define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc) /* Nothing to do.  */
 # endif
 
 # if ! ELF_MACHINE_NO_RELA
 #  define DO_RELA
 #  include "do-rel.h"
-#  define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) \
-  _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, lazy, skip_ifunc, _ELF_CHECK_REL)
+#  define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc)	      \
+  _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL)
 # else
-#  define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) /* Nothing to do.  */
+#  define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc) /* Nothing to do.  */
 # endif
 
 /* This can't just be an inline function because GCC is too dumb
    to inline functions containing inlines themselves.  */
-# define ELF_DYNAMIC_RELOCATE(map, lazy, consider_profile, skip_ifunc) \
+# define ELF_DYNAMIC_RELOCATE(map, scope, lazy, consider_profile, skip_ifunc) \
   do {									      \
-    int edr_lazy = elf_machine_runtime_setup ((map), (lazy),		      \
+    int edr_lazy = elf_machine_runtime_setup ((map), (scope), (lazy),	      \
 					      (consider_profile));	      \
-    ELF_DYNAMIC_DO_REL ((map), edr_lazy, skip_ifunc);			      \
-    ELF_DYNAMIC_DO_RELA ((map), edr_lazy, skip_ifunc);			      \
+    ELF_DYNAMIC_DO_REL ((map), (scope), edr_lazy, skip_ifunc);		      \
+    ELF_DYNAMIC_DO_RELA ((map), (scope), edr_lazy, skip_ifunc);		      \
   } while (0)
 
 #endif
diff --git a/elf/get-dynamic-info.h b/elf/get-dynamic-info.h
index 4aa2058abf..15c316b38c 100644
--- a/elf/get-dynamic-info.h
+++ b/elf/get-dynamic-info.h
@@ -16,18 +16,15 @@ 
    License along with the GNU C Library; if not, see
    <https://www.gnu.org/licenses/>.  */
 
-/* This file is included multiple times and therefore lacks a header
-   file inclusion guard.  */
+/* Populate dynamic tags in l_info.  */
+
+#ifndef _GET_DYNAMIC_INFO_H
+#define _GET_DYNAMIC_INFO_H
 
 #include <assert.h>
 #include <libc-diag.h>
 
-#ifndef RESOLVE_MAP
-static
-#else
-auto
-#endif
-inline void __attribute__ ((unused, always_inline))
+static inline void __attribute__ ((unused, always_inline))
 elf_get_dynamic_info (struct link_map *l)
 {
 #if __ELF_NATIVE_CLASS == 32
@@ -165,3 +162,5 @@  elf_get_dynamic_info (struct link_map *l)
     info[DT_RPATH] = NULL;
 #endif
 }
+
+#endif
diff --git a/elf/rtld.c b/elf/rtld.c
index 8d2bba3d43..0c27e5d486 100644
--- a/elf/rtld.c
+++ b/elf/rtld.c
@@ -500,13 +500,9 @@  _dl_start_final (void *arg, struct dl_start_final_info *info)
   return start_addr;
 }
 
-static ElfW(Addr) __attribute_used__
-_dl_start (void *arg)
-{
 #ifdef DONT_USE_BOOTSTRAP_MAP
 # define bootstrap_map GL(dl_rtld_map)
 #else
-  struct dl_start_final_info info;
 # define bootstrap_map info.l
 #endif
 
@@ -515,13 +511,16 @@  _dl_start (void *arg)
      Since ld.so must not have any undefined symbols the result
      is trivial: always the map of ld.so itself.  */
 #define RTLD_BOOTSTRAP
-#define BOOTSTRAP_MAP (&bootstrap_map)
-#define RESOLVE_MAP(sym, version, flags) BOOTSTRAP_MAP
+#define RESOLVE_MAP(map, scope, sym, version, flags) map
 #include "dynamic-link.h"
 
+static ElfW(Addr) __attribute_used__
+_dl_start (void *arg)
+{
 #ifdef DONT_USE_BOOTSTRAP_MAP
   rtld_timer_start (&start_time);
 #else
+  struct dl_start_final_info info;
   rtld_timer_start (&info.start_time);
 #endif
 
@@ -554,7 +553,7 @@  _dl_start (void *arg)
 #endif
 
 #ifdef ELF_MACHINE_BEFORE_RTLD_RELOC
-  ELF_MACHINE_BEFORE_RTLD_RELOC (bootstrap_map.l_info);
+  ELF_MACHINE_BEFORE_RTLD_RELOC (&bootstrap_map, bootstrap_map.l_info);
 #endif
 
   if (bootstrap_map.l_addr || ! bootstrap_map.l_info[VALIDX(DT_GNU_PRELINKED)])
@@ -562,7 +561,7 @@  _dl_start (void *arg)
       /* Relocate ourselves so we can do normal function calls and
 	 data access using the global offset table.  */
 
-      ELF_DYNAMIC_RELOCATE (&bootstrap_map, 0, 0, 0);
+      ELF_DYNAMIC_RELOCATE (&bootstrap_map, NULL, 0, 0, 0);
     }
   bootstrap_map.l_relocated = 1;
 
diff --git a/sysdeps/aarch64/dl-machine.h b/sysdeps/aarch64/dl-machine.h
index 3e10cb462f..e30e81c902 100644
--- a/sysdeps/aarch64/dl-machine.h
+++ b/sysdeps/aarch64/dl-machine.h
@@ -59,7 +59,8 @@  elf_machine_dynamic (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   if (l->l_info[DT_JMPREL] && lazy)
     {
@@ -237,10 +238,11 @@  elf_machine_plt_value (struct link_map *map,
 
 #ifdef RESOLVE_MAP
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
-		  const ElfW(Sym) *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
@@ -253,7 +255,8 @@  elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
   else
     {
       const ElfW(Sym) *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -377,9 +380,9 @@  elf_machine_rela_relative (ElfW(Addr) l_addr,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      ElfW(Addr) l_addr,
 		      const ElfW(Rela) *reloc,
 		      int skip_ifunc)
@@ -406,7 +409,7 @@  elf_machine_lazy_rel (struct link_map *map,
 		    (const void *)D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
 		  version = &map->l_versions[vernum[symndx] & 0x7fff];
 		}
-	      elf_machine_rela (map, reloc, sym, version, reloc_addr,
+	      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
 				skip_ifunc);
 	      return;
 	    }
@@ -433,7 +436,8 @@  elf_machine_lazy_rel (struct link_map *map,
 
       /* Always initialize TLS descriptors completely, because lazy
 	 initialization requires synchronization at every TLS access.  */
-      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
+      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
+			skip_ifunc);
     }
   else if (__glibc_unlikely (r_type == AARCH64_R(IRELATIVE)))
     {
diff --git a/sysdeps/alpha/dl-machine.h b/sysdeps/alpha/dl-machine.h
index 9e327b7f17..491541326f 100644
--- a/sysdeps/alpha/dl-machine.h
+++ b/sysdeps/alpha/dl-machine.h
@@ -69,7 +69,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int
-elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   extern char _dl_runtime_resolve_new[] attribute_hidden;
   extern char _dl_runtime_profile_new[] attribute_hidden;
@@ -360,9 +361,9 @@  elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
 
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
 		  const Elf64_Rela *reloc,
 		  const Elf64_Sym *sym,
 		  const struct r_found_version *version,
@@ -410,7 +411,8 @@  elf_machine_rela (struct link_map *map,
       return;
   else
     {
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf64_Addr sym_value;
       Elf64_Addr sym_raw_value;
 
@@ -488,7 +490,7 @@  elf_machine_rela (struct link_map *map,
    can be skipped.  */
 #define ELF_MACHINE_REL_RELATIVE 1
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -505,9 +507,9 @@  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
   memcpy (reloc_addr_arg, &reloc_addr_val, 8);
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/arc/dl-machine.h b/sysdeps/arc/dl-machine.h
index e6ce7f0ff6..4b64ffec25 100644
--- a/sysdeps/arc/dl-machine.h
+++ b/sysdeps/arc/dl-machine.h
@@ -122,7 +122,8 @@  elf_machine_load_address (void)
 
 static inline int
 __attribute__ ((always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   extern void _dl_runtime_resolve (void);
 
@@ -228,10 +229,11 @@  elf_machine_fixup_plt (struct link_map *map, lookup_t t,
 
 #ifdef RESOLVE_MAP
 
-inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
-                  const ElfW(Sym) *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
+		  const struct r_found_version *version,
                   void *const reloc_addr_arg, int skip_ifunc)
 {
   ElfW(Addr) r_info = reloc->r_info;
@@ -245,7 +247,8 @@  elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
   else
     {
       const ElfW(Sym) *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       switch (r_type)
@@ -326,8 +329,9 @@  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 
 inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
-                      const ElfW(Rela) *reloc, int skip_ifunc)
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
+		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
+		      int skip_ifunc)
 {
   ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
   const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
diff --git a/sysdeps/arm/dl-machine.h b/sysdeps/arm/dl-machine.h
index eb13cb8b57..68a0b4b476 100644
--- a/sysdeps/arm/dl-machine.h
+++ b/sysdeps/arm/dl-machine.h
@@ -57,7 +57,8 @@  elf_machine_dynamic (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf32_Addr *got;
   extern void _dl_runtime_resolve (Elf32_Word);
@@ -276,7 +277,7 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
 
 #ifdef RESOLVE_MAP
 /* Handle a PC24 reloc, including the out-of-range case.  */
-auto void
+static void
 relocate_pc24 (struct link_map *map, Elf32_Addr value,
                Elf32_Addr *const reloc_addr, Elf32_Sword addend)
 {
@@ -330,10 +331,11 @@  relocate_pc24 (struct link_map *map, Elf32_Addr value,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
-		 const Elf32_Sym *sym, const struct r_found_version *version,
+elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
+                 const Elf32_Rel *reloc, const Elf32_Sym *sym,
+                 const struct r_found_version *version,
 		 void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -364,7 +366,8 @@  elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
 #endif
     {
       const Elf32_Sym *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -508,10 +511,11 @@  elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
 }
 
 # ifndef RTLD_BOOTSTRAP
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+                  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+                  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -526,7 +530,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
 # ifndef RESOLVE_CONFLICT_FIND_MAP
       const Elf32_Sym *const refsym = sym;
 # endif
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -601,7 +605,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
 }
 # endif
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
 			  void *const reloc_addr_arg)
@@ -611,7 +615,7 @@  elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
 }
 
 # ifndef RTLD_BOOTSTRAP
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -621,9 +625,9 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 }
 # endif
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rel *reloc,
 		      int skip_ifunc)
 {
@@ -653,7 +657,7 @@  elf_machine_lazy_rel (struct link_map *map,
 
       /* Always initialize TLS descriptors completely, because lazy
 	 initialization requires synchronization at every TLS access.  */
-      elf_machine_rel (map, reloc, sym, version, reloc_addr, skip_ifunc);
+      elf_machine_rel (map, scope, reloc, sym, version, reloc_addr, skip_ifunc);
     }
   else
     _dl_reloc_bad_type (map, r_type, 1);
diff --git a/sysdeps/csky/dl-machine.h b/sysdeps/csky/dl-machine.h
index b08f06d74c..ec22f87577 100644
--- a/sysdeps/csky/dl-machine.h
+++ b/sysdeps/csky/dl-machine.h
@@ -58,7 +58,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf32_Addr *got;
   extern void _dl_runtime_resolve (Elf32_Word);
@@ -215,9 +216,10 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void __attribute__ ((unused, always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+static inline void __attribute__ ((unused, always_inline))
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -230,7 +232,8 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
   else
     {
       const Elf32_Sym *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
       opcode16_addr = (unsigned short *)reloc_addr;
 
@@ -331,7 +334,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
 }
 
-auto inline void __attribute__ ((unused, always_inline))
+static inline void __attribute__ ((unused, always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
 {
@@ -339,8 +342,8 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void __attribute__ ((unused, always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static inline void __attribute__ ((unused, always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/hppa/dl-machine.h b/sysdeps/hppa/dl-machine.h
index ded9c193d6..e6a4575fce 100644
--- a/sysdeps/hppa/dl-machine.h
+++ b/sysdeps/hppa/dl-machine.h
@@ -68,8 +68,8 @@  __hppa_init_bootstrap_fdesc_table (struct link_map *map)
   map->l_mach.fptr_table = boot_table;
 }
 
-#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)		\
-	__hppa_init_bootstrap_fdesc_table (BOOTSTRAP_MAP);	\
+#define ELF_MACHINE_BEFORE_RTLD_RELOC(map, dynamic_info)	\
+	__hppa_init_bootstrap_fdesc_table (map);		\
 	_dl_fptr_init();
 
 /* Return nonzero iff ELF header is compatible with the running host.  */
@@ -162,7 +162,8 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf32_Addr *got = NULL;
   Elf32_Addr l_addr, iplt, jmprel, end_jmprel, r_type, r_sym;
@@ -548,8 +549,8 @@  dl_platform_init (void)
   (  (((as14) & 0x1fff) << 1) \
    | (((as14) & 0x2000) >> 13))
 
-auto void __attribute__((always_inline))
-elf_machine_rela (struct link_map *map,
+static void __attribute__((always_inline))
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
 		  const Elf32_Rela *reloc,
 		  const Elf32_Sym *sym,
 		  const struct r_found_version *version,
@@ -578,11 +579,9 @@  elf_machine_rela (struct link_map *map,
      zeros, and an all zero Elf32_Sym has a binding of STB_LOCAL.)
      See RESOLVE_MAP definition in elf/dl-reloc.c  */
 # ifdef RTLD_BOOTSTRAP
-  /* RESOLVE_MAP in rtld.c doesn't have the local sym test.  */
-  sym_map = (ELF32_ST_BIND (sym->st_info) != STB_LOCAL
-	     ? RESOLVE_MAP (&sym, version, r_type) : map);
+  sym_map = map;
 # else
-  sym_map = RESOLVE_MAP (&sym, version, r_type);
+  sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
 # endif
 
   if (sym_map)
@@ -740,7 +739,7 @@  elf_machine_rela (struct link_map *map,
 
 /* hppa doesn't have an R_PARISC_RELATIVE reloc, but uses relocs with
    ELF32_R_SYM (info) == 0 for a similar purpose.  */
-auto void __attribute__((always_inline))
+static void __attribute__((always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr,
 			   const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -793,8 +792,8 @@  elf_machine_rela_relative (Elf32_Addr l_addr,
   *reloc_addr = value;
 }
 
-auto void __attribute__((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static void __attribute__((always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/i386/dl-machine.h b/sysdeps/i386/dl-machine.h
index 0401888508..9f578e536a 100644
--- a/sysdeps/i386/dl-machine.h
+++ b/sysdeps/i386/dl-machine.h
@@ -54,7 +54,8 @@  elf_machine_dynamic (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused, always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf32_Addr *got;
   extern void _dl_runtime_resolve (Elf32_Word) attribute_hidden;
@@ -284,9 +285,10 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute ((always_inline))
-elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
+elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
+		 const Elf32_Rel *reloc,
 		 const Elf32_Sym *sym, const struct r_found_version *version,
 		 void *const reloc_addr_arg, int skip_ifunc)
 {
@@ -320,7 +322,8 @@  elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
 # ifndef RTLD_BOOTSTRAP
       const Elf32_Sym *const refsym = sym;
 # endif
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -491,10 +494,11 @@  and creates an unsatisfiable circular dependency.\n",
 }
 
 # ifndef RTLD_BOOTSTRAP
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -507,7 +511,8 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
 #  ifndef RESOLVE_CONFLICT_FIND_MAP
       const Elf32_Sym *const refsym = sym;
 #  endif
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -640,7 +645,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
 }
 # endif	/* !RTLD_BOOTSTRAP */
 
-auto inline void
+static inline void
 __attribute ((always_inline))
 elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
 			  void *const reloc_addr_arg)
@@ -651,7 +656,7 @@  elf_machine_rel_relative (Elf32_Addr l_addr, const Elf32_Rel *reloc,
 }
 
 # ifndef RTLD_BOOTSTRAP
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -661,9 +666,9 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 }
 # endif	/* !RTLD_BOOTSTRAP */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rel *reloc,
 		      int skip_ifunc)
 {
@@ -698,13 +703,13 @@  elf_machine_lazy_rel (struct link_map *map,
 	  const ElfW(Half) *const version =
 	    (const void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
 	  ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
-	  elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)],
+	  elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)],
 			   &map->l_versions[ndx],
 			   (void *) (l_addr + r->r_offset), skip_ifunc);
 	}
 # ifndef RTLD_BOOTSTRAP
       else
-	elf_machine_rel (map, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
+	elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
 			 (void *) (l_addr + r->r_offset), skip_ifunc);
 # endif
     }
@@ -721,9 +726,9 @@  elf_machine_lazy_rel (struct link_map *map,
 
 # ifndef RTLD_BOOTSTRAP
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rela (struct link_map *map,
+elf_machine_lazy_rela (struct link_map *map, struct r_scope_elem *scope[],
 		       Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		       int skip_ifunc)
 {
@@ -747,7 +752,8 @@  elf_machine_lazy_rela (struct link_map *map,
 
       /* Always initialize TLS descriptors completely at load time, in
 	 case static TLS is allocated for it that requires locking.  */
-      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
+      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
+			skip_ifunc);
     }
   else if (__glibc_unlikely (r_type == R_386_IRELATIVE))
     {
diff --git a/sysdeps/ia64/dl-machine.h b/sysdeps/ia64/dl-machine.h
index 4403e7767a..2217d0b556 100644
--- a/sysdeps/ia64/dl-machine.h
+++ b/sysdeps/ia64/dl-machine.h
@@ -44,8 +44,8 @@  __ia64_init_bootstrap_fdesc_table (struct link_map *map)
   map->l_mach.fptr_table = boot_table;
 }
 
-#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)		\
-	__ia64_init_bootstrap_fdesc_table (BOOTSTRAP_MAP);
+#define ELF_MACHINE_BEFORE_RTLD_RELOC(map, dynamic_info)		\
+	__ia64_init_bootstrap_fdesc_table (map);
 
 /* Return nonzero iff ELF header is compatible with the running host.  */
 static inline int __attribute__ ((unused))
@@ -98,7 +98,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused, always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   extern void _dl_runtime_resolve (void);
   extern void _dl_runtime_profile (void);
@@ -371,9 +372,9 @@  elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
 
 /* Perform the relocation specified by RELOC and SYM (which is fully
    resolved).  MAP is the object containing the reloc.  */
-auto inline void
+static inline void
 __attribute ((always_inline))
-elf_machine_rela (struct link_map *map,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
 		  const Elf64_Rela *reloc,
 		  const Elf64_Sym *sym,
 		  const struct r_found_version *version,
@@ -414,10 +415,11 @@  elf_machine_rela (struct link_map *map,
       return;
   else
     {
-      struct link_map *sym_map;
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
 
       /* RESOLVE_MAP() will return NULL if it fail to locate the symbol.  */
-      if ((sym_map = RESOLVE_MAP (&sym, version, r_type)))
+      if (sym_map != NULL)
 	{
 	  value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
 
@@ -476,7 +478,7 @@  elf_machine_rela (struct link_map *map,
    can be skipped.  */
 #define ELF_MACHINE_REL_RELATIVE 1
 
-auto inline void
+static inline void
 __attribute ((always_inline))
 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -489,9 +491,9 @@  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 }
 
 /* Perform a RELATIVE reloc on the .got entry that transfers to the .plt.  */
-auto inline void
+static inline void
 __attribute ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/m68k/dl-machine.h b/sysdeps/m68k/dl-machine.h
index 86a8c67e2a..5e34c4784e 100644
--- a/sysdeps/m68k/dl-machine.h
+++ b/sysdeps/m68k/dl-machine.h
@@ -68,7 +68,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf32_Addr *got;
   extern void _dl_runtime_resolve (Elf32_Word);
@@ -215,9 +216,10 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void __attribute__ ((unused, always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+static inline void __attribute__ ((unused, always_inline))
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -228,7 +230,8 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
   else
     {
       const Elf32_Sym *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       switch (r_type)
@@ -303,7 +306,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
 }
 
-auto inline void __attribute__ ((unused, always_inline))
+static inline void __attribute__ ((unused, always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
 {
@@ -311,8 +314,8 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void __attribute__ ((unused, always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static inline void __attribute__ ((unused, always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/microblaze/dl-machine.h b/sysdeps/microblaze/dl-machine.h
index e460f6f195..3fd4988e60 100644
--- a/sysdeps/microblaze/dl-machine.h
+++ b/sysdeps/microblaze/dl-machine.h
@@ -69,7 +69,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   extern void _dl_runtime_resolve (Elf32_Word);
   extern void _dl_runtime_profile (Elf32_Word);
@@ -207,9 +208,10 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
     ((unsigned short *)(rel_addr))[3] = (val) & 0xffff; \
   } while (0)
 
-auto inline void __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+static inline void __attribute__ ((always_inline))
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -222,7 +224,8 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
   else
     {
       const Elf32_Sym *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       value += reloc->r_addend;
@@ -277,7 +280,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
 }
 
-auto inline void
+static inline void
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
 {
@@ -285,8 +288,8 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
   PUT_REL_64 (reloc_addr, l_addr + reloc->r_addend);
 }
 
-auto inline void
-elf_machine_lazy_rel (struct link_map *map,
+static inline void
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/mips/dl-machine.h b/sysdeps/mips/dl-machine.h
index b74d427d64..f8d1298b60 100644
--- a/sysdeps/mips/dl-machine.h
+++ b/sysdeps/mips/dl-machine.h
@@ -187,9 +187,9 @@  elf_machine_load_address (void)
 
 /* We can't rely on elf_machine_got_rel because _dl_object_relocation_scope
    fiddles with global data.  */
-#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)			\
+#define ELF_MACHINE_BEFORE_RTLD_RELOC(bootstrap_map, dynamic_info)	\
 do {									\
-  struct link_map *map = BOOTSTRAP_MAP;					\
+  struct link_map *map = bootstrap_map;					\
   ElfW(Sym) *sym;							\
   ElfW(Addr) *got;							\
   int i, n;								\
@@ -474,11 +474,12 @@  elf_machine_plt_value (struct link_map *map, const ElfW(Rel) *reloc,
    by RELOC_ADDR.  SYM is the relocation symbol specified by R_INFO and
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
-		   const ElfW(Sym) *sym, const struct r_found_version *version,
-		   void *reloc_addr, ElfW(Addr) r_addend, int inplace_p)
+elf_machine_reloc (struct link_map *map, struct r_scope_elem *scope[],
+		   ElfW(Addr) r_info, const ElfW(Sym) *sym,
+		   const struct r_found_version *version, void *reloc_addr,
+		   ElfW(Addr) r_addend, int inplace_p)
 {
   const unsigned long int r_type = ELFW(R_TYPE) (r_info);
   ElfW(Addr) *addr_field = (ElfW(Addr) *) reloc_addr;
@@ -506,7 +507,8 @@  elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
     case R_MIPS_TLS_TPREL32:
 # endif
       {
-	struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+	struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+						r_type);
 
 	switch (r_type)
 	  {
@@ -646,7 +648,7 @@  elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
 	  _dl_signal_error (0, map->l_name, NULL,
 			    "found jump slot relocation with non-zero addend");
 
-	sym_map = RESOLVE_MAP (&sym, version, r_type);
+	sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
 	value = SYMBOL_ADDRESS (sym_map, sym, true);
 	*addr_field = value;
 
@@ -660,7 +662,7 @@  elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
 	ElfW(Addr) value;
 
 	/* Calculate the address of the symbol.  */
-	sym_map = RESOLVE_MAP (&sym, version, r_type);
+	sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
 	value = SYMBOL_ADDRESS (sym_map, sym, true);
 
 	if (__builtin_expect (sym == NULL, 0))
@@ -707,16 +709,17 @@  elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
-		 const ElfW(Sym) *sym, const struct r_found_version *version,
-		 void *const reloc_addr, int skip_ifunc)
+elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[],
+		 const ElfW(Rel) *reloc, const ElfW(Sym) *sym,
+		 const struct r_found_version *version, void *const reloc_addr,
+		 int skip_ifunc)
 {
-  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr, 0, 1);
+  elf_machine_reloc (map, scope, reloc->r_info, sym, version, reloc_addr, 0, 1);
 }
 
-auto inline void
+static inline void
 __attribute__((always_inline))
 elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
 			  void *const reloc_addr)
@@ -724,9 +727,9 @@  elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
   /* XXX Nothing to do.  There is no relative relocation, right?  */
 }
 
-auto inline void
+static inline void
 __attribute__((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
 		      int skip_ifunc)
 {
@@ -747,17 +750,17 @@  elf_machine_lazy_rel (struct link_map *map,
     _dl_reloc_bad_type (map, r_type, 1);
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[], const ElfW(Rela) *reloc,
 		  const ElfW(Sym) *sym, const struct r_found_version *version,
 		  void *const reloc_addr, int skip_ifunc)
 {
-  elf_machine_reloc (map, reloc->r_info, sym, version, reloc_addr,
+  elf_machine_reloc (map, scope, reloc->r_info, sym, version, reloc_addr,
 		     reloc->r_addend, 0);
 }
 
-auto inline void
+static inline void
 __attribute__((always_inline))
 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 			   void *const reloc_addr)
@@ -766,9 +769,9 @@  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 
 #ifndef RTLD_BOOTSTRAP
 /* Relocate GOT. */
-auto inline void
+static inline void
 __attribute__((always_inline))
-elf_machine_got_rel (struct link_map *map, int lazy)
+elf_machine_got_rel (struct link_map *map, struct r_scope_elem *scope[], int lazy)
 {
   ElfW(Addr) *got;
   ElfW(Sym) *sym;
@@ -781,7 +784,7 @@  elf_machine_got_rel (struct link_map *map, int lazy)
       const struct r_found_version *version __attribute__ ((unused))	  \
 	= vernum ? &map->l_versions[vernum[sym_index] & 0x7fff] : NULL;	  \
       struct link_map *sym_map;						  \
-      sym_map = RESOLVE_MAP (&ref, version, reloc);			  \
+      sym_map = RESOLVE_MAP (map, scope, &ref, version, reloc);		  \
       SYMBOL_ADDRESS (sym_map, ref, true);				  \
     })
 
@@ -867,9 +870,10 @@  elf_machine_got_rel (struct link_map *map, int lazy)
 /* Set up the loaded object described by L so its stub function
    will jump to the on-demand fixup code __dl_runtime_resolve.  */
 
-auto inline int
+static inline int
 __attribute__((always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
 # ifndef RTLD_BOOTSTRAP
   ElfW(Addr) *got;
@@ -899,7 +903,7 @@  elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
     }
 
   /* Relocate global offset table.  */
-  elf_machine_got_rel (l, lazy);
+  elf_machine_got_rel (l, scope, lazy);
 
   /* If using PLTs, fill in the first two entries of .got.plt.  */
   if (l->l_info[DT_JMPREL] && lazy)
diff --git a/sysdeps/nios2/dl-machine.h b/sysdeps/nios2/dl-machine.h
index e000cd081f..4de602b13d 100644
--- a/sysdeps/nios2/dl-machine.h
+++ b/sysdeps/nios2/dl-machine.h
@@ -67,7 +67,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   extern void _dl_runtime_resolve (Elf32_Word);
 
@@ -234,10 +235,11 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
    LOADADDR is the load address of the object; INFO is an array indexed
    by DT_* of the .dynamic section info.  */
 
-auto inline void __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
-                  const ElfW(Sym) *sym, const struct r_found_version *version,
-                  void *const reloc_addr_arg, int skip_ifunc)
+static inline void __attribute__ ((always_inline))
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
+		  const struct r_found_version *version,
+		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
   const unsigned int r_type = ELF32_R_TYPE (reloc->r_info);
@@ -249,7 +251,8 @@  elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
   else
     {
       const Elf32_Sym *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       switch (r_type)
@@ -314,7 +317,7 @@  elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
     }
 }
 
-auto inline void __attribute__((always_inline))
+static inline void __attribute__((always_inline))
 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 			   void *const reloc_addr_arg)
 {
@@ -322,8 +325,8 @@  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void __attribute__((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static inline void __attribute__((always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/powerpc/powerpc32/dl-machine.h b/sysdeps/powerpc/powerpc32/dl-machine.h
index ced3a7b659..cda012dc1b 100644
--- a/sysdeps/powerpc/powerpc32/dl-machine.h
+++ b/sysdeps/powerpc/powerpc32/dl-machine.h
@@ -109,8 +109,6 @@  elf_machine_load_address (void)
   return runtime_dynamic - elf_machine_dynamic ();
 }
 
-#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
-
 /* The PLT uses Elf32_Rela relocs.  */
 #define elf_machine_relplt elf_machine_rela
 
@@ -172,7 +170,7 @@  extern int __elf_machine_runtime_setup (struct link_map *map,
 					int lazy, int profile);
 
 static inline int
-elf_machine_runtime_setup (struct link_map *map,
+elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
 			   int lazy, int profile)
 {
   if (map->l_info[DT_JMPREL] == 0)
@@ -286,9 +284,10 @@  extern void _dl_reloc_overflow (struct link_map *map,
    LOADADDR is the load address of the object; INFO is an array indexed
    by DT_* of the .dynamic section info.  */
 
-auto inline void __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+static inline void __attribute__ ((always_inline))
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -317,7 +316,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
   else
     {
-      sym_map = RESOLVE_MAP (&sym, version, r_type);
+      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
       value = SYMBOL_ADDRESS (sym_map, sym, true);
     }
   value += reloc->r_addend;
@@ -441,7 +440,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
 }
 
-auto inline void __attribute__ ((always_inline))
+static inline void __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
 {
@@ -449,8 +448,8 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static inline void __attribute__ ((always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/powerpc/powerpc64/dl-machine.h b/sysdeps/powerpc/powerpc64/dl-machine.h
index b90f407119..3f92fbb369 100644
--- a/sysdeps/powerpc/powerpc64/dl-machine.h
+++ b/sysdeps/powerpc/powerpc64/dl-machine.h
@@ -116,8 +116,6 @@  elf_machine_dynamic (void)
   return runtime_dynamic - elf_machine_load_address() ;
 }
 
-#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
-
 /* The PLT uses Elf64_Rela relocs.  */
 #define elf_machine_relplt elf_machine_rela
 
@@ -345,7 +343,8 @@  dl_platform_init (void)
 /* Set up the loaded object described by MAP so its unrelocated PLT
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 static inline int __attribute__ ((always_inline))
-elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   if (map->l_info[DT_JMPREL])
     {
@@ -620,7 +619,7 @@  extern void attribute_hidden _dl_reloc_overflow (struct link_map *map,
 						 Elf64_Addr *const reloc_addr,
 						 const Elf64_Sym *refsym);
 
-auto inline void __attribute__ ((always_inline))
+static inline void __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 			   void *const reloc_addr_arg)
 {
@@ -629,7 +628,7 @@  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 }
 
 /* This computes the value used by TPREL* relocs.  */
-auto inline Elf64_Addr __attribute__ ((always_inline, const))
+static inline Elf64_Addr __attribute__ ((always_inline, const))
 elf_machine_tprel (struct link_map *map,
 		   struct link_map *sym_map,
 		   const Elf64_Sym *sym,
@@ -648,7 +647,7 @@  elf_machine_tprel (struct link_map *map,
 }
 
 /* Call function at address VALUE (an OPD entry) to resolve ifunc relocs.  */
-auto inline Elf64_Addr __attribute__ ((always_inline))
+static inline Elf64_Addr __attribute__ ((always_inline))
 resolve_ifunc (Elf64_Addr value,
 	       const struct link_map *map, const struct link_map *sym_map)
 {
@@ -678,8 +677,8 @@  resolve_ifunc (Elf64_Addr value,
 
 /* Perform the relocation specified by RELOC and SYM (which is fully
    resolved).  MAP is the object containing the reloc.  */
-auto inline void __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map,
+static inline void __attribute__ ((always_inline))
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
 		  const Elf64_Rela *reloc,
 		  const Elf64_Sym *sym,
 		  const struct r_found_version *version,
@@ -707,7 +706,7 @@  elf_machine_rela (struct link_map *map,
 
   /* We need SYM_MAP even in the absence of TLS, for elf_machine_fixup_plt
      and STT_GNU_IFUNC.  */
-  struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+  struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
   Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
 
   if (sym != NULL
@@ -1037,8 +1036,8 @@  elf_machine_rela (struct link_map *map,
   MODIFIED_CODE_NOQUEUE (reloc_addr);
 }
 
-auto inline void __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+static inline void __attribute__ ((always_inline))
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/riscv/dl-machine.h b/sysdeps/riscv/dl-machine.h
index 5b0746175c..e7289d7ddc 100644
--- a/sysdeps/riscv/dl-machine.h
+++ b/sysdeps/riscv/dl-machine.h
@@ -161,17 +161,18 @@  elf_machine_fixup_plt (struct link_map *map, lookup_t t,
    by RELOC_ADDR.  SYM is the relocation symbol specified by R_INFO and
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
-		  const ElfW(Sym) *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr, int skip_ifunc)
 {
   ElfW(Addr) r_info = reloc->r_info;
   const unsigned long int r_type = ELFW (R_TYPE) (r_info);
   ElfW(Addr) *addr_field = (ElfW(Addr) *) reloc_addr;
   const ElfW(Sym) *const __attribute__ ((unused)) refsym = sym;
-  struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+  struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
   ElfW(Addr) value = 0;
   if (sym_map != NULL)
     value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
@@ -279,7 +280,7 @@  elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
     }
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 			  void *const reloc_addr)
@@ -287,10 +288,11 @@  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
   *(ElfW(Addr) *) reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
-		      const ElfW(Rela) *reloc, int skip_ifunc)
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
+		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
+		      int skip_ifunc)
 {
   ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
   const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
@@ -320,9 +322,10 @@  elf_machine_lazy_rel (struct link_map *map, ElfW(Addr) l_addr,
 /* Set up the loaded object described by L so its stub function
    will jump to the on-demand fixup code __dl_runtime_resolve.  */
 
-auto inline int
+static inline int
 __attribute__ ((always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
 #ifndef RTLD_BOOTSTRAP
   /* If using PLTs, fill in the first two entries of .got.plt.  */
diff --git a/sysdeps/s390/s390-32/dl-machine.h b/sysdeps/s390/s390-32/dl-machine.h
index 73cc007e34..cd16cc7e00 100644
--- a/sysdeps/s390/s390-32/dl-machine.h
+++ b/sysdeps/s390/s390-32/dl-machine.h
@@ -84,7 +84,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   extern void _dl_runtime_resolve (Elf32_Word);
   extern void _dl_runtime_profile (Elf32_Word);
@@ -320,10 +321,11 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -356,7 +358,8 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
       /* Only needed for R_390_COPY below.  */
       const Elf32_Sym *const refsym = sym;
 #endif
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -483,7 +486,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -492,9 +495,9 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/s390/s390-64/dl-machine.h b/sysdeps/s390/s390-64/dl-machine.h
index aa9d524bac..0330a8d7de 100644
--- a/sysdeps/s390/s390-64/dl-machine.h
+++ b/sysdeps/s390/s390-64/dl-machine.h
@@ -74,7 +74,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   extern void _dl_runtime_resolve (Elf64_Word);
   extern void _dl_runtime_profile (Elf64_Word);
@@ -267,10 +268,11 @@  elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
-		  const Elf64_Sym *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf64_Rela *reloc, const Elf64_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf64_Addr *const reloc_addr = reloc_addr_arg;
@@ -303,7 +305,8 @@  elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
       /* Only needed for R_390_COPY below.  */
       const Elf64_Sym *const refsym = sym;
 #endif
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -437,7 +440,7 @@  elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
     }
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -446,9 +449,9 @@  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/sh/dl-machine.h b/sysdeps/sh/dl-machine.h
index 122b417a17..0c22dfd848 100644
--- a/sysdeps/sh/dl-machine.h
+++ b/sysdeps/sh/dl-machine.h
@@ -69,7 +69,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused, always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf32_Addr *got;
   extern void _dl_runtime_resolve (Elf32_Word);
@@ -259,10 +260,11 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -318,7 +320,8 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
   else
     {
       const Elf32_Sym *const refsym = sym;
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
 
       value = SYMBOL_ADDRESS (sym_map, sym, true);
       value += reloc->r_addend;
@@ -424,7 +427,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -443,9 +446,9 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 #undef COPY_UNALIGNED_WORD
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/sparc/sparc32/dl-machine.h b/sysdeps/sparc/sparc32/dl-machine.h
index 0269e458ea..6361cfae9e 100644
--- a/sysdeps/sparc/sparc32/dl-machine.h
+++ b/sysdeps/sparc/sparc32/dl-machine.h
@@ -97,7 +97,8 @@  elf_machine_load_address (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf32_Addr *plt;
   extern void _dl_runtime_resolve (Elf32_Word);
@@ -327,10 +328,11 @@  elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
-		  const Elf32_Sym *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf32_Rela *reloc, const Elf32_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf32_Addr *const reloc_addr = reloc_addr_arg;
@@ -381,7 +383,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
   else
     {
-      sym_map = RESOLVE_MAP (&sym, version, r_type);
+      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
       value = SYMBOL_ADDRESS (sym_map, sym, true);
     }
 #else
@@ -536,7 +538,7 @@  elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
     }
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -545,9 +547,9 @@  elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
   *reloc_addr += l_addr + reloc->r_addend;
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/sparc/sparc64/dl-machine.h b/sysdeps/sparc/sparc64/dl-machine.h
index bbd4566d8a..3fd18c6e5e 100644
--- a/sysdeps/sparc/sparc64/dl-machine.h
+++ b/sysdeps/sparc/sparc64/dl-machine.h
@@ -126,7 +126,8 @@  elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   if (l->l_info[DT_JMPREL] && lazy)
     {
@@ -354,10 +355,11 @@  elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
-		  const Elf64_Sym *sym, const struct r_found_version *version,
+elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
+		  const Elf64_Rela *reloc, const Elf64_Sym *sym,
+		  const struct r_found_version *version,
 		  void *const reloc_addr_arg, int skip_ifunc)
 {
   Elf64_Addr *const reloc_addr = reloc_addr_arg;
@@ -408,7 +410,7 @@  elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
     }
   else
     {
-      sym_map = RESOLVE_MAP (&sym, version, r_type);
+      sym_map = RESOLVE_MAP (map, scope, &sym, version, r_type);
       value = SYMBOL_ADDRESS (sym_map, sym, true);
     }
 #else
@@ -646,7 +648,7 @@  elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
     }
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -655,9 +657,9 @@  elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
   *reloc_addr = l_addr + reloc->r_addend;
 }
 
-auto inline void
+static inline void
 __attribute__ ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      Elf64_Addr l_addr, const Elf64_Rela *reloc,
 		      int skip_ifunc)
 {
diff --git a/sysdeps/x86_64/dl-machine.h b/sysdeps/x86_64/dl-machine.h
index b3ed4dd467..9c0182d597 100644
--- a/sysdeps/x86_64/dl-machine.h
+++ b/sysdeps/x86_64/dl-machine.h
@@ -54,7 +54,8 @@  elf_machine_dynamic (void)
    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 
 static inline int __attribute__ ((unused, always_inline))
-elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
+			   int lazy, int profile)
 {
   Elf64_Addr *got;
   extern void _dl_runtime_resolve_fxsave (ElfW(Word)) attribute_hidden;
@@ -250,12 +251,11 @@  elf_machine_plt_value (struct link_map *map, const ElfW(Rela) *reloc,
 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
    MAP is the object containing the reloc.  */
 
-auto inline void
-__attribute__ ((always_inline))
-elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
-		  const ElfW(Sym) *sym, const struct r_found_version *version,
-		  void *const reloc_addr_arg, int skip_ifunc)
-{
+static inline void __attribute__((always_inline))
+elf_machine_rela(struct link_map *map, struct r_scope_elem *scope[],
+		 const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
+		 const struct r_found_version *version,
+		 void *const reloc_addr_arg, int skip_ifunc) {
   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
   const unsigned long int r_type = ELFW(R_TYPE) (reloc->r_info);
 
@@ -292,7 +292,8 @@  elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
 # ifndef RTLD_BOOTSTRAP
       const ElfW(Sym) *const refsym = sym;
 # endif
-      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+      struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
+					      r_type);
       ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
 
       if (sym != NULL
@@ -517,7 +518,7 @@  and creates an unsatisfiable circular dependency.\n",
     }
 }
 
-auto inline void
+static inline void
 __attribute ((always_inline))
 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 			   void *const reloc_addr_arg)
@@ -536,9 +537,9 @@  elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
     }
 }
 
-auto inline void
+static inline void
 __attribute ((always_inline))
-elf_machine_lazy_rel (struct link_map *map,
+elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 		      ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 		      int skip_ifunc)
 {
@@ -572,7 +573,7 @@  elf_machine_lazy_rel (struct link_map *map,
 
       /* Always initialize TLS descriptors completely at load time, in
 	 case static TLS is allocated for it that requires locking.  */
-      elf_machine_rela (map, reloc, sym, version, reloc_addr, skip_ifunc);
+      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr, skip_ifunc);
     }
   else if (__glibc_unlikely (r_type == R_X86_64_IRELATIVE))
     {