sysdeps/alpha/dl-machine.h

   1 /* Machine-dependent ELF dynamic relocation inline functions.  Alpha version.
   2    Copyright (C) 1996-2021 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 /* This was written in the absence of an ABI -- don't expect
  20    it to remain unchanged.  */
  21
  22 #ifndef dl_machine_h
  23 #define dl_machine_h 1
  24
  25 #define ELF_MACHINE_NAME "alpha"
  26
  27 #include <string.h>
  28
  29
  30 /* Mask identifying addresses reserved for the user program,
  31    where the dynamic linker should not map anything.  */
  32 #define ELF_MACHINE_USER_ADDRESS_MASK   0x120000000UL
  33
  34 /* Translate a processor specific dynamic tag to the index in l_info array.  */
  35 #define DT_ALPHA(x) (DT_ALPHA_##x - DT_LOPROC + DT_NUM)
  36
  37 /* Return nonzero iff ELF header is compatible with the running host.  */
  38 static inline int
  39 elf_machine_matches_host (const Elf64_Ehdr *ehdr)
  40 {
  41   return ehdr->e_machine == EM_ALPHA;
  42 }
  43
  44 /* Return the link-time address of _DYNAMIC.  The multiple-got-capable
  45    linker no longer allocates the first .got entry for this.  But not to
  46    worry, no special tricks are needed.  */
  47 static inline Elf64_Addr
  48 elf_machine_dynamic (void)
  49 {
  50 #ifndef NO_AXP_MULTI_GOT_LD
  51   return (Elf64_Addr) &_DYNAMIC;
  52 #else
  53   register Elf64_Addr *gp __asm__ ("$29");
  54   return gp[-4096];
  55 #endif
  56 }
  57
  58 /* Return the run-time load address of the shared object.  */
  59
  60 static inline Elf64_Addr
  61 elf_machine_load_address (void)
  62 {
  63   /* This relies on the compiler using gp-relative addresses for static symbols.  */
  64   static void *dot = &dot;
  65   return (void *)&dot - dot;
  66 }
  67
  68 /* Set up the loaded object described by L so its unrelocated PLT
  69    entries will jump to the on-demand fixup code in dl-runtime.c.  */
  70
  71 static inline int
  72 elf_machine_runtime_setup (struct link_map *map, struct r_scope_elem *scope[],
  73                            int lazy, int profile)
  74 {
  75   extern char _dl_runtime_resolve_new[] attribute_hidden;
  76   extern char _dl_runtime_profile_new[] attribute_hidden;
  77   extern char _dl_runtime_resolve_old[] attribute_hidden;
  78   extern char _dl_runtime_profile_old[] attribute_hidden;
  79
  80   struct pltgot {
  81     char *resolve;
  82     struct link_map *link;
  83   };
  84
  85   struct pltgot *pg;
  86   long secureplt;
  87   char *resolve;
  88
  89   if (map->l_info[DT_JMPREL] == 0 || !lazy)
  90     return lazy;
  91
  92   /* Check to see if we're using the read-only plt form.  */
  93   secureplt = map->l_info[DT_ALPHA(PLTRO)] != 0;
  94
  95   /* If the binary uses the read-only secure plt format, PG points to
  96      the .got.plt section, which is the right place for ld.so to place
  97      its hooks.  Otherwise, PG is currently pointing at the start of
  98      the plt; the hooks go at offset 16.  */
  99   pg = (struct pltgot *) D_PTR (map, l_info[DT_PLTGOT]);
 100   pg += !secureplt;
 101
 102   /* This function will be called to perform the relocation.  They're
 103      not declared as functions to convince the compiler to use gp
 104      relative relocations for them.  */
 105   if (secureplt)
 106     resolve = _dl_runtime_resolve_new;
 107   else
 108     resolve = _dl_runtime_resolve_old;
 109
 110   if (__builtin_expect (profile, 0))
 111     {
 112       if (secureplt)
 113         resolve = _dl_runtime_profile_new;
 114       else
 115         resolve = _dl_runtime_profile_old;
 116
 117       if (GLRO(dl_profile) && _dl_name_match_p (GLRO(dl_profile), map))
 118         {
 119           /* This is the object we are looking for.  Say that we really
 120              want profiling and the timers are started.  */
 121           GL(dl_profile_map) = map;
 122         }
 123     }
 124
 125   pg->resolve = resolve;
 126   pg->link = map;
 127
 128   return lazy;
 129 }
 130
 131 /* Initial entry point code for the dynamic linker.
 132    The C function `_dl_start' is the real entry point;
 133    its return value is the user program's entry point.  */
 134
 135 #define RTLD_START asm ("\
 136         .section .text                                          \n\
 137         .set at                                                 \n\
 138         .globl _start                                           \n\
 139         .ent _start                                             \n\
 140 _start:                                                         \n\
 141         .frame $31,0,$31,0                                      \n\
 142         br      $gp, 0f                                         \n\
 143 0:      ldgp    $gp, 0($gp)                                     \n\
 144         .prologue 0                                             \n\
 145         /* Pass pointer to argument block to _dl_start.  */     \n\
 146         mov     $sp, $16                                        \n\
 147         bsr     $26, _dl_start          !samegp                 \n\
 148         .end _start                                             \n\
 149         /* FALLTHRU */                                          \n\
 150         .globl _dl_start_user                                   \n\
 151         .ent _dl_start_user                                     \n\
 152 _dl_start_user:                                                 \n\
 153         .frame $31,0,$31,0                                      \n\
 154         .prologue 0                                             \n\
 155         /* Save the user entry point address in s0.  */         \n\
 156         mov     $0, $9                                          \n\
 157         /* See if we were run as a command with the executable  \n\
 158            file name as an extra leading argument.  */          \n\
 159         ldah    $1, _dl_skip_args($gp)  !gprelhigh              \n\
 160         ldl     $1, _dl_skip_args($1)   !gprellow               \n\
 161         bne     $1, $fixup_stack                                \n\
 162 $fixup_stack_ret:                                               \n\
 163         /* The special initializer gets called with the stack   \n\
 164            just as the application's entry point will see it;   \n\
 165            it can switch stacks if it moves these contents      \n\
 166            over.  */                                            \n\
 167 " RTLD_START_SPECIAL_INIT "                                     \n\
 168         /* Call _dl_init(_dl_loaded, argc, argv, envp) to run   \n\
 169            initializers.  */                                    \n\
 170         ldah    $16, _rtld_local($gp)   !gprelhigh              \n\
 171         ldq     $16, _rtld_local($16)   !gprellow               \n\
 172         ldq     $17, 0($sp)                                     \n\
 173         lda     $18, 8($sp)                                     \n\
 174         s8addq  $17, 8, $19                                     \n\
 175         addq    $19, $18, $19                                   \n\
 176         bsr     $26, _dl_init           !samegp                 \n\
 177         /* Pass our finalizer function to the user in $0. */    \n\
 178         ldah    $0, _dl_fini($gp)       !gprelhigh              \n\
 179         lda     $0, _dl_fini($0)        !gprellow               \n\
 180         /* Jump to the user's entry point.  */                  \n\
 181         mov     $9, $27                                         \n\
 182         jmp     ($9)                                            \n\
 183 $fixup_stack:                                                   \n\
 184         /* Adjust the stack pointer to skip _dl_skip_args words.\n\
 185            This involves copying everything down, since the     \n\
 186            stack pointer must always be 16-byte aligned.  */    \n\
 187         ldah    $7, __GI__dl_argv($gp) !gprelhigh               \n\
 188         ldq     $2, 0($sp)                                      \n\
 189         ldq     $5, __GI__dl_argv($7) !gprellow                 \n\
 190         subq    $31, $1, $6                                     \n\
 191         subq    $2, $1, $2                                      \n\
 192         s8addq  $6, $5, $5                                      \n\
 193         mov     $sp, $4                                         \n\
 194         s8addq  $1, $sp, $3                                     \n\
 195         stq     $2, 0($sp)                                      \n\
 196         stq     $5, __GI__dl_argv($7) !gprellow                 \n\
 197         /* Copy down argv.  */                                  \n\
 198 0:      ldq     $5, 8($3)                                       \n\
 199         addq    $4, 8, $4                                       \n\
 200         addq    $3, 8, $3                                       \n\
 201         stq     $5, 0($4)                                       \n\
 202         bne     $5, 0b                                          \n\
 203         /* Copy down envp.  */                                  \n\
 204 1:      ldq     $5, 8($3)                                       \n\
 205         addq    $4, 8, $4                                       \n\
 206         addq    $3, 8, $3                                       \n\
 207         stq     $5, 0($4)                                       \n\
 208         bne     $5, 1b                                          \n\
 209         /* Copy down auxiliary table.  */                       \n\
 210 2:      ldq     $5, 8($3)                                       \n\
 211         ldq     $6, 16($3)                                      \n\
 212         addq    $4, 16, $4                                      \n\
 213         addq    $3, 16, $3                                      \n\
 214         stq     $5, -8($4)                                      \n\
 215         stq     $6, 0($4)                                       \n\
 216         bne     $5, 2b                                          \n\
 217         br      $fixup_stack_ret                                \n\
 218         .end _dl_start_user                                     \n\
 219         .set noat                                               \n\
 220 .previous");
 221
 222 #ifndef RTLD_START_SPECIAL_INIT
 223 #define RTLD_START_SPECIAL_INIT /* nothing */
 224 #endif
 225
 226 /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry
 227    or TLS variables, so undefined references should not be allowed
 228    to define the value.
 229
 230    ELF_RTYPE_CLASS_COPY iff TYPE should not be allowed to resolve
 231    to one of the main executable's symbols, as for a COPY reloc.
 232    This is unused on Alpha.  */
 233
 234 # define elf_machine_type_class(type)   \
 235   (((type) == R_ALPHA_JMP_SLOT          \
 236     || (type) == R_ALPHA_DTPMOD64       \
 237     || (type) == R_ALPHA_DTPREL64       \
 238     || (type) == R_ALPHA_TPREL64) * ELF_RTYPE_CLASS_PLT)
 239
 240 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
 241 #define ELF_MACHINE_JMP_SLOT     R_ALPHA_JMP_SLOT
 242
 243 /* The alpha never uses Elf64_Rel relocations.  */
 244 #define ELF_MACHINE_NO_REL 1
 245 #define ELF_MACHINE_NO_RELA 0
 246
 247 /* We define an initialization functions.  This is called very early in
 248  *    _dl_sysdep_start.  */
 249 #define DL_PLATFORM_INIT dl_platform_init ()
 250
 251 static inline void __attribute__ ((unused))
 252 dl_platform_init (void)
 253 {
 254         if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
 255         /* Avoid an empty string which would disturb us.  */
 256                 GLRO(dl_platform) = NULL;
 257 }
 258
 259 /* Fix up the instructions of a PLT entry to invoke the function
 260    rather than the dynamic linker.  */
 261 static inline Elf64_Addr
 262 elf_machine_fixup_plt (struct link_map *map, lookup_t t,
 263                        const ElfW(Sym) *refsym, const ElfW(Sym) *sym,
 264                        const Elf64_Rela *reloc,
 265                        Elf64_Addr *got_addr, Elf64_Addr value)
 266 {
 267   const Elf64_Rela *rela_plt;
 268   Elf64_Word *plte;
 269   long int edisp;
 270
 271   /* Store the value we are going to load.  */
 272   *got_addr = value;
 273
 274   /* If this binary uses the read-only secure plt format, we're done.  */
 275   if (map->l_info[DT_ALPHA(PLTRO)])
 276     return value;
 277
 278   /* Otherwise we have to modify the plt entry in place to do the branch.  */
 279
 280   /* Recover the PLT entry address by calculating reloc's index into the
 281      .rela.plt, and finding that entry in the .plt.  */
 282   rela_plt = (const Elf64_Rela *) D_PTR (map, l_info[DT_JMPREL]);
 283   plte = (Elf64_Word *) (D_PTR (map, l_info[DT_PLTGOT]) + 32);
 284   plte += 3 * (reloc - rela_plt);
 285
 286   /* Find the displacement from the plt entry to the function.  */
 287   edisp = (long int) (value - (Elf64_Addr)&plte[3]) / 4;
 288
 289   if (edisp >= -0x100000 && edisp < 0x100000)
 290     {
 291       /* If we are in range, use br to perfect branch prediction and
 292          elide the dependency on the address load.  This case happens,
 293          e.g., when a shared library call is resolved to the same library.  */
 294
 295       int hi, lo;
 296       hi = value - (Elf64_Addr)&plte[0];
 297       lo = (short int) hi;
 298       hi = (hi - lo) >> 16;
 299
 300       /* Emit "lda $27,lo($27)" */
 301       plte[1] = 0x237b0000 | (lo & 0xffff);
 302
 303       /* Emit "br $31,function" */
 304       plte[2] = 0xc3e00000 | (edisp & 0x1fffff);
 305
 306       /* Think about thread-safety -- the previous instructions must be
 307          committed to memory before the first is overwritten.  */
 308       __asm__ __volatile__("wmb" : : : "memory");
 309
 310       /* Emit "ldah $27,hi($27)" */
 311       plte[0] = 0x277b0000 | (hi & 0xffff);
 312     }
 313   else
 314     {
 315       /* Don't bother with the hint since we already know the hint is
 316          wrong.  Eliding it prevents the wrong page from getting pulled
 317          into the cache.  */
 318
 319       int hi, lo;
 320       hi = (Elf64_Addr)got_addr - (Elf64_Addr)&plte[0];
 321       lo = (short)hi;
 322       hi = (hi - lo) >> 16;
 323
 324       /* Emit "ldq $27,lo($27)" */
 325       plte[1] = 0xa77b0000 | (lo & 0xffff);
 326
 327       /* Emit "jmp $31,($27)" */
 328       plte[2] = 0x6bfb0000;
 329
 330       /* Think about thread-safety -- the previous instructions must be
 331          committed to memory before the first is overwritten.  */
 332       __asm__ __volatile__("wmb" : : : "memory");
 333
 334       /* Emit "ldah $27,hi($27)" */
 335       plte[0] = 0x277b0000 | (hi & 0xffff);
 336     }
 337
 338   /* At this point, if we've been doing runtime resolution, Icache is dirty.
 339      This will be taken care of in _dl_runtime_resolve.  If instead we are
 340      doing this as part of non-lazy startup relocation, that bit of code
 341      hasn't made it into Icache yet, so there's nothing to clean up.  */
 342
 343   return value;
 344 }
 345
 346 /* Return the final value of a plt relocation.  */
 347 static inline Elf64_Addr
 348 elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
 349                        Elf64_Addr value)
 350 {
 351   return value + reloc->r_addend;
 352 }
 353
 354 /* Names of the architecture-specific auditing callback functions.  */
 355 #define ARCH_LA_PLTENTER        alpha_gnu_pltenter
 356 #define ARCH_LA_PLTEXIT         alpha_gnu_pltexit
 357
 358 #endif /* !dl_machine_h */
 359
 360 #ifdef RESOLVE_MAP
 361
 362 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 363    MAP is the object containing the reloc.  */
 364 static inline void
 365 __attribute__ ((always_inline))
 366 elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
 367                   const Elf64_Rela *reloc,
 368                   const Elf64_Sym *sym,
 369                   const struct r_found_version *version,
 370                   void *const reloc_addr_arg,
 371                   int skip_ifunc)
 372 {
 373   Elf64_Addr *const reloc_addr = reloc_addr_arg;
 374   unsigned long int const r_type = ELF64_R_TYPE (reloc->r_info);
 375
 376 #if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC && !defined SHARED
 377   /* This is defined in rtld.c, but nowhere in the static libc.a; make the
 378      reference weak so static programs can still link.  This declaration
 379      cannot be done when compiling rtld.c (i.e.  #ifdef RTLD_BOOTSTRAP)
 380      because rtld.c contains the common defn for _dl_rtld_map, which is
 381      incompatible with a weak decl in the same file.  */
 382   weak_extern (_dl_rtld_map);
 383 #endif
 384
 385   /* We cannot use a switch here because we cannot locate the switch
 386      jump table until we've self-relocated.  */
 387
 388 #if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
 389   if (__builtin_expect (r_type == R_ALPHA_RELATIVE, 0))
 390     {
 391 # if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
 392       /* Already done in dynamic linker.  */
 393       if (map != &GL(dl_rtld_map))
 394 # endif
 395         {
 396           /* XXX Make some timings.  Maybe it's preferable to test for
 397              unaligned access and only do it the complex way if necessary.  */
 398           Elf64_Addr reloc_addr_val;
 399
 400           /* Load value without causing unaligned trap. */
 401           memcpy (&reloc_addr_val, reloc_addr_arg, 8);
 402           reloc_addr_val += map->l_addr;
 403
 404           /* Store value without causing unaligned trap. */
 405           memcpy (reloc_addr_arg, &reloc_addr_val, 8);
 406         }
 407     }
 408   else
 409 #endif
 410     if (__builtin_expect (r_type == R_ALPHA_NONE, 0))
 411       return;
 412   else
 413     {
 414       struct link_map *sym_map = RESOLVE_MAP (map, scope, &sym, version,
 415                                               r_type);
 416       Elf64_Addr sym_value;
 417       Elf64_Addr sym_raw_value;
 418
 419       sym_raw_value = sym_value = reloc->r_addend;
 420       if (sym_map)
 421         {
 422           sym_raw_value += sym->st_value;
 423           sym_value += SYMBOL_ADDRESS (sym_map, sym, true);
 424         }
 425
 426       if (r_type == R_ALPHA_GLOB_DAT)
 427         *reloc_addr = sym_value;
 428 #ifdef RESOLVE_CONFLICT_FIND_MAP
 429       /* In .gnu.conflict section, R_ALPHA_JMP_SLOT relocations have
 430          R_ALPHA_JMP_SLOT in lower 8 bits and the remaining 24 bits
 431          are .rela.plt index.  */
 432       else if ((r_type & 0xff) == R_ALPHA_JMP_SLOT)
 433         {
 434           /* elf_machine_fixup_plt needs the map reloc_addr points into,
 435              while in _dl_resolve_conflicts map is _dl_loaded.  */
 436           RESOLVE_CONFLICT_FIND_MAP (map, reloc_addr);
 437           reloc = ((const Elf64_Rela *) D_PTR (map, l_info[DT_JMPREL]))
 438                   + (r_type >> 8);
 439           elf_machine_fixup_plt (map, 0, 0, 0, reloc, reloc_addr, sym_value);
 440         }
 441 #else
 442       else if (r_type == R_ALPHA_JMP_SLOT)
 443         elf_machine_fixup_plt (map, 0, 0, 0, reloc, reloc_addr, sym_value);
 444 #endif
 445 #ifndef RTLD_BOOTSTRAP
 446       else if (r_type == R_ALPHA_REFQUAD)
 447         {
 448           /* Store value without causing unaligned trap.  */
 449           memcpy (reloc_addr_arg, &sym_value, 8);
 450         }
 451 #endif
 452       else if (r_type == R_ALPHA_DTPMOD64)
 453         {
 454 # ifdef RTLD_BOOTSTRAP
 455           /* During startup the dynamic linker is always index 1.  */
 456           *reloc_addr = 1;
 457 # else
 458           /* Get the information from the link map returned by the
 459              resolv function.  */
 460           if (sym_map != NULL)
 461             *reloc_addr = sym_map->l_tls_modid;
 462 # endif
 463         }
 464       else if (r_type == R_ALPHA_DTPREL64)
 465         {
 466 # ifndef RTLD_BOOTSTRAP
 467           /* During relocation all TLS symbols are defined and used.
 468              Therefore the offset is already correct.  */
 469           *reloc_addr = sym_raw_value;
 470 # endif
 471         }
 472       else if (r_type == R_ALPHA_TPREL64)
 473         {
 474 # ifdef RTLD_BOOTSTRAP
 475           *reloc_addr = sym_raw_value + map->l_tls_offset;
 476 # else
 477           if (sym_map)
 478             {
 479               CHECK_STATIC_TLS (map, sym_map);
 480               *reloc_addr = sym_raw_value + sym_map->l_tls_offset;
 481             }
 482 # endif
 483         }
 484       else
 485         _dl_reloc_bad_type (map, r_type, 0);
 486     }
 487 }
 488
 489 /* Let do-rel.h know that on Alpha if l_addr is 0, all RELATIVE relocs
 490    can be skipped.  */
 491 #define ELF_MACHINE_REL_RELATIVE 1
 492
 493 static inline void
 494 __attribute__ ((always_inline))
 495 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 496                            void *const reloc_addr_arg)
 497 {
 498   /* XXX Make some timings.  Maybe it's preferable to test for
 499      unaligned access and only do it the complex way if necessary.  */
 500   Elf64_Addr reloc_addr_val;
 501
 502   /* Load value without causing unaligned trap. */
 503   memcpy (&reloc_addr_val, reloc_addr_arg, 8);
 504   reloc_addr_val += l_addr;
 505
 506   /* Store value without causing unaligned trap. */
 507   memcpy (reloc_addr_arg, &reloc_addr_val, 8);
 508 }
 509
 510 static inline void
 511 __attribute__ ((always_inline))
 512 elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
 513                       Elf64_Addr l_addr, const Elf64_Rela *reloc,
 514                       int skip_ifunc)
 515 {
 516   Elf64_Addr * const reloc_addr = (void *)(l_addr + reloc->r_offset);
 517   unsigned long int const r_type = ELF64_R_TYPE (reloc->r_info);
 518
 519   if (r_type == R_ALPHA_JMP_SLOT)
 520     {
 521       /* Perform a RELATIVE reloc on the .got entry that transfers
 522          to the .plt.  */
 523       *reloc_addr += l_addr;
 524     }
 525   else if (r_type == R_ALPHA_NONE)
 526     return;
 527   else
 528     _dl_reloc_bad_type (map, r_type, 1);
 529 }
 530
 531 #endif /* RESOLVE_MAP */