sysdeps/aarch64/dl-machine.h

   1 /* Copyright (C) 1995-2023 Free Software Foundation, Inc.
   2
   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 License as
   7    published by the Free Software Foundation; either version 2.1 of the
   8    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 #ifndef dl_machine_h
  20 #define dl_machine_h
  21
  22 #define ELF_MACHINE_NAME "aarch64"
  23
  24 #include <sysdep.h>
  25 #include <tls.h>
  26 #include <dl-tlsdesc.h>
  27 #include <dl-static-tls.h>
  28 #include <dl-irel.h>
  29 #include <dl-machine-rel.h>
  30 #include <cpu-features.c>
  31
  32 /* Translate a processor specific dynamic tag to the index in l_info array.  */
  33 #define DT_AARCH64(x) (DT_AARCH64_##x - DT_LOPROC + DT_NUM)
  34
  35 /* Return nonzero iff ELF header is compatible with the running host.  */
  36 static inline int __attribute__ ((unused))
  37 elf_machine_matches_host (const ElfW(Ehdr) *ehdr)
  38 {
  39   return ehdr->e_machine == EM_AARCH64;
  40 }
  41
  42 /* Return the run-time load address of the shared object.  */
  43
  44 static inline ElfW(Addr) __attribute__ ((unused))
  45 elf_machine_load_address (void)
  46 {
  47   extern const ElfW(Ehdr) __ehdr_start attribute_hidden;
  48   return (ElfW(Addr)) &__ehdr_start;
  49 }
  50
  51 /* Return the link-time address of _DYNAMIC.  */
  52
  53 static inline ElfW(Addr) __attribute__ ((unused))
  54 elf_machine_dynamic (void)
  55 {
  56   extern ElfW(Dyn) _DYNAMIC[] attribute_hidden;
  57   return (ElfW(Addr)) _DYNAMIC - elf_machine_load_address ();
  58 }
  59
  60 /* Set up the loaded object described by L so its unrelocated PLT
  61    entries will jump to the on-demand fixup code in dl-runtime.c.  */
  62
  63 static inline int __attribute__ ((unused))
  64 elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
  65                            int lazy, int profile)
  66 {
  67   if (l->l_info[DT_JMPREL] && lazy)
  68     {
  69       ElfW(Addr) *got;
  70       extern void _dl_runtime_resolve (ElfW(Word));
  71       extern void _dl_runtime_profile (ElfW(Word));
  72
  73       got = (ElfW(Addr) *) D_PTR (l, l_info[DT_PLTGOT]);
  74       if (got[1])
  75         {
  76           l->l_mach.plt = got[1] + l->l_addr;
  77         }
  78       got[1] = (ElfW(Addr)) l;
  79
  80       /* The got[2] entry contains the address of a function which gets
  81          called to get the address of a so far unresolved function and
  82          jump to it.  The profiling extension of the dynamic linker allows
  83          to intercept the calls to collect information.  In this case we
  84          don't store the address in the GOT so that all future calls also
  85          end in this function.  */
  86       if ( profile)
  87         {
  88            got[2] = (ElfW(Addr)) &_dl_runtime_profile;
  89
  90           if (GLRO(dl_profile) != NULL
  91               && _dl_name_match_p (GLRO(dl_profile), l))
  92             /* Say that we really want profiling and the timers are
  93                started.  */
  94             GL(dl_profile_map) = l;
  95         }
  96       else
  97         {
  98           /* This function will get called to fix up the GOT entry
  99              indicated by the offset on the stack, and then jump to
 100              the resolved address.  */
 101           got[2] = (ElfW(Addr)) &_dl_runtime_resolve;
 102         }
 103     }
 104
 105   return lazy;
 106 }
 107
 108 /* In elf/rtld.c _dl_start should be global so dl-start.S can reference it.  */
 109 #define RTLD_START asm (".globl _dl_start");
 110
 111 #define elf_machine_type_class(type)                                    \
 112   ((((type) == R_AARCH64_JUMP_SLOT ||                                   \
 113      (type) == R_AARCH64_TLS_DTPMOD ||                                  \
 114      (type) == R_AARCH64_TLS_DTPREL ||                                  \
 115      (type) == R_AARCH64_TLS_TPREL ||                                   \
 116      (type) == R_AARCH64_TLSDESC) * ELF_RTYPE_CLASS_PLT)                \
 117    | (((type) == R_AARCH64_COPY) * ELF_RTYPE_CLASS_COPY))
 118
 119 #define ELF_MACHINE_JMP_SLOT    AARCH64_R(JUMP_SLOT)
 120
 121 #define DL_PLATFORM_INIT dl_platform_init ()
 122
 123 static inline void __attribute__ ((unused))
 124 dl_platform_init (void)
 125 {
 126   if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
 127     /* Avoid an empty string which would disturb us.  */
 128     GLRO(dl_platform) = NULL;
 129
 130 #ifdef SHARED
 131   /* init_cpu_features has been called early from __libc_start_main in
 132      static executable.  */
 133   init_cpu_features (&GLRO(dl_aarch64_cpu_features));
 134 #endif
 135 }
 136
 137
 138 static inline ElfW(Addr)
 139 elf_machine_fixup_plt (struct link_map *map, lookup_t t,
 140                        const ElfW(Sym) *refsym, const ElfW(Sym) *sym,
 141                        const ElfW(Rela) *reloc,
 142                        ElfW(Addr) *reloc_addr,
 143                        ElfW(Addr) value)
 144 {
 145   return *reloc_addr = value;
 146 }
 147
 148 /* Return the final value of a plt relocation.  */
 149 static inline ElfW(Addr)
 150 elf_machine_plt_value (struct link_map *map,
 151                        const ElfW(Rela) *reloc,
 152                        ElfW(Addr) value)
 153 {
 154   return value;
 155 }
 156
 157 #endif
 158
 159 /* Names of the architecture-specific auditing callback functions.  */
 160 #define ARCH_LA_PLTENTER aarch64_gnu_pltenter
 161 #define ARCH_LA_PLTEXIT  aarch64_gnu_pltexit
 162
 163 #ifdef RESOLVE_MAP
 164
 165 static inline void
 166 __attribute__ ((always_inline))
 167 elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
 168                   const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
 169                   const struct r_found_version *version,
 170                   void *const reloc_addr_arg, int skip_ifunc)
 171 {
 172   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
 173   const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
 174
 175   if (__builtin_expect (r_type == AARCH64_R(RELATIVE), 0))
 176       *reloc_addr = map->l_addr + reloc->r_addend;
 177   else if (__builtin_expect (r_type == R_AARCH64_NONE, 0))
 178       return;
 179   else
 180     {
 181 # ifndef RTLD_BOOTSTRAP
 182       const ElfW(Sym) *const refsym = sym;
 183 # endif
 184       struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
 185                                               r_type);
 186       ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
 187
 188       if (sym != NULL
 189           && __glibc_unlikely (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC)
 190           && __glibc_likely (sym->st_shndx != SHN_UNDEF)
 191           && __glibc_likely (!skip_ifunc))
 192         value = elf_ifunc_invoke (value);
 193
 194       switch (r_type)
 195         {
 196         case AARCH64_R(GLOB_DAT):
 197         case AARCH64_R(JUMP_SLOT):
 198           *reloc_addr = value + reloc->r_addend;
 199           break;
 200
 201 # ifndef RTLD_BOOTSTRAP
 202         case AARCH64_R(ABS32):
 203 #  ifdef __LP64__
 204         case AARCH64_R(ABS64):
 205 #  endif
 206           *reloc_addr = value + reloc->r_addend;
 207           break;
 208         case AARCH64_R(COPY):
 209           if (sym == NULL)
 210               break;
 211
 212           if (sym->st_size > refsym->st_size
 213               || (GLRO(dl_verbose) && sym->st_size < refsym->st_size))
 214             {
 215               const char *strtab;
 216
 217               strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
 218               _dl_error_printf ("\
 219 %s: Symbol `%s' has different size in shared object, consider re-linking\n",
 220                                 RTLD_PROGNAME, strtab + refsym->st_name);
 221             }
 222           memcpy (reloc_addr_arg, (void *) value,
 223                   sym->st_size < refsym->st_size
 224                   ? sym->st_size : refsym->st_size);
 225           break;
 226
 227         case AARCH64_R(TLSDESC):
 228           {
 229             struct tlsdesc volatile *td =
 230               (struct tlsdesc volatile *)reloc_addr;
 231             if (! sym)
 232               {
 233                 td->arg = (void*)reloc->r_addend;
 234                 td->entry = _dl_tlsdesc_undefweak;
 235               }
 236             else
 237               {
 238 # ifndef SHARED
 239                 CHECK_STATIC_TLS (map, sym_map);
 240 # else
 241                 if (!TRY_STATIC_TLS (map, sym_map))
 242                   {
 243                     td->arg = _dl_make_tlsdesc_dynamic
 244                       (sym_map, sym->st_value + reloc->r_addend);
 245                     td->entry = _dl_tlsdesc_dynamic;
 246                   }
 247                 else
 248 # endif
 249                   {
 250                     td->arg = (void*)(sym->st_value + sym_map->l_tls_offset
 251                                       + reloc->r_addend);
 252                     td->entry = _dl_tlsdesc_return;
 253                   }
 254               }
 255             break;
 256           }
 257
 258         case AARCH64_R(TLS_DTPMOD):
 259           if (sym_map != NULL)
 260             {
 261               *reloc_addr = sym_map->l_tls_modid;
 262             }
 263           break;
 264
 265         case AARCH64_R(TLS_DTPREL):
 266           if (sym)
 267             *reloc_addr = sym->st_value + reloc->r_addend;
 268           break;
 269
 270         case AARCH64_R(TLS_TPREL):
 271           if (sym)
 272             {
 273               CHECK_STATIC_TLS (map, sym_map);
 274               *reloc_addr =
 275                 sym->st_value + reloc->r_addend + sym_map->l_tls_offset;
 276             }
 277           break;
 278
 279         case AARCH64_R(IRELATIVE):
 280           value = map->l_addr + reloc->r_addend;
 281           if (__glibc_likely (!skip_ifunc))
 282             value = elf_ifunc_invoke (value);
 283           *reloc_addr = value;
 284           break;
 285 # endif /* !RTLD_BOOTSTRAP */
 286
 287         default:
 288           _dl_reloc_bad_type (map, r_type, 0);
 289           break;
 290         }
 291     }
 292 }
 293
 294 static inline void
 295 __attribute__ ((always_inline))
 296 elf_machine_rela_relative (ElfW(Addr) l_addr,
 297                            const ElfW(Rela) *reloc,
 298                            void *const reloc_addr_arg)
 299 {
 300   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
 301   *reloc_addr = l_addr + reloc->r_addend;
 302 }
 303
 304 static inline void
 305 __attribute__ ((always_inline))
 306 elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 307                       ElfW(Addr) l_addr,
 308                       const ElfW(Rela) *reloc,
 309                       int skip_ifunc)
 310 {
 311   ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
 312   const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
 313   /* Check for unexpected PLT reloc type.  */
 314   if (__builtin_expect (r_type == AARCH64_R(JUMP_SLOT), 1))
 315     {
 316       if (__glibc_unlikely (map->l_info[DT_AARCH64 (VARIANT_PCS)] != NULL))
 317         {
 318           /* Check the symbol table for variant PCS symbols.  */
 319           const Elf_Symndx symndx = ELFW (R_SYM) (reloc->r_info);
 320           const ElfW (Sym) *symtab =
 321             (const void *)D_PTR (map, l_info[DT_SYMTAB]);
 322           const ElfW (Sym) *sym = &symtab[symndx];
 323           if (__glibc_unlikely (sym->st_other & STO_AARCH64_VARIANT_PCS))
 324             {
 325               /* Avoid lazy resolution of variant PCS symbols.  */
 326               const struct r_found_version *version = NULL;
 327               if (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 328                 {
 329                   const ElfW (Half) *vernum =
 330                     (const void *)D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
 331                   version = &map->l_versions[vernum[symndx] & 0x7fff];
 332                 }
 333               elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
 334                                 skip_ifunc);
 335               return;
 336             }
 337         }
 338
 339       if (map->l_mach.plt == 0)
 340         *reloc_addr += l_addr;
 341       else
 342         *reloc_addr = map->l_mach.plt;
 343     }
 344   else if (__builtin_expect (r_type == AARCH64_R(TLSDESC), 1))
 345     {
 346       const Elf_Symndx symndx = ELFW (R_SYM) (reloc->r_info);
 347       const ElfW (Sym) *symtab = (const void *)D_PTR (map, l_info[DT_SYMTAB]);
 348       const ElfW (Sym) *sym = &symtab[symndx];
 349       const struct r_found_version *version = NULL;
 350
 351       if (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 352         {
 353           const ElfW (Half) *vernum =
 354             (const void *)D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
 355           version = &map->l_versions[vernum[symndx] & 0x7fff];
 356         }
 357
 358       /* Always initialize TLS descriptors completely, because lazy
 359          initialization requires synchronization at every TLS access.  */
 360       elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
 361                         skip_ifunc);
 362     }
 363   else if (__glibc_unlikely (r_type == AARCH64_R(IRELATIVE)))
 364     {
 365       ElfW(Addr) value = map->l_addr + reloc->r_addend;
 366       if (__glibc_likely (!skip_ifunc))
 367         value = elf_ifunc_invoke (value);
 368       *reloc_addr = value;
 369     }
 370   else
 371     _dl_reloc_bad_type (map, r_type, 1);
 372 }
 373
 374 #endif