sysdeps/arc/dl-machine.h

   1 /* Machine-dependent ELF dynamic relocation inline functions.  ARC version.
   2    Copyright (C) 2020-2023 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 #ifndef dl_machine_h
  20 #define dl_machine_h
  21
  22 #define ELF_MACHINE_NAME "arc"
  23
  24 #include <entry.h>
  25
  26 #ifndef ENTRY_POINT
  27 # error ENTRY_POINT needs to be defined for ARC
  28 #endif
  29
  30 #include <string.h>
  31 #include <link.h>
  32 #include <dl-tls.h>
  33 #include <dl-static-tls.h>
  34 #include <dl-machine-rel.h>
  35
  36 /* Dynamic Linking ABI for ARCv2 ISA.
  37
  38                         PLT
  39           --------------------------------      <---- DT_PLTGOT
  40           |  ld r11, [pcl, off-to-GOT[1] |  0
  41           |                              |  4
  42    plt0   |  ld r10, [pcl, off-to-GOT[2] |  8
  43           |                              | 12
  44           |  j [r10]                     | 16
  45           --------------------------------
  46           |    Base address of GOT       | 20
  47           --------------------------------
  48           |  ld r12, [pcl, off-to-GOT[3] | 24
  49    plt1   |                              |
  50           |  j.d    [r12]                | 32
  51           |  mov    r12, pcl             | 36
  52           --------------------------------
  53           |                              | 40
  54           ~                              ~
  55           ~                              ~
  56           |                              |
  57           --------------------------------
  58
  59                .got
  60           --------------
  61           |    [0]     |
  62           |    ...     |  Runtime address for data symbols
  63           |    [n]     |
  64           --------------
  65
  66             .got.plt
  67           --------------
  68           |    [0]     |  Build address of .dynamic
  69           --------------
  70           |    [1]     |  Module info - setup by ld.so
  71           --------------
  72           |    [2]     |  resolver entry point
  73           --------------
  74           |    [3]     |
  75           |    ...     |  Runtime address for function symbols
  76           |    [f]     |
  77           --------------
  78
  79    For ARCompact, the PLT is 12 bytes due to short instructions
  80
  81           --------------------------------
  82           |  ld r12, [pcl, off-to-GOT[3] | 24   (12 bytes each)
  83    plt1   |                              |
  84           |  j_s.d  [r12]                | 32
  85           |  mov_s  r12, pcl             | 34
  86           --------------------------------
  87           |                              | 36  */
  88
  89 /* Return nonzero iff ELF header is compatible with the running host.  */
  90 static inline int
  91 elf_machine_matches_host (const ElfW(Ehdr) *ehdr)
  92 {
  93   return (ehdr->e_machine == EM_ARCV2            /* ARC HS.  */
  94           || ehdr->e_machine == EM_ARC_COMPACT); /* ARC 700.  */
  95 }
  96
  97 /* Get build time address of .dynamic as setup in GOT[0]
  98    This is called very early in _dl_start so it has not been relocated to
  99    runtime value.  */
 100 static inline ElfW(Addr)
 101 elf_machine_dynamic (void)
 102 {
 103   extern const ElfW(Addr) _GLOBAL_OFFSET_TABLE_[] attribute_hidden;
 104   return _GLOBAL_OFFSET_TABLE_[0];
 105 }
 106
 107
 108 /* Return the run-time load address of the shared object.  */
 109 static inline ElfW(Addr)
 110 elf_machine_load_address (void)
 111 {
 112   ElfW(Addr) build_addr, run_addr;
 113
 114   /* For build address, below generates
 115      ld  r0, [pcl, _GLOBAL_OFFSET_TABLE_@pcl].  */
 116   build_addr = elf_machine_dynamic ();
 117   __asm__ ("add %0, pcl, _DYNAMIC@pcl   \n" : "=r" (run_addr));
 118
 119   return run_addr - build_addr;
 120 }
 121
 122 /* Set up the loaded object described by L so its unrelocated PLT
 123    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 124
 125 static inline int
 126 __attribute__ ((always_inline))
 127 elf_machine_runtime_setup (struct link_map *l, struct r_scope_elem *scope[],
 128                            int lazy, int profile)
 129 {
 130   extern void _dl_runtime_resolve (void);
 131
 132   if (l->l_info[DT_JMPREL] && lazy)
 133     {
 134       /* On ARC DT_PLTGOT point to .plt whose 5th word (after the PLT header)
 135          contains the address of .got.  */
 136       ElfW(Addr) *plt_base = (ElfW(Addr) *) D_PTR (l, l_info[DT_PLTGOT]);
 137       ElfW(Addr) *got = (ElfW(Addr) *) (plt_base[5] + l->l_addr);
 138
 139       got[1] = (ElfW(Addr)) l;  /* Identify this shared object.  */
 140
 141       /* This function will get called to fix up the GOT entry indicated by
 142          the offset on the stack, and then jump to the resolved address.  */
 143       got[2] = (ElfW(Addr)) &_dl_runtime_resolve;
 144     }
 145
 146   return lazy;
 147 }
 148
 149 /* What this code does:
 150     -ldso starts execution here when kernel returns from execve
 151     -calls into generic ldso entry point _dl_start
 152     -optionally adjusts argc for executable if exec passed as cmd
 153     -calls into app main with address of finaliser.  */
 154
 155 #define RTLD_START asm ("\
 156 .text                                                                   \n\
 157 .globl __start                                                          \n\
 158 .type __start, @function                                                \n\
 159 __start:                                                                \n\
 160         /* (1). bootstrap ld.so.  */                                    \n\
 161         bl.d    _dl_start                                               \n\
 162         mov_s   r0, sp  /* pass ptr to aux vector tbl.    */            \n\
 163         mov r13, r0     /* safekeep app elf entry point.  */            \n\
 164         ld_s    r1, [sp]       /* orig argc.  */                        \n\
 165                                                                         \n\
 166         /* (2). call preinit stuff.  */                                 \n\
 167         ld      r0, [pcl, _rtld_local@pcl]                              \n\
 168         add     r2, sp, 4       ; argv                                  \n\
 169         add2    r3, r2, r1                                              \n\
 170         add     r3, r3, 4       ; env                                   \n\
 171         bl      _dl_init@plt                                            \n\
 172                                                                         \n\
 173         /* (3) call app elf entry point.  */                            \n\
 174         add     r0, pcl, _dl_fini@pcl                                   \n\
 175         j       [r13]                                                   \n\
 176                                                                         \n\
 177         .size  __start,.-__start                                        \n\
 178         .previous                                                       \n\
 179 ");
 180
 181 /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry, so
 182    PLT entries should not be allowed to define the value.
 183    ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to one
 184    of the main executable's symbols, as for a COPY reloc.  */
 185 #define elf_machine_type_class(type)                            \
 186   ((((type) == R_ARC_JMP_SLOT                                   \
 187      || (type) == R_ARC_TLS_DTPMOD                              \
 188      || (type) == R_ARC_TLS_DTPOFF                              \
 189      || (type) == R_ARC_TLS_TPOFF) * ELF_RTYPE_CLASS_PLT)       \
 190    | (((type) == R_ARC_COPY) * ELF_RTYPE_CLASS_COPY))
 191
 192 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
 193 #define ELF_MACHINE_JMP_SLOT  R_ARC_JMP_SLOT
 194
 195 /* Fixup a PLT entry to bounce directly to the function at VALUE.  */
 196
 197 static inline ElfW(Addr)
 198 elf_machine_fixup_plt (struct link_map *map, lookup_t t,
 199                        const ElfW(Sym) *refsym, const ElfW(Sym) *sym,
 200                        const ElfW(Rela) *reloc,
 201                        ElfW(Addr) *reloc_addr, ElfW(Addr) value)
 202 {
 203   return *reloc_addr = value;
 204 }
 205
 206 /* Return the final value of a plt relocation.  */
 207 #define elf_machine_plt_value(map, reloc, value) (value)
 208
 209 /* Names of the architecture-specific auditing callback functions.  */
 210 #define ARCH_LA_PLTENTER arc_gnu_pltenter
 211 #define ARCH_LA_PLTEXIT arc_gnu_pltexit
 212
 213 #endif /* dl_machine_h */
 214
 215 #ifdef RESOLVE_MAP
 216
 217 static inline void
 218 __attribute__ ((always_inline))
 219 elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
 220                   const ElfW(Rela) *reloc, const ElfW(Sym) *sym,
 221                   const struct r_found_version *version,
 222                   void *const reloc_addr_arg, int skip_ifunc)
 223 {
 224   ElfW(Addr) r_info = reloc->r_info;
 225   const unsigned long int r_type = ELFW (R_TYPE) (r_info);
 226   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
 227
 228   if (__glibc_unlikely (r_type == R_ARC_RELATIVE))
 229     *reloc_addr += map->l_addr;
 230   else if (__glibc_unlikely (r_type == R_ARC_NONE))
 231     return;
 232   else
 233     {
 234       const ElfW(Sym) *const refsym = sym;
 235       struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
 236                                               r_type);
 237       ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
 238
 239       switch (r_type)
 240         {
 241         case R_ARC_COPY:
 242           if (__glibc_unlikely (sym == NULL))
 243             /* This can happen in trace mode if an object could not be
 244                found.  */
 245             break;
 246
 247           size_t size = sym->st_size;
 248           if (__glibc_unlikely (size != refsym->st_size))
 249             {
 250               const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
 251               if (sym->st_size > refsym->st_size)
 252                 size = refsym->st_size;
 253               if (sym->st_size > refsym->st_size || GLRO(dl_verbose))
 254                 _dl_error_printf ("\
 255   %s: Symbol `%s' has different size in shared object, consider re-linking\n",
 256                                   rtld_progname ?: "<program name unknown>",
 257                                   strtab + refsym->st_name);
 258             }
 259
 260           memcpy (reloc_addr_arg, (void *) value, size);
 261           break;
 262
 263         case R_ARC_GLOB_DAT:
 264         case R_ARC_JMP_SLOT:
 265             *reloc_addr = value;
 266           break;
 267
 268         case R_ARC_TLS_DTPMOD:
 269           if (sym_map != NULL)
 270             /* Get the information from the link map returned by the
 271                resolv function.  */
 272             *reloc_addr = sym_map->l_tls_modid;
 273           break;
 274
 275         case R_ARC_TLS_DTPOFF:
 276           if (sym != NULL)
 277             /* Offset set by the linker in the GOT entry would be overwritten
 278                by dynamic loader instead of added to the symbol location.
 279                Other target have the same approach on DTPOFF relocs.  */
 280             *reloc_addr += sym->st_value;
 281           break;
 282
 283         case R_ARC_TLS_TPOFF:
 284           if (sym != NULL)
 285             {
 286               CHECK_STATIC_TLS (map, sym_map);
 287               *reloc_addr = sym_map->l_tls_offset + sym->st_value + reloc->r_addend;
 288             }
 289           break;
 290
 291         case R_ARC_32:
 292           *reloc_addr += value + reloc->r_addend;
 293           break;
 294
 295         case R_ARC_PC32:
 296           *reloc_addr += value + reloc->r_addend - (unsigned long int) reloc_addr;
 297           break;
 298
 299         default:
 300           _dl_reloc_bad_type (map, r_type, 0);
 301           break;
 302         }
 303     }
 304 }
 305
 306 static inline void
 307 __attribute__ ((always_inline))
 308 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 309                            void *const reloc_addr_arg)
 310 {
 311   ElfW(Addr) *const reloc_addr = reloc_addr_arg;
 312   *reloc_addr += l_addr;
 313 }
 314
 315 static inline void
 316 __attribute__ ((always_inline))
 317 elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 318                       ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 319                       int skip_ifunc)
 320 {
 321   ElfW(Addr) *const reloc_addr = (void *) (l_addr + reloc->r_offset);
 322   const unsigned int r_type = ELFW (R_TYPE) (reloc->r_info);
 323
 324   if (r_type == R_ARC_JMP_SLOT)
 325     *reloc_addr += l_addr;
 326   else
 327     _dl_reloc_bad_type (map, r_type, 1);
 328 }
 329
 330 #endif /* RESOLVE_MAP */