sysdeps/x86_64/dl-machine.h

   1 /* Machine-dependent ELF dynamic relocation inline functions.  x86-64 version.
   2    Copyright (C) 2001-2006, 2008, 2009, 2010 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Andreas Jaeger <aj@suse.de>.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #ifndef dl_machine_h
  22 #define dl_machine_h
  23
  24 #define ELF_MACHINE_NAME "x86_64"
  25
  26 #include <sys/param.h>
  27 #include <sysdep.h>
  28 #include <tls.h>
  29 #include <dl-tlsdesc.h>
  30
  31 /* Return nonzero iff ELF header is compatible with the running host.  */
  32 static inline int __attribute__ ((unused))
  33 elf_machine_matches_host (const Elf64_Ehdr *ehdr)
  34 {
  35   return ehdr->e_machine == EM_X86_64;
  36 }
  37
  38
  39 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
  40    first element of the GOT.  This must be inlined in a function which
  41    uses global data.  */
  42 static inline Elf64_Addr __attribute__ ((unused))
  43 elf_machine_dynamic (void)
  44 {
  45   Elf64_Addr addr;
  46
  47   /* This works because we have our GOT address available in the small PIC
  48      model.  */
  49   addr = (Elf64_Addr) &_DYNAMIC;
  50
  51   return addr;
  52 }
  53
  54
  55 /* Return the run-time load address of the shared object.  */
  56 static inline Elf64_Addr __attribute__ ((unused))
  57 elf_machine_load_address (void)
  58 {
  59   Elf64_Addr addr;
  60
  61   /* The easy way is just the same as on x86:
  62        leaq _dl_start, %0
  63        leaq _dl_start(%%rip), %1
  64        subq %0, %1
  65      but this does not work with binutils since we then have
  66      a R_X86_64_32S relocation in a shared lib.
  67
  68      Instead we store the address of _dl_start in the data section
  69      and compare it with the current value that we can get via
  70      an RIP relative addressing mode.  Note that this is the address
  71      of _dl_start before any relocation performed at runtime.  In case
  72      the binary is prelinked the resulting "address" is actually a
  73      load offset which is zero if the binary was loaded at the address
  74      it is prelinked for.  */
  75
  76   asm ("leaq _dl_start(%%rip), %0\n\t"
  77        "subq 1f(%%rip), %0\n\t"
  78        ".section\t.data.rel.ro\n"
  79        "1:\t.quad _dl_start\n\t"
  80        ".previous\n\t"
  81        : "=r" (addr) : : "cc");
  82
  83   return addr;
  84 }
  85
  86 /* Set up the loaded object described by L so its unrelocated PLT
  87    entries will jump to the on-demand fixup code in dl-runtime.c.  */
  88
  89 static inline int __attribute__ ((unused, always_inline))
  90 elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
  91 {
  92   Elf64_Addr *got;
  93   extern void _dl_runtime_resolve (Elf64_Word) attribute_hidden;
  94   extern void _dl_runtime_profile (Elf64_Word) attribute_hidden;
  95
  96   if (l->l_info[DT_JMPREL] && lazy)
  97     {
  98       /* The GOT entries for functions in the PLT have not yet been filled
  99          in.  Their initial contents will arrange when called to push an
 100          offset into the .rel.plt section, push _GLOBAL_OFFSET_TABLE_[1],
 101          and then jump to _GLOBAL_OFFSET_TABLE[2].  */
 102       got = (Elf64_Addr *) D_PTR (l, l_info[DT_PLTGOT]);
 103       /* If a library is prelinked but we have to relocate anyway,
 104          we have to be able to undo the prelinking of .got.plt.
 105          The prelinker saved us here address of .plt + 0x16.  */
 106       if (got[1])
 107         {
 108           l->l_mach.plt = got[1] + l->l_addr;
 109           l->l_mach.gotplt = (Elf64_Addr) &got[3];
 110         }
 111       got[1] = (Elf64_Addr) l;  /* Identify this shared object.  */
 112
 113       /* The got[2] entry contains the address of a function which gets
 114          called to get the address of a so far unresolved function and
 115          jump to it.  The profiling extension of the dynamic linker allows
 116          to intercept the calls to collect information.  In this case we
 117          don't store the address in the GOT so that all future calls also
 118          end in this function.  */
 119       if (__builtin_expect (profile, 0))
 120         {
 121           got[2] = (Elf64_Addr) &_dl_runtime_profile;
 122
 123           if (GLRO(dl_profile) != NULL
 124               && _dl_name_match_p (GLRO(dl_profile), l))
 125             /* This is the object we are looking for.  Say that we really
 126                want profiling and the timers are started.  */
 127             GL(dl_profile_map) = l;
 128         }
 129       else
 130         /* This function will get called to fix up the GOT entry indicated by
 131            the offset on the stack, and then jump to the resolved address.  */
 132         got[2] = (Elf64_Addr) &_dl_runtime_resolve;
 133     }
 134
 135   if (l->l_info[ADDRIDX (DT_TLSDESC_GOT)] && lazy)
 136     *(Elf64_Addr*)(D_PTR (l, l_info[ADDRIDX (DT_TLSDESC_GOT)]) + l->l_addr)
 137       = (Elf64_Addr) &_dl_tlsdesc_resolve_rela;
 138
 139   return lazy;
 140 }
 141
 142 /* Initial entry point code for the dynamic linker.
 143    The C function `_dl_start' is the real entry point;
 144    its return value is the user program's entry point.  */
 145 #define RTLD_START asm ("\n\
 146 .text\n\
 147         .align 16\n\
 148 .globl _start\n\
 149 .globl _dl_start_user\n\
 150 _start:\n\
 151         movq %rsp, %rdi\n\
 152         call _dl_start\n\
 153 _dl_start_user:\n\
 154         # Save the user entry point address in %r12.\n\
 155         movq %rax, %r12\n\
 156         # See if we were run as a command with the executable file\n\
 157         # name as an extra leading argument.\n\
 158         movl _dl_skip_args(%rip), %eax\n\
 159         # Pop the original argument count.\n\
 160         popq %rdx\n\
 161         # Adjust the stack pointer to skip _dl_skip_args words.\n\
 162         leaq (%rsp,%rax,8), %rsp\n\
 163         # Subtract _dl_skip_args from argc.\n\
 164         subl %eax, %edx\n\
 165         # Push argc back on the stack.\n\
 166         pushq %rdx\n\
 167         # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env)\n\
 168         # argc -> rsi\n\
 169         movq %rdx, %rsi\n\
 170         # Save %rsp value in %r13.\n\
 171         movq %rsp, %r13\n\
 172         # And align stack for the _dl_init_internal call. \n\
 173         andq $-16, %rsp\n\
 174         # _dl_loaded -> rdi\n\
 175         movq _rtld_local(%rip), %rdi\n\
 176         # env -> rcx\n\
 177         leaq 16(%r13,%rdx,8), %rcx\n\
 178         # argv -> rdx\n\
 179         leaq 8(%r13), %rdx\n\
 180         # Clear %rbp to mark outermost frame obviously even for constructors.\n\
 181         xorl %ebp, %ebp\n\
 182         # Call the function to run the initializers.\n\
 183         call _dl_init_internal@PLT\n\
 184         # Pass our finalizer function to the user in %rdx, as per ELF ABI.\n\
 185         leaq _dl_fini(%rip), %rdx\n\
 186         # And make sure %rsp points to argc stored on the stack.\n\
 187         movq %r13, %rsp\n\
 188         # Jump to the user's entry point.\n\
 189         jmp *%r12\n\
 190 .previous\n\
 191 ");
 192
 193 /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry or
 194    TLS variable, so undefined references should not be allowed to
 195    define the value.
 196    ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to one
 197    of the main executable's symbols, as for a COPY reloc.  */
 198 #if !defined RTLD_BOOTSTRAP || USE___THREAD
 199 # define elf_machine_type_class(type)                                         \
 200   ((((type) == R_X86_64_JUMP_SLOT                                             \
 201      || (type) == R_X86_64_DTPMOD64                                           \
 202      || (type) == R_X86_64_DTPOFF64                                           \
 203      || (type) == R_X86_64_TPOFF64                                            \
 204      || (type) == R_X86_64_TLSDESC)                                           \
 205     * ELF_RTYPE_CLASS_PLT)                                                    \
 206    | (((type) == R_X86_64_COPY) * ELF_RTYPE_CLASS_COPY))
 207 #else
 208 # define elf_machine_type_class(type) \
 209   ((((type) == R_X86_64_JUMP_SLOT) * ELF_RTYPE_CLASS_PLT) \
 210    | (((type) == R_X86_64_COPY) * ELF_RTYPE_CLASS_COPY))
 211 #endif
 212
 213 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
 214 #define ELF_MACHINE_JMP_SLOT    R_X86_64_JUMP_SLOT
 215
 216 /* The x86-64 never uses Elf64_Rel relocations.  */
 217 #define ELF_MACHINE_NO_REL 1
 218
 219 /* We define an initialization functions.  This is called very early in
 220    _dl_sysdep_start.  */
 221 #define DL_PLATFORM_INIT dl_platform_init ()
 222
 223 static inline void __attribute__ ((unused))
 224 dl_platform_init (void)
 225 {
 226   if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
 227     /* Avoid an empty string which would disturb us.  */
 228     GLRO(dl_platform) = NULL;
 229 }
 230
 231 static inline Elf64_Addr
 232 elf_machine_fixup_plt (struct link_map *map, lookup_t t,
 233                        const Elf64_Rela *reloc,
 234                        Elf64_Addr *reloc_addr, Elf64_Addr value)
 235 {
 236   return *reloc_addr = value;
 237 }
 238
 239 /* Return the final value of a plt relocation.  On x86-64 the
 240    JUMP_SLOT relocation ignores the addend. */
 241 static inline Elf64_Addr
 242 elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
 243                        Elf64_Addr value)
 244 {
 245   return value;
 246 }
 247
 248
 249 /* Names of the architecture-specific auditing callback functions.  */
 250 #define ARCH_LA_PLTENTER x86_64_gnu_pltenter
 251 #define ARCH_LA_PLTEXIT x86_64_gnu_pltexit
 252
 253 #endif /* !dl_machine_h */
 254
 255 #ifdef RESOLVE_MAP
 256
 257 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 258    MAP is the object containing the reloc.  */
 259
 260 auto inline void
 261 __attribute__ ((always_inline))
 262 elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
 263                   const Elf64_Sym *sym, const struct r_found_version *version,
 264                   void *const reloc_addr_arg)
 265 {
 266   Elf64_Addr *const reloc_addr = reloc_addr_arg;
 267   const unsigned long int r_type = ELF64_R_TYPE (reloc->r_info);
 268
 269 # if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
 270   if (__builtin_expect (r_type == R_X86_64_RELATIVE, 0))
 271     {
 272 #  if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
 273       /* This is defined in rtld.c, but nowhere in the static libc.a;
 274          make the reference weak so static programs can still link.
 275          This declaration cannot be done when compiling rtld.c
 276          (i.e. #ifdef RTLD_BOOTSTRAP) because rtld.c contains the
 277          common defn for _dl_rtld_map, which is incompatible with a
 278          weak decl in the same file.  */
 279 #   ifndef SHARED
 280       weak_extern (GL(dl_rtld_map));
 281 #   endif
 282       if (map != &GL(dl_rtld_map)) /* Already done in rtld itself.  */
 283 #  endif
 284         *reloc_addr = map->l_addr + reloc->r_addend;
 285     }
 286   else
 287 # endif
 288   if (__builtin_expect (r_type == R_X86_64_NONE, 0))
 289     return;
 290   else
 291     {
 292 # ifndef RTLD_BOOTSTRAP
 293       const Elf64_Sym *const refsym = sym;
 294 # endif
 295       struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
 296       Elf64_Addr value = (sym == NULL ? 0
 297                           : (Elf64_Addr) sym_map->l_addr + sym->st_value);
 298
 299       if (sym != NULL
 300           && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC,
 301                                0)
 302           && __builtin_expect (sym->st_shndx != SHN_UNDEF, 1))
 303         value = ((Elf64_Addr (*) (void)) value) ();
 304
 305 # if defined RTLD_BOOTSTRAP && !USE___THREAD
 306       assert (r_type == R_X86_64_GLOB_DAT || r_type == R_X86_64_JUMP_SLOT);
 307       *reloc_addr = value + reloc->r_addend;
 308 # else
 309       switch (r_type)
 310         {
 311         case R_X86_64_GLOB_DAT:
 312         case R_X86_64_JUMP_SLOT:
 313           *reloc_addr = value + reloc->r_addend;
 314           break;
 315
 316 # ifndef RESOLVE_CONFLICT_FIND_MAP
 317         case R_X86_64_DTPMOD64:
 318 #  ifdef RTLD_BOOTSTRAP
 319           /* During startup the dynamic linker is always the module
 320              with index 1.
 321              XXX If this relocation is necessary move before RESOLVE
 322              call.  */
 323           *reloc_addr = 1;
 324 #  else
 325           /* Get the information from the link map returned by the
 326              resolve function.  */
 327           if (sym_map != NULL)
 328             *reloc_addr = sym_map->l_tls_modid;
 329 #  endif
 330           break;
 331         case R_X86_64_DTPOFF64:
 332 #  ifndef RTLD_BOOTSTRAP
 333           /* During relocation all TLS symbols are defined and used.
 334              Therefore the offset is already correct.  */
 335           if (sym != NULL)
 336             *reloc_addr = sym->st_value + reloc->r_addend;
 337 #  endif
 338           break;
 339         case R_X86_64_TLSDESC:
 340           {
 341             struct tlsdesc volatile *td =
 342               (struct tlsdesc volatile *)reloc_addr;
 343
 344 #  ifndef RTLD_BOOTSTRAP
 345             if (! sym)
 346               {
 347                 td->arg = (void*)reloc->r_addend;
 348                 td->entry = _dl_tlsdesc_undefweak;
 349               }
 350             else
 351 #  endif
 352               {
 353 #  ifndef RTLD_BOOTSTRAP
 354 #   ifndef SHARED
 355                 CHECK_STATIC_TLS (map, sym_map);
 356 #   else
 357                 if (!TRY_STATIC_TLS (map, sym_map))
 358                   {
 359                     td->arg = _dl_make_tlsdesc_dynamic
 360                       (sym_map, sym->st_value + reloc->r_addend);
 361                     td->entry = _dl_tlsdesc_dynamic;
 362                   }
 363                 else
 364 #   endif
 365 #  endif
 366                   {
 367                     td->arg = (void*)(sym->st_value - sym_map->l_tls_offset
 368                                       + reloc->r_addend);
 369                     td->entry = _dl_tlsdesc_return;
 370                   }
 371               }
 372             break;
 373           }
 374         case R_X86_64_TPOFF64:
 375           /* The offset is negative, forward from the thread pointer.  */
 376 #  ifndef RTLD_BOOTSTRAP
 377           if (sym != NULL)
 378 #  endif
 379             {
 380 #  ifndef RTLD_BOOTSTRAP
 381               CHECK_STATIC_TLS (map, sym_map);
 382 #  endif
 383               /* We know the offset of the object the symbol is contained in.
 384                  It is a negative value which will be added to the
 385                  thread pointer.  */
 386               *reloc_addr = (sym->st_value + reloc->r_addend
 387                              - sym_map->l_tls_offset);
 388             }
 389           break;
 390 # endif
 391
 392 # ifndef RTLD_BOOTSTRAP
 393         case R_X86_64_64:
 394           *reloc_addr = value + reloc->r_addend;
 395           break;
 396         case R_X86_64_32:
 397           value += reloc->r_addend;
 398           *(unsigned int *) reloc_addr = value;
 399
 400           const char *fmt;
 401           if (__builtin_expect (value > UINT_MAX, 0))
 402             {
 403               const char *strtab;
 404
 405               fmt = "\
 406 %s: Symbol `%s' causes overflow in R_X86_64_32 relocation\n";
 407 #  ifndef RESOLVE_CONFLICT_FIND_MAP
 408             print_err:
 409 #  endif
 410               strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]);
 411
 412               _dl_error_printf (fmt,
 413                                 rtld_progname ?: "<program name unknown>",
 414                                 strtab + refsym->st_name);
 415             }
 416           break;
 417 #  ifndef RESOLVE_CONFLICT_FIND_MAP
 418           /* Not needed for dl-conflict.c.  */
 419         case R_X86_64_PC32:
 420           value += reloc->r_addend - (Elf64_Addr) reloc_addr;
 421           *(unsigned int *) reloc_addr = value;
 422           if (__builtin_expect (value != (int) value, 0))
 423             {
 424               fmt = "\
 425 %s: Symbol `%s' causes overflow in R_X86_64_PC32 relocation\n";
 426               goto print_err;
 427             }
 428           break;
 429         case R_X86_64_COPY:
 430           if (sym == NULL)
 431             /* This can happen in trace mode if an object could not be
 432                found.  */
 433             break;
 434           memcpy (reloc_addr_arg, (void *) value,
 435                   MIN (sym->st_size, refsym->st_size));
 436           if (__builtin_expect (sym->st_size > refsym->st_size, 0)
 437               || (__builtin_expect (sym->st_size < refsym->st_size, 0)
 438                   && GLRO(dl_verbose)))
 439             {
 440               fmt = "\
 441 %s: Symbol `%s' has different size in shared object, consider re-linking\n";
 442               goto print_err;
 443             }
 444           break;
 445 #  endif
 446         case R_X86_64_IRELATIVE:
 447           value = map->l_addr + reloc->r_addend;
 448           value = ((Elf64_Addr (*) (void)) value) ();
 449           *reloc_addr = value;
 450           break;
 451         default:
 452           _dl_reloc_bad_type (map, r_type, 0);
 453           break;
 454 # endif
 455         }
 456 #endif
 457     }
 458 }
 459
 460 auto inline void
 461 __attribute ((always_inline))
 462 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
 463                            void *const reloc_addr_arg)
 464 {
 465   Elf64_Addr *const reloc_addr = reloc_addr_arg;
 466   assert (ELF64_R_TYPE (reloc->r_info) == R_X86_64_RELATIVE);
 467   *reloc_addr = l_addr + reloc->r_addend;
 468 }
 469
 470 auto inline void
 471 __attribute ((always_inline))
 472 elf_machine_lazy_rel (struct link_map *map,
 473                       Elf64_Addr l_addr, const Elf64_Rela *reloc)
 474 {
 475   Elf64_Addr *const reloc_addr = (void *) (l_addr + reloc->r_offset);
 476   const unsigned long int r_type = ELF64_R_TYPE (reloc->r_info);
 477
 478   /* Check for unexpected PLT reloc type.  */
 479   if (__builtin_expect (r_type == R_X86_64_JUMP_SLOT, 1))
 480     {
 481       if (__builtin_expect (map->l_mach.plt, 0) == 0)
 482         *reloc_addr += l_addr;
 483       else
 484         *reloc_addr =
 485           map->l_mach.plt
 486           + (((Elf64_Addr) reloc_addr) - map->l_mach.gotplt) * 2;
 487     }
 488   else if (__builtin_expect (r_type == R_X86_64_TLSDESC, 1))
 489     {
 490       struct tlsdesc volatile * __attribute__((__unused__)) td =
 491         (struct tlsdesc volatile *)reloc_addr;
 492
 493       td->arg = (void*)reloc;
 494       td->entry = (void*)(D_PTR (map, l_info[ADDRIDX (DT_TLSDESC_PLT)])
 495                           + map->l_addr);
 496     }
 497   else if (__builtin_expect (r_type == R_X86_64_IRELATIVE, 0))
 498     {
 499       Elf64_Addr value = map->l_addr + reloc->r_addend;
 500       value = ((Elf64_Addr (*) (void)) value) ();
 501       *reloc_addr = value;
 502     }
 503   else
 504     _dl_reloc_bad_type (map, r_type, 1);
 505 }
 506
 507 #endif /* RESOLVE_MAP */