diff mbox series

[1/3] elf: Introduce rtld_setup_main_map

Message ID 0a942bd0f7e159ca641cc14f76aa28607cd64da0.1641228666.git.fweimer@redhat.com
State Committed
Commit b4d4ff8963866367ba861681ef3b1251e122014a
Headers show
Series Fix elf/tst-dl_find_objects with --enable-hardcoded-path-in-tests | expand

Checks

Context Check Description
dj/TryBot-apply_patch success Patch applied to master at the time it was sent

Commit Message

Florian Weimer Jan. 3, 2022, 5:11 p.m. UTC
This function collects most of the processing needed to initialize
the link map for the main executable.
---
 elf/rtld.c | 303 ++++++++++++++++++++++++++++-------------------------
 1 file changed, 159 insertions(+), 144 deletions(-)

Comments

H.J. Lu Jan. 16, 2022, 12:11 a.m. UTC | #1
On Mon, Jan 3, 2022 at 9:12 AM Florian Weimer via Libc-alpha
<libc-alpha@sourceware.org> wrote:
>
> This function collects most of the processing needed to initialize
> the link map for the main executable.
> ---
>  elf/rtld.c | 303 ++++++++++++++++++++++++++++-------------------------
>  1 file changed, 159 insertions(+), 144 deletions(-)
>
> diff --git a/elf/rtld.c b/elf/rtld.c
> index 24e48bf3fa..ba6e31377d 100644
> --- a/elf/rtld.c
> +++ b/elf/rtld.c
> @@ -1126,17 +1126,172 @@ rtld_chain_load (struct link_map *main_map, char *argv0)
>                      rtld_soname, pathname, errcode);
>  }
>
> +/* Called to complete the initialization of the link map for the main
> +   executable.  Returns true if there is a PT_INTERP segment.  */
> +static bool
> +rtld_setup_main_map (struct link_map *main_map)
> +{
> +  /* This have already been filled in right after _dl_new_object, or
> +     as part of _dl_map_object.  */
> +  const ElfW(Phdr) *phdr = main_map->l_phdr;
> +  ElfW(Word) phnum = main_map->l_phnum;
> +
> +  bool has_interp = false;
> +
> +  main_map->l_map_end = 0;
> +  main_map->l_text_end = 0;
> +  /* Perhaps the executable has no PT_LOAD header entries at all.  */
> +  main_map->l_map_start = ~0;
> +  /* And it was opened directly.  */
> +  ++main_map->l_direct_opencount;
> +
> +  /* Scan the program header table for the dynamic section.  */
> +  for (const ElfW(Phdr) *ph = phdr; ph < &phdr[phnum]; ++ph)
> +    switch (ph->p_type)
> +      {
> +      case PT_PHDR:
> +       /* Find out the load address.  */
> +       main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
> +       break;
> +      case PT_DYNAMIC:
> +       /* This tells us where to find the dynamic section,
> +          which tells us everything we need to do.  */
> +       main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
> +       main_map->l_ld_readonly = (ph->p_flags & PF_W) == 0;
> +       break;
> +      case PT_INTERP:
> +       /* This "interpreter segment" was used by the program loader to
> +          find the program interpreter, which is this program itself, the
> +          dynamic linker.  We note what name finds us, so that a future
> +          dlopen call or DT_NEEDED entry, for something that wants to link
> +          against the dynamic linker as a shared library, will know that
> +          the shared object is already loaded.  */
> +       _dl_rtld_libname.name = ((const char *) main_map->l_addr
> +                                + ph->p_vaddr);
> +       /* _dl_rtld_libname.next = NULL;        Already zero.  */
> +       GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
> +
> +       /* Ordinarilly, we would get additional names for the loader from
> +          our DT_SONAME.  This can't happen if we were actually linked as
> +          a static executable (detect this case when we have no DYNAMIC).
> +          If so, assume the filename component of the interpreter path to
> +          be our SONAME, and add it to our name list.  */
> +       if (GL(dl_rtld_map).l_ld == NULL)
> +         {
> +           const char *p = NULL;
> +           const char *cp = _dl_rtld_libname.name;
> +
> +           /* Find the filename part of the path.  */
> +           while (*cp != '\0')
> +             if (*cp++ == '/')
> +               p = cp;
> +
> +           if (p != NULL)
> +             {
> +               _dl_rtld_libname2.name = p;
> +               /* _dl_rtld_libname2.next = NULL;  Already zero.  */
> +               _dl_rtld_libname.next = &_dl_rtld_libname2;
> +             }
> +         }
> +
> +       has_interp = true;
> +       break;
> +      case PT_LOAD:
> +       {
> +         ElfW(Addr) mapstart;
> +         ElfW(Addr) allocend;
> +
> +         /* Remember where the main program starts in memory.  */
> +         mapstart = (main_map->l_addr
> +                     + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
> +         if (main_map->l_map_start > mapstart)
> +           main_map->l_map_start = mapstart;
> +
> +         /* Also where it ends.  */
> +         allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
> +         if (main_map->l_map_end < allocend)
> +           main_map->l_map_end = allocend;
> +         if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
> +           main_map->l_text_end = allocend;
> +       }
> +       break;
> +
> +      case PT_TLS:
> +       if (ph->p_memsz > 0)
> +         {
> +           /* Note that in the case the dynamic linker we duplicate work
> +              here since we read the PT_TLS entry already in
> +              _dl_start_final.  But the result is repeatable so do not
> +              check for this special but unimportant case.  */
> +           main_map->l_tls_blocksize = ph->p_memsz;
> +           main_map->l_tls_align = ph->p_align;
> +           if (ph->p_align == 0)
> +             main_map->l_tls_firstbyte_offset = 0;
> +           else
> +             main_map->l_tls_firstbyte_offset = (ph->p_vaddr
> +                                                 & (ph->p_align - 1));
> +           main_map->l_tls_initimage_size = ph->p_filesz;
> +           main_map->l_tls_initimage = (void *) ph->p_vaddr;
> +
> +           /* This image gets the ID one.  */
> +           GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
> +         }
> +       break;
> +
> +      case PT_GNU_STACK:
> +       GL(dl_stack_flags) = ph->p_flags;
> +       break;
> +
> +      case PT_GNU_RELRO:
> +       main_map->l_relro_addr = ph->p_vaddr;
> +       main_map->l_relro_size = ph->p_memsz;
> +       break;
> +      }
> +  /* Process program headers again, but scan them backwards so
> +     that PT_NOTE can be skipped if PT_GNU_PROPERTY exits.  */
> +  for (const ElfW(Phdr) *ph = &phdr[phnum]; ph != phdr; --ph)
> +    switch (ph[-1].p_type)
> +      {
> +      case PT_NOTE:
> +       _dl_process_pt_note (main_map, -1, &ph[-1]);
> +       break;
> +      case PT_GNU_PROPERTY:
> +       _dl_process_pt_gnu_property (main_map, -1, &ph[-1]);
> +       break;
> +      }
> +
> +  /* Adjust the address of the TLS initialization image in case
> +     the executable is actually an ET_DYN object.  */
> +  if (main_map->l_tls_initimage != NULL)
> +    main_map->l_tls_initimage
> +      = (char *) main_map->l_tls_initimage + main_map->l_addr;
> +  if (! main_map->l_map_end)
> +    main_map->l_map_end = ~0;
> +  if (! main_map->l_text_end)
> +    main_map->l_text_end = ~0;
> +  if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
> +    {
> +      /* We were invoked directly, so the program might not have a
> +        PT_INTERP.  */
> +      _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
> +      /* _dl_rtld_libname.next = NULL; Already zero.  */
> +      GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
> +    }
> +  else
> +    assert (GL(dl_rtld_map).l_libname); /* How else did we get here?  */
> +
> +  return has_interp;
> +}
> +
>  static void
>  dl_main (const ElfW(Phdr) *phdr,
>          ElfW(Word) phnum,
>          ElfW(Addr) *user_entry,
>          ElfW(auxv_t) *auxv)
>  {
> -  const ElfW(Phdr) *ph;
>    struct link_map *main_map;
>    size_t file_size;
>    char *file;
> -  bool has_interp = false;
>    unsigned int i;
>    bool prelinked = false;
>    bool rtld_is_main = false;
> @@ -1350,7 +1505,7 @@ dl_main (const ElfW(Phdr) *phdr,
>          load the program below unless it has a PT_GNU_STACK indicating
>          nonexecutable stack is ok.  */
>
> -      for (ph = phdr; ph < &phdr[phnum]; ++ph)
> +      for (const ElfW(Phdr) *ph = phdr; ph < &phdr[phnum]; ++ph)
>         if (ph->p_type == PT_GNU_STACK)
>           {
>             GL(dl_stack_flags) = ph->p_flags;
> @@ -1469,147 +1624,7 @@ dl_main (const ElfW(Phdr) *phdr,
>          information for the program.  */
>      }
>
> -  main_map->l_map_end = 0;
> -  main_map->l_text_end = 0;
> -  /* Perhaps the executable has no PT_LOAD header entries at all.  */
> -  main_map->l_map_start = ~0;
> -  /* And it was opened directly.  */
> -  ++main_map->l_direct_opencount;
> -
> -  /* Scan the program header table for the dynamic section.  */
> -  for (ph = phdr; ph < &phdr[phnum]; ++ph)
> -    switch (ph->p_type)
> -      {
> -      case PT_PHDR:
> -       /* Find out the load address.  */
> -       main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
> -       break;
> -      case PT_DYNAMIC:
> -       /* This tells us where to find the dynamic section,
> -          which tells us everything we need to do.  */
> -       main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
> -       main_map->l_ld_readonly = (ph->p_flags & PF_W) == 0;
> -       break;
> -      case PT_INTERP:
> -       /* This "interpreter segment" was used by the program loader to
> -          find the program interpreter, which is this program itself, the
> -          dynamic linker.  We note what name finds us, so that a future
> -          dlopen call or DT_NEEDED entry, for something that wants to link
> -          against the dynamic linker as a shared library, will know that
> -          the shared object is already loaded.  */
> -       _dl_rtld_libname.name = ((const char *) main_map->l_addr
> -                                + ph->p_vaddr);
> -       /* _dl_rtld_libname.next = NULL;        Already zero.  */
> -       GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
> -
> -       /* Ordinarilly, we would get additional names for the loader from
> -          our DT_SONAME.  This can't happen if we were actually linked as
> -          a static executable (detect this case when we have no DYNAMIC).
> -          If so, assume the filename component of the interpreter path to
> -          be our SONAME, and add it to our name list.  */
> -       if (GL(dl_rtld_map).l_ld == NULL)
> -         {
> -           const char *p = NULL;
> -           const char *cp = _dl_rtld_libname.name;
> -
> -           /* Find the filename part of the path.  */
> -           while (*cp != '\0')
> -             if (*cp++ == '/')
> -               p = cp;
> -
> -           if (p != NULL)
> -             {
> -               _dl_rtld_libname2.name = p;
> -               /* _dl_rtld_libname2.next = NULL;  Already zero.  */
> -               _dl_rtld_libname.next = &_dl_rtld_libname2;
> -             }
> -         }
> -
> -       has_interp = true;
> -       break;
> -      case PT_LOAD:
> -       {
> -         ElfW(Addr) mapstart;
> -         ElfW(Addr) allocend;
> -
> -         /* Remember where the main program starts in memory.  */
> -         mapstart = (main_map->l_addr
> -                     + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
> -         if (main_map->l_map_start > mapstart)
> -           main_map->l_map_start = mapstart;
> -
> -         /* Also where it ends.  */
> -         allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
> -         if (main_map->l_map_end < allocend)
> -           main_map->l_map_end = allocend;
> -         if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
> -           main_map->l_text_end = allocend;
> -       }
> -       break;
> -
> -      case PT_TLS:
> -       if (ph->p_memsz > 0)
> -         {
> -           /* Note that in the case the dynamic linker we duplicate work
> -              here since we read the PT_TLS entry already in
> -              _dl_start_final.  But the result is repeatable so do not
> -              check for this special but unimportant case.  */
> -           main_map->l_tls_blocksize = ph->p_memsz;
> -           main_map->l_tls_align = ph->p_align;
> -           if (ph->p_align == 0)
> -             main_map->l_tls_firstbyte_offset = 0;
> -           else
> -             main_map->l_tls_firstbyte_offset = (ph->p_vaddr
> -                                                 & (ph->p_align - 1));
> -           main_map->l_tls_initimage_size = ph->p_filesz;
> -           main_map->l_tls_initimage = (void *) ph->p_vaddr;
> -
> -           /* This image gets the ID one.  */
> -           GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
> -         }
> -       break;
> -
> -      case PT_GNU_STACK:
> -       GL(dl_stack_flags) = ph->p_flags;
> -       break;
> -
> -      case PT_GNU_RELRO:
> -       main_map->l_relro_addr = ph->p_vaddr;
> -       main_map->l_relro_size = ph->p_memsz;
> -       break;
> -      }
> -  /* Process program headers again, but scan them backwards so
> -     that PT_NOTE can be skipped if PT_GNU_PROPERTY exits.  */
> -  for (ph = &phdr[phnum]; ph != phdr; --ph)
> -    switch (ph[-1].p_type)
> -      {
> -      case PT_NOTE:
> -       _dl_process_pt_note (main_map, -1, &ph[-1]);
> -       break;
> -      case PT_GNU_PROPERTY:
> -       _dl_process_pt_gnu_property (main_map, -1, &ph[-1]);
> -       break;
> -      }
> -
> -  /* Adjust the address of the TLS initialization image in case
> -     the executable is actually an ET_DYN object.  */
> -  if (main_map->l_tls_initimage != NULL)
> -    main_map->l_tls_initimage
> -      = (char *) main_map->l_tls_initimage + main_map->l_addr;
> -  if (! main_map->l_map_end)
> -    main_map->l_map_end = ~0;
> -  if (! main_map->l_text_end)
> -    main_map->l_text_end = ~0;
> -  if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
> -    {
> -      /* We were invoked directly, so the program might not have a
> -        PT_INTERP.  */
> -      _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
> -      /* _dl_rtld_libname.next = NULL; Already zero.  */
> -      GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
> -    }
> -  else
> -    assert (GL(dl_rtld_map).l_libname); /* How else did we get here?  */
> +  bool has_interp = rtld_setup_main_map (main_map);
>
>    /* If the current libname is different from the SONAME, add the
>       latter as well.  */
> --
> 2.33.1
>

LGTM.

Reviewed-by: H.J. Lu <hjl.tools@gmail.com>

Thanks.
diff mbox series

Patch

diff --git a/elf/rtld.c b/elf/rtld.c
index 24e48bf3fa..ba6e31377d 100644
--- a/elf/rtld.c
+++ b/elf/rtld.c
@@ -1126,17 +1126,172 @@  rtld_chain_load (struct link_map *main_map, char *argv0)
 		     rtld_soname, pathname, errcode);
 }
 
+/* Called to complete the initialization of the link map for the main
+   executable.  Returns true if there is a PT_INTERP segment.  */
+static bool
+rtld_setup_main_map (struct link_map *main_map)
+{
+  /* This have already been filled in right after _dl_new_object, or
+     as part of _dl_map_object.  */
+  const ElfW(Phdr) *phdr = main_map->l_phdr;
+  ElfW(Word) phnum = main_map->l_phnum;
+
+  bool has_interp = false;
+
+  main_map->l_map_end = 0;
+  main_map->l_text_end = 0;
+  /* Perhaps the executable has no PT_LOAD header entries at all.  */
+  main_map->l_map_start = ~0;
+  /* And it was opened directly.  */
+  ++main_map->l_direct_opencount;
+
+  /* Scan the program header table for the dynamic section.  */
+  for (const ElfW(Phdr) *ph = phdr; ph < &phdr[phnum]; ++ph)
+    switch (ph->p_type)
+      {
+      case PT_PHDR:
+	/* Find out the load address.  */
+	main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
+	break;
+      case PT_DYNAMIC:
+	/* This tells us where to find the dynamic section,
+	   which tells us everything we need to do.  */
+	main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
+	main_map->l_ld_readonly = (ph->p_flags & PF_W) == 0;
+	break;
+      case PT_INTERP:
+	/* This "interpreter segment" was used by the program loader to
+	   find the program interpreter, which is this program itself, the
+	   dynamic linker.  We note what name finds us, so that a future
+	   dlopen call or DT_NEEDED entry, for something that wants to link
+	   against the dynamic linker as a shared library, will know that
+	   the shared object is already loaded.  */
+	_dl_rtld_libname.name = ((const char *) main_map->l_addr
+				 + ph->p_vaddr);
+	/* _dl_rtld_libname.next = NULL;	Already zero.  */
+	GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
+
+	/* Ordinarilly, we would get additional names for the loader from
+	   our DT_SONAME.  This can't happen if we were actually linked as
+	   a static executable (detect this case when we have no DYNAMIC).
+	   If so, assume the filename component of the interpreter path to
+	   be our SONAME, and add it to our name list.  */
+	if (GL(dl_rtld_map).l_ld == NULL)
+	  {
+	    const char *p = NULL;
+	    const char *cp = _dl_rtld_libname.name;
+
+	    /* Find the filename part of the path.  */
+	    while (*cp != '\0')
+	      if (*cp++ == '/')
+		p = cp;
+
+	    if (p != NULL)
+	      {
+		_dl_rtld_libname2.name = p;
+		/* _dl_rtld_libname2.next = NULL;  Already zero.  */
+		_dl_rtld_libname.next = &_dl_rtld_libname2;
+	      }
+	  }
+
+	has_interp = true;
+	break;
+      case PT_LOAD:
+	{
+	  ElfW(Addr) mapstart;
+	  ElfW(Addr) allocend;
+
+	  /* Remember where the main program starts in memory.  */
+	  mapstart = (main_map->l_addr
+		      + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
+	  if (main_map->l_map_start > mapstart)
+	    main_map->l_map_start = mapstart;
+
+	  /* Also where it ends.  */
+	  allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
+	  if (main_map->l_map_end < allocend)
+	    main_map->l_map_end = allocend;
+	  if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
+	    main_map->l_text_end = allocend;
+	}
+	break;
+
+      case PT_TLS:
+	if (ph->p_memsz > 0)
+	  {
+	    /* Note that in the case the dynamic linker we duplicate work
+	       here since we read the PT_TLS entry already in
+	       _dl_start_final.  But the result is repeatable so do not
+	       check for this special but unimportant case.  */
+	    main_map->l_tls_blocksize = ph->p_memsz;
+	    main_map->l_tls_align = ph->p_align;
+	    if (ph->p_align == 0)
+	      main_map->l_tls_firstbyte_offset = 0;
+	    else
+	      main_map->l_tls_firstbyte_offset = (ph->p_vaddr
+						  & (ph->p_align - 1));
+	    main_map->l_tls_initimage_size = ph->p_filesz;
+	    main_map->l_tls_initimage = (void *) ph->p_vaddr;
+
+	    /* This image gets the ID one.  */
+	    GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
+	  }
+	break;
+
+      case PT_GNU_STACK:
+	GL(dl_stack_flags) = ph->p_flags;
+	break;
+
+      case PT_GNU_RELRO:
+	main_map->l_relro_addr = ph->p_vaddr;
+	main_map->l_relro_size = ph->p_memsz;
+	break;
+      }
+  /* Process program headers again, but scan them backwards so
+     that PT_NOTE can be skipped if PT_GNU_PROPERTY exits.  */
+  for (const ElfW(Phdr) *ph = &phdr[phnum]; ph != phdr; --ph)
+    switch (ph[-1].p_type)
+      {
+      case PT_NOTE:
+	_dl_process_pt_note (main_map, -1, &ph[-1]);
+	break;
+      case PT_GNU_PROPERTY:
+	_dl_process_pt_gnu_property (main_map, -1, &ph[-1]);
+	break;
+      }
+
+  /* Adjust the address of the TLS initialization image in case
+     the executable is actually an ET_DYN object.  */
+  if (main_map->l_tls_initimage != NULL)
+    main_map->l_tls_initimage
+      = (char *) main_map->l_tls_initimage + main_map->l_addr;
+  if (! main_map->l_map_end)
+    main_map->l_map_end = ~0;
+  if (! main_map->l_text_end)
+    main_map->l_text_end = ~0;
+  if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
+    {
+      /* We were invoked directly, so the program might not have a
+	 PT_INTERP.  */
+      _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
+      /* _dl_rtld_libname.next = NULL;	Already zero.  */
+      GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
+    }
+  else
+    assert (GL(dl_rtld_map).l_libname); /* How else did we get here?  */
+
+  return has_interp;
+}
+
 static void
 dl_main (const ElfW(Phdr) *phdr,
 	 ElfW(Word) phnum,
 	 ElfW(Addr) *user_entry,
 	 ElfW(auxv_t) *auxv)
 {
-  const ElfW(Phdr) *ph;
   struct link_map *main_map;
   size_t file_size;
   char *file;
-  bool has_interp = false;
   unsigned int i;
   bool prelinked = false;
   bool rtld_is_main = false;
@@ -1350,7 +1505,7 @@  dl_main (const ElfW(Phdr) *phdr,
 	 load the program below unless it has a PT_GNU_STACK indicating
 	 nonexecutable stack is ok.  */
 
-      for (ph = phdr; ph < &phdr[phnum]; ++ph)
+      for (const ElfW(Phdr) *ph = phdr; ph < &phdr[phnum]; ++ph)
 	if (ph->p_type == PT_GNU_STACK)
 	  {
 	    GL(dl_stack_flags) = ph->p_flags;
@@ -1469,147 +1624,7 @@  dl_main (const ElfW(Phdr) *phdr,
 	 information for the program.  */
     }
 
-  main_map->l_map_end = 0;
-  main_map->l_text_end = 0;
-  /* Perhaps the executable has no PT_LOAD header entries at all.  */
-  main_map->l_map_start = ~0;
-  /* And it was opened directly.  */
-  ++main_map->l_direct_opencount;
-
-  /* Scan the program header table for the dynamic section.  */
-  for (ph = phdr; ph < &phdr[phnum]; ++ph)
-    switch (ph->p_type)
-      {
-      case PT_PHDR:
-	/* Find out the load address.  */
-	main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
-	break;
-      case PT_DYNAMIC:
-	/* This tells us where to find the dynamic section,
-	   which tells us everything we need to do.  */
-	main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
-	main_map->l_ld_readonly = (ph->p_flags & PF_W) == 0;
-	break;
-      case PT_INTERP:
-	/* This "interpreter segment" was used by the program loader to
-	   find the program interpreter, which is this program itself, the
-	   dynamic linker.  We note what name finds us, so that a future
-	   dlopen call or DT_NEEDED entry, for something that wants to link
-	   against the dynamic linker as a shared library, will know that
-	   the shared object is already loaded.  */
-	_dl_rtld_libname.name = ((const char *) main_map->l_addr
-				 + ph->p_vaddr);
-	/* _dl_rtld_libname.next = NULL;	Already zero.  */
-	GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
-
-	/* Ordinarilly, we would get additional names for the loader from
-	   our DT_SONAME.  This can't happen if we were actually linked as
-	   a static executable (detect this case when we have no DYNAMIC).
-	   If so, assume the filename component of the interpreter path to
-	   be our SONAME, and add it to our name list.  */
-	if (GL(dl_rtld_map).l_ld == NULL)
-	  {
-	    const char *p = NULL;
-	    const char *cp = _dl_rtld_libname.name;
-
-	    /* Find the filename part of the path.  */
-	    while (*cp != '\0')
-	      if (*cp++ == '/')
-		p = cp;
-
-	    if (p != NULL)
-	      {
-		_dl_rtld_libname2.name = p;
-		/* _dl_rtld_libname2.next = NULL;  Already zero.  */
-		_dl_rtld_libname.next = &_dl_rtld_libname2;
-	      }
-	  }
-
-	has_interp = true;
-	break;
-      case PT_LOAD:
-	{
-	  ElfW(Addr) mapstart;
-	  ElfW(Addr) allocend;
-
-	  /* Remember where the main program starts in memory.  */
-	  mapstart = (main_map->l_addr
-		      + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
-	  if (main_map->l_map_start > mapstart)
-	    main_map->l_map_start = mapstart;
-
-	  /* Also where it ends.  */
-	  allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
-	  if (main_map->l_map_end < allocend)
-	    main_map->l_map_end = allocend;
-	  if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
-	    main_map->l_text_end = allocend;
-	}
-	break;
-
-      case PT_TLS:
-	if (ph->p_memsz > 0)
-	  {
-	    /* Note that in the case the dynamic linker we duplicate work
-	       here since we read the PT_TLS entry already in
-	       _dl_start_final.  But the result is repeatable so do not
-	       check for this special but unimportant case.  */
-	    main_map->l_tls_blocksize = ph->p_memsz;
-	    main_map->l_tls_align = ph->p_align;
-	    if (ph->p_align == 0)
-	      main_map->l_tls_firstbyte_offset = 0;
-	    else
-	      main_map->l_tls_firstbyte_offset = (ph->p_vaddr
-						  & (ph->p_align - 1));
-	    main_map->l_tls_initimage_size = ph->p_filesz;
-	    main_map->l_tls_initimage = (void *) ph->p_vaddr;
-
-	    /* This image gets the ID one.  */
-	    GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
-	  }
-	break;
-
-      case PT_GNU_STACK:
-	GL(dl_stack_flags) = ph->p_flags;
-	break;
-
-      case PT_GNU_RELRO:
-	main_map->l_relro_addr = ph->p_vaddr;
-	main_map->l_relro_size = ph->p_memsz;
-	break;
-      }
-  /* Process program headers again, but scan them backwards so
-     that PT_NOTE can be skipped if PT_GNU_PROPERTY exits.  */
-  for (ph = &phdr[phnum]; ph != phdr; --ph)
-    switch (ph[-1].p_type)
-      {
-      case PT_NOTE:
-	_dl_process_pt_note (main_map, -1, &ph[-1]);
-	break;
-      case PT_GNU_PROPERTY:
-	_dl_process_pt_gnu_property (main_map, -1, &ph[-1]);
-	break;
-      }
-
-  /* Adjust the address of the TLS initialization image in case
-     the executable is actually an ET_DYN object.  */
-  if (main_map->l_tls_initimage != NULL)
-    main_map->l_tls_initimage
-      = (char *) main_map->l_tls_initimage + main_map->l_addr;
-  if (! main_map->l_map_end)
-    main_map->l_map_end = ~0;
-  if (! main_map->l_text_end)
-    main_map->l_text_end = ~0;
-  if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
-    {
-      /* We were invoked directly, so the program might not have a
-	 PT_INTERP.  */
-      _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
-      /* _dl_rtld_libname.next = NULL;	Already zero.  */
-      GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
-    }
-  else
-    assert (GL(dl_rtld_map).l_libname); /* How else did we get here?  */
+  bool has_interp = rtld_setup_main_map (main_map);
 
   /* If the current libname is different from the SONAME, add the
      latter as well.  */