commit b19de59d620b3a9e6adf937f322f4281b67fc712

Author: Fangrui Song <maskray@google.com>

Date:   Thu Oct 7 11:55:02 2021 -0700

    elf: Avoid nested functions in the loader [BZ #27220]

    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 Clang build (Clang doesn't support GCC

    nested functions).

    The key idea for unnesting is to add extra parameters (struct link_map

    *and struct r_scope_elm *[]) to RESOLVE_MAP,

    ELF_MACHINE_BEFORE_RTLD_RELOC, ELF_DYNAMIC_RELOCATE, elf_machine_rel[a],

    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 mixed extra parameters and 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, i386, x86-64, powerpc64le, powerpc64, powerpc32,

    sparc64, sparcv9, s390x, s390, hppa, ia64, armhf, alpha, and mips64.

    In addition, tested build-many-glibcs.py with {arc,csky,microblaze,nios2}-linux-gnu

    and riscv64-linux-gnu-rv64imafdc-lp64d.

    Reviewed-by: Adhemerval Zanella  <adhemerval.zanella@linaro.org>

    (cherry picked from commit 490e6c62aa31a8aa5c4a059f6e646ede121edf0a)

diff --git a/elf/dl-conflict.c b/elf/dl-conflict.c

index 31a2f90770ce2a55..5c8e51d19ae095d6 100644

--- a/elf/dl-conflict.c

+++ b/elf/dl-conflict.c

@@ -27,20 +27,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 at loading time solely for prelink executable.  It is not called

+   concurrently so it is be safe to defined as static.  */

+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 {									      \

@@ -51,12 +43,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

@@ -67,8 +70,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 2fb02d727654c87d..a52ba8aeb8b573cb 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.  */

diff --git a/elf/dl-reloc.c b/elf/dl-reloc.c

index e13a672ade6d7a28..3447de7f3536cd70 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 /* !THREAD_GSCOPE_IN_TCB */

+/* 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)))	      \

+     ? ((__glibc_unlikely ((*ref) == l->l_lookup_cache.sym)		      \

+	 && 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 321ac2b359c1028c..f441b749190c2641 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 3eb24ba3a6cee40b..7cc30211649d3820 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))

+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 4aa2058abf6443c9..15c316b38c05a90c 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 84eac9a8df7125a6..ee45657aeac14f3c 100644

--- a/elf/rtld.c

+++ b/elf/rtld.c

@@ -502,13 +502,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

@@ -517,13 +513,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

@@ -557,7 +556,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)])

@@ -565,7 +564,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 d29d827ab32a78ee..34c0790b893a529b 100644

--- a/sysdeps/aarch64/dl-machine.h

+++ b/sysdeps/aarch64/dl-machine.h

@@ -65,7 +65,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)

 {

   if (l->l_info[DT_JMPREL] && lazy)

     {

@@ -243,10 +244,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;

@@ -259,7 +261,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

@@ -383,9 +386,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)

@@ -412,7 +415,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;

 	    }

@@ -439,7 +442,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 2cd2213d9ab25287..66e1db524bb378f6 100644

--- a/sysdeps/alpha/dl-machine.h

+++ b/sysdeps/alpha/dl-machine.h

@@ -70,7 +70,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;

@@ -361,9 +362,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,

@@ -411,7 +412,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;

@@ -489,7 +491,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)

@@ -506,9 +508,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 e6ce7f0ff6d9ac34..4b64ffec256b7f3b 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 ff5e09e207f7986b..7e6761bbe87540d5 100644

--- a/sysdeps/arm/dl-machine.h

+++ b/sysdeps/arm/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)

 {

   Elf32_Addr *got;

   extern void _dl_runtime_resolve (Elf32_Word);

@@ -303,7 +304,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)

 {

@@ -357,10 +358,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;

@@ -391,7 +393,8 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,

 #endif