elf/do-rel.h

   1 /* Do relocations for ELF dynamic linking.
   2    Copyright (C) 1995-2022 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <ldsodefs.h>
  20
  21 /* This file may be included twice, to define both
  22    `elf_dynamic_do_rel' and `elf_dynamic_do_rela'.  */
  23
  24 #ifdef DO_RELA
  25 # define elf_dynamic_do_Rel             elf_dynamic_do_Rela
  26 # define Rel                            Rela
  27 # define elf_machine_rel                elf_machine_rela
  28 # define elf_machine_rel_relative       elf_machine_rela_relative
  29 #endif
  30
  31 #ifndef DO_ELF_MACHINE_REL_RELATIVE
  32 # define DO_ELF_MACHINE_REL_RELATIVE(map, l_addr, relative) \
  33   elf_machine_rel_relative (l_addr, relative,                                 \
  34                             (void *) (l_addr + relative->r_offset))
  35 #endif
  36
  37 /* Perform the relocations in MAP on the running program image as specified
  38    by RELTAG, SZTAG.  If LAZY is nonzero, this is the first pass on PLT
  39    relocations; they should be set up to call _dl_runtime_resolve, rather
  40    than fully resolved now.  */
  41
  42 static inline void __attribute__ ((always_inline))
  43 elf_dynamic_do_Rel (struct link_map *map, struct r_scope_elem *scope[],
  44                     ElfW(Addr) reladdr, ElfW(Addr) relsize,
  45                     __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative,
  46                     int lazy, int skip_ifunc)
  47 {
  48   const ElfW(Rel) *r = (const void *) reladdr;
  49   const ElfW(Rel) *end = (const void *) (reladdr + relsize);
  50   ElfW(Addr) l_addr = map->l_addr;
  51 # if defined ELF_MACHINE_IRELATIVE && !defined RTLD_BOOTSTRAP
  52   const ElfW(Rel) *r2 = NULL;
  53   const ElfW(Rel) *end2 = NULL;
  54 # endif
  55
  56 #if (!defined DO_RELA || !defined ELF_MACHINE_PLT_REL) && !defined RTLD_BOOTSTRAP
  57   /* We never bind lazily during ld.so bootstrap.  Unfortunately gcc is
  58      not clever enough to see through all the function calls to realize
  59      that.  */
  60   if (lazy)
  61     {
  62       /* Doing lazy PLT relocations; they need very little info.  */
  63       for (; r < end; ++r)
  64 # ifdef ELF_MACHINE_IRELATIVE
  65         if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_IRELATIVE)
  66           {
  67             if (r2 == NULL)
  68               r2 = r;
  69             end2 = r;
  70           }
  71         else
  72 # endif
  73           elf_machine_lazy_rel (map, scope, l_addr, r, skip_ifunc);
  74
  75 # ifdef ELF_MACHINE_IRELATIVE
  76       if (r2 != NULL)
  77         for (; r2 <= end2; ++r2)
  78           if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
  79             elf_machine_lazy_rel (map, scope, l_addr, r2, skip_ifunc);
  80 # endif
  81     }
  82   else
  83 #endif
  84     {
  85       const ElfW(Sym) *const symtab =
  86         (const void *) D_PTR (map, l_info[DT_SYMTAB]);
  87       const ElfW(Rel) *relative = r;
  88       r += nrelative;
  89
  90 #ifndef RTLD_BOOTSTRAP
  91       /* This is defined in rtld.c, but nowhere in the static libc.a; make
  92          the reference weak so static programs can still link.  This
  93          declaration cannot be done when compiling rtld.c (i.e. #ifdef
  94          RTLD_BOOTSTRAP) because rtld.c contains the common defn for
  95          _dl_rtld_map, which is incompatible with a weak decl in the same
  96          file.  */
  97 # ifndef SHARED
  98       weak_extern (GL(dl_rtld_map));
  99 # endif
 100       if (map != &GL(dl_rtld_map)) /* Already done in rtld itself.  */
 101 # if !defined DO_RELA || defined ELF_MACHINE_REL_RELATIVE
 102         /* Rela platforms get the offset from r_addend and this must
 103            be copied in the relocation address.  Therefore we can skip
 104            the relative relocations only if this is for rel
 105            relocations or rela relocations if they are computed as
 106            memory_loc += l_addr...  */
 107         if (l_addr != 0)
 108 # endif
 109 #endif
 110           for (; relative < r; ++relative)
 111             DO_ELF_MACHINE_REL_RELATIVE (map, l_addr, relative);
 112
 113 #ifdef RTLD_BOOTSTRAP
 114       /* The dynamic linker always uses versioning.  */
 115       assert (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL);
 116 #else
 117       if (map->l_info[VERSYMIDX (DT_VERSYM)])
 118 #endif
 119         {
 120           const ElfW(Half) *const version =
 121             (const void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
 122
 123           for (; r < end; ++r)
 124             {
 125               ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
 126               const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (r->r_info)];
 127               void *const r_addr_arg = (void *) (l_addr + r->r_offset);
 128               const struct r_found_version *rversion = &map->l_versions[ndx];
 129 #if defined ELF_MACHINE_IRELATIVE && !defined RTLD_BOOTSTRAP
 130               if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_IRELATIVE)
 131                 {
 132                   if (r2 == NULL)
 133                     r2 = r;
 134                   end2 = r;
 135                   continue;
 136                 }
 137 #endif
 138
 139               elf_machine_rel (map, scope, r, sym, rversion, r_addr_arg,
 140                                skip_ifunc);
 141 #if defined SHARED && !defined RTLD_BOOTSTRAP
 142               if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_JMP_SLOT
 143                   && GLRO(dl_naudit) > 0)
 144                 {
 145                   struct link_map *sym_map
 146                     = RESOLVE_MAP (map, scope, &sym, rversion,
 147                                    ELF_MACHINE_JMP_SLOT);
 148                   if (sym != NULL)
 149                     _dl_audit_symbind (map, NULL, sym, r_addr_arg, sym_map);
 150                 }
 151 #endif
 152             }
 153
 154 #if defined ELF_MACHINE_IRELATIVE && !defined RTLD_BOOTSTRAP
 155           if (r2 != NULL)
 156             for (; r2 <= end2; ++r2)
 157               if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
 158                 {
 159                   ElfW(Half) ndx
 160                     = version[ELFW(R_SYM) (r2->r_info)] & 0x7fff;
 161                   elf_machine_rel (map, scope, r2,
 162                                    &symtab[ELFW(R_SYM) (r2->r_info)],
 163                                    &map->l_versions[ndx],
 164                                    (void *) (l_addr + r2->r_offset),
 165                                    skip_ifunc);
 166                 }
 167 #endif
 168         }
 169 #ifndef RTLD_BOOTSTRAP
 170       else
 171         {
 172           for (; r < end; ++r)
 173             {
 174               const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (r->r_info)];
 175               void *const r_addr_arg = (void *) (l_addr + r->r_offset);
 176 # ifdef ELF_MACHINE_IRELATIVE
 177               if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_IRELATIVE)
 178                 {
 179                   if (r2 == NULL)
 180                     r2 = r;
 181                   end2 = r;
 182                   continue;
 183                 }
 184 # endif
 185               elf_machine_rel (map, scope, r, sym, NULL, r_addr_arg,
 186                                skip_ifunc);
 187 # if defined SHARED && !defined RTLD_BOOTSTRAP
 188               if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_JMP_SLOT
 189                   && GLRO(dl_naudit) > 0)
 190                 {
 191                   struct link_map *sym_map
 192                     = RESOLVE_MAP (map, scope, &sym,
 193                                    (struct r_found_version *) NULL,
 194                                    ELF_MACHINE_JMP_SLOT);
 195                   if (sym != NULL)
 196                     _dl_audit_symbind (map, NULL , sym,r_addr_arg, sym_map);
 197                 }
 198 # endif
 199             }
 200
 201 # ifdef ELF_MACHINE_IRELATIVE
 202           if (r2 != NULL)
 203             for (; r2 <= end2; ++r2)
 204               if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
 205                 elf_machine_rel (map, scope, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
 206                                  NULL, (void *) (l_addr + r2->r_offset),
 207                                  skip_ifunc);
 208 # endif
 209         }
 210 #endif
 211     }
 212 }
 213
 214 #undef elf_dynamic_do_Rel
 215 #undef Rel
 216 #undef elf_machine_rel
 217 #undef elf_machine_rel_relative
 218 #undef DO_ELF_MACHINE_REL_RELATIVE
 219 #undef DO_RELA