sysdeps/sparc/sparc64/dl-machine.h

   1 /* Machine-dependent ELF dynamic relocation inline functions.  Sparc64 version.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2001 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 Library General Public License as
   7    published by the Free Software Foundation; either version 2 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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If
  17    not, write to the Free Software Foundation, Inc.,
  18    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #define ELF_MACHINE_NAME "sparc64"
  21
  22 #include <string.h>
  23 #include <sys/param.h>
  24 #include <ldsodefs.h>
  25 #include <sysdep.h>
  26
  27 #define ELF64_R_TYPE_ID(info)   ((info) & 0xff)
  28 #define ELF64_R_TYPE_DATA(info) ((info) >> 8)
  29
  30 /* Return nonzero iff ELF header is compatible with the running host.  */
  31 static inline int
  32 elf_machine_matches_host (const Elf64_Ehdr *ehdr)
  33 {
  34   return ehdr->e_machine == EM_SPARCV9;
  35 }
  36
  37 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
  38    first element of the GOT.  This must be inlined in a function which
  39    uses global data.  */
  40 static inline Elf64_Addr
  41 elf_machine_dynamic (void)
  42 {
  43   register Elf64_Addr *elf_pic_register __asm__("%l7");
  44
  45   return *elf_pic_register;
  46 }
  47
  48 /* Return the run-time load address of the shared object.  */
  49 static inline Elf64_Addr
  50 elf_machine_load_address (void)
  51 {
  52   register Elf64_Addr *elf_pic_register __asm__("%l7");
  53
  54   /* We used to utilize the fact that a local .got entry will
  55      be partially initialized at startup awaiting its RELATIVE
  56      fixup:
  57
  58      Elf64_Addr pc, la;
  59
  60      __asm("sethi %%hi(.Load_address), %1\n"
  61            ".Load_address:\n\t"
  62            "rd %%pc, %0\n\t"
  63            "or %1, %%lo(.Load_address), %1\n\t"
  64            : "=r"(pc), "=r"(la));
  65
  66      return pc - *(Elf64_Addr *)(elf_pic_register + la);
  67
  68      Unfortunately as binutils tries to work around Solaris
  69      dynamic linker bug which resolves R_SPARC_RELATIVE as X += B + A
  70      instead of X = B + A this does not work any longer, since ld
  71      clears it.
  72
  73      The following method relies on the fact that sparcv9 ABI maximal
  74      page length is 1MB and all ELF segments on sparc64 are aligned
  75      to 1MB.  Also, it relies on _DYNAMIC coming after _GLOBAL_OFFSET_TABLE_
  76      and assumes that they both fit into the first 1MB of the RW segment.
  77      This should be true for some time unless ld.so grows too much, at the
  78      moment the whole stripped ld.so is 128KB and only smaller part of that
  79      is in the RW segment.  */
  80
  81   return ((Elf64_Addr)elf_pic_register - *elf_pic_register + 0xfffff)
  82          & ~0xfffffUL;
  83 }
  84
  85 /* We have 4 cases to handle.  And we code different code sequences
  86    for each one.  I love V9 code models...  */
  87 static inline Elf64_Addr
  88 elf_machine_fixup_plt (struct link_map *map, lookup_t t,
  89                        const Elf64_Rela *reloc,
  90                        Elf64_Addr *reloc_addr, Elf64_Addr value)
  91 {
  92   unsigned int *insns = (unsigned int *) reloc_addr;
  93   Elf64_Addr plt_vaddr = (Elf64_Addr) reloc_addr;
  94
  95   /* Now move plt_vaddr up to the call instruction.  */
  96   plt_vaddr += (2 * 4);
  97
  98   /* PLT entries .PLT32768 and above look always the same.  */
  99   if (__builtin_expect (reloc->r_addend, 0) != 0)
 100     {
 101       *reloc_addr = value - map->l_addr;
 102     }
 103   /* 32-bit Sparc style, the target is in the lower 32-bits of
 104      address space.  */
 105   else if ((value >> 32) == 0)
 106     {
 107       /* sethi  %hi(target), %g1
 108          jmpl   %g1 + %lo(target), %g0  */
 109
 110       insns[2] = 0x81c06000 | (value & 0x3ff);
 111       __asm __volatile ("flush %0 + 8" : : "r" (insns));
 112
 113       insns[1] = 0x03000000 | ((unsigned int)(value >> 10));
 114       __asm __volatile ("flush %0 + 4" : : "r" (insns));
 115     }
 116   /* We can also get somewhat simple sequences if the distance between
 117      the target and the PLT entry is within +/- 2GB.  */
 118   else if ((plt_vaddr > value
 119             && ((plt_vaddr - value) >> 32) == 0)
 120            || (value > plt_vaddr
 121                && ((value - plt_vaddr) >> 32) == 0))
 122     {
 123       unsigned int displacement;
 124
 125       if (plt_vaddr > value)
 126         displacement = (0 - (plt_vaddr - value));
 127       else
 128         displacement = value - plt_vaddr;
 129
 130       /* mov    %o7, %g1
 131          call   displacement
 132           mov   %g1, %o7  */
 133
 134       insns[3] = 0x9e100001;
 135       __asm __volatile ("flush %0 + 12" : : "r" (insns));
 136
 137       insns[2] = 0x40000000 | (displacement >> 2);
 138       __asm __volatile ("flush %0 + 8" : : "r" (insns));
 139
 140       insns[1] = 0x8210000f;
 141       __asm __volatile ("flush %0 + 4" : : "r" (insns));
 142     }
 143   /* Worst case, ho hum...  */
 144   else
 145     {
 146       unsigned int high32 = (value >> 32);
 147       unsigned int low32 = (unsigned int) value;
 148
 149       /* ??? Some tricks can be stolen from the sparc64 egcs backend
 150              constant formation code I wrote.  -DaveM  */
 151
 152       /* sethi  %hh(value), %g1
 153          sethi  %lm(value), %g5
 154          or     %g1, %hm(value), %g1
 155          or     %g5, %lo(value), %g5
 156          sllx   %g1, 32, %g1
 157          jmpl   %g1 + %g5, %g0
 158           nop  */
 159
 160       insns[6] = 0x81c04005;
 161       __asm __volatile ("flush %0 + 24" : : "r" (insns));
 162
 163       insns[5] = 0x83287020;
 164       __asm __volatile ("flush %0 + 20" : : "r" (insns));
 165
 166       insns[4] = 0x8a116000 | (low32 & 0x3ff);
 167       __asm __volatile ("flush %0 + 16" : : "r" (insns));
 168
 169       insns[3] = 0x82106000 | (high32 & 0x3ff);
 170       __asm __volatile ("flush %0 + 12" : : "r" (insns));
 171
 172       insns[2] = 0x0b000000 | (low32 >> 10);
 173       __asm __volatile ("flush %0 + 8" : : "r" (insns));
 174
 175       insns[1] = 0x03000000 | (high32 >> 10);
 176       __asm __volatile ("flush %0 + 4" : : "r" (insns));
 177     }
 178
 179   return value;
 180 }
 181
 182 /* Return the final value of a plt relocation.  */
 183 static inline Elf64_Addr
 184 elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
 185                        Elf64_Addr value)
 186 {
 187   return value + reloc->r_addend;
 188 }
 189
 190 #ifdef RESOLVE
 191
 192 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 193    MAP is the object containing the reloc.  */
 194
 195 static inline void
 196 elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
 197                   const Elf64_Sym *sym, const struct r_found_version *version,
 198                   Elf64_Addr *const reloc_addr)
 199 {
 200 #ifndef RTLD_BOOTSTRAP
 201   /* This is defined in rtld.c, but nowhere in the static libc.a; make the
 202      reference weak so static programs can still link.  This declaration
 203      cannot be done when compiling rtld.c (i.e.  #ifdef RTLD_BOOTSTRAP)
 204      because rtld.c contains the common defn for _dl_rtld_map, which is
 205      incompatible with a weak decl in the same file.  */
 206   weak_extern (_dl_rtld_map);
 207 #endif
 208
 209   if (ELF64_R_TYPE_ID (reloc->r_info) == R_SPARC_RELATIVE)
 210     {
 211 #ifndef RTLD_BOOTSTRAP
 212       if (map != &_dl_rtld_map) /* Already done in rtld itself. */
 213 #endif
 214         *reloc_addr = map->l_addr + reloc->r_addend;
 215     }
 216   else if (ELF64_R_TYPE_ID (reloc->r_info) != R_SPARC_NONE) /* Who is Wilbur? */
 217     {
 218 #ifndef RTLD_BOOTSTRAP
 219       const Elf64_Sym *const refsym = sym;
 220 #endif
 221       Elf64_Addr value;
 222       if (sym->st_shndx != SHN_UNDEF &&
 223           ELF64_ST_BIND (sym->st_info) == STB_LOCAL)
 224         value = map->l_addr;
 225       else
 226         {
 227           value = RESOLVE (&sym, version, ELF64_R_TYPE_ID (reloc->r_info));
 228           if (sym)
 229             value += sym->st_value;
 230         }
 231       value += reloc->r_addend; /* Assume copy relocs have zero addend.  */
 232
 233       switch (ELF64_R_TYPE_ID (reloc->r_info))
 234         {
 235 #ifndef RTLD_BOOTSTRAP
 236         case R_SPARC_COPY:
 237           if (sym == NULL)
 238             /* This can happen in trace mode if an object could not be
 239                found.  */
 240             break;
 241           if (sym->st_size > refsym->st_size
 242               || (_dl_verbose && sym->st_size < refsym->st_size))
 243             {
 244               extern char **_dl_argv;
 245               const char *strtab;
 246
 247               strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
 248               _dl_error_printf ("\
 249 %s: Symbol `%s' has different size in shared object, consider re-linking\n",
 250                                 _dl_argv[0] ?: "<program name unknown>",
 251                                 strtab + refsym->st_name);
 252             }
 253           memcpy (reloc_addr, (void *) value, MIN (sym->st_size,
 254                                                    refsym->st_size));
 255           break;
 256 #endif
 257         case R_SPARC_64:
 258         case R_SPARC_GLOB_DAT:
 259           *reloc_addr = value;
 260           break;
 261 #ifndef RTLD_BOOTSTRAP
 262         case R_SPARC_8:
 263           *(char *) reloc_addr = value;
 264           break;
 265         case R_SPARC_16:
 266           *(short *) reloc_addr = value;
 267           break;
 268         case R_SPARC_32:
 269           *(unsigned int *) reloc_addr = value;
 270           break;
 271         case R_SPARC_DISP8:
 272           *(char *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 273           break;
 274         case R_SPARC_DISP16:
 275           *(short *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 276           break;
 277         case R_SPARC_DISP32:
 278           *(unsigned int *) reloc_addr = (value - (Elf64_Addr) reloc_addr);
 279           break;
 280         case R_SPARC_WDISP30:
 281           *(unsigned int *) reloc_addr =
 282             ((*(unsigned int *)reloc_addr & 0xc0000000) |
 283              ((value - (Elf64_Addr) reloc_addr) >> 2));
 284           break;
 285
 286         /* MEDLOW code model relocs */
 287         case R_SPARC_LO10:
 288           *(unsigned int *) reloc_addr =
 289             ((*(unsigned int *)reloc_addr & ~0x3ff) |
 290              (value & 0x3ff));
 291           break;
 292         case R_SPARC_HI22:
 293           *(unsigned int *) reloc_addr =
 294             ((*(unsigned int *)reloc_addr & 0xffc00000) |
 295              (value >> 10));
 296           break;
 297         case R_SPARC_OLO10:
 298           *(unsigned int *) reloc_addr =
 299             ((*(unsigned int *)reloc_addr & ~0x1fff) |
 300              (((value & 0x3ff) + ELF64_R_TYPE_DATA (reloc->r_info)) & 0x1fff));
 301           break;
 302
 303         /* MEDMID code model relocs */
 304         case R_SPARC_H44:
 305           *(unsigned int *) reloc_addr =
 306             ((*(unsigned int *)reloc_addr & 0xffc00000) |
 307              (value >> 22));
 308           break;
 309         case R_SPARC_M44:
 310           *(unsigned int *) reloc_addr =
 311             ((*(unsigned int *)reloc_addr & ~0x3ff) |
 312              ((value >> 12) & 0x3ff));
 313           break;
 314         case R_SPARC_L44:
 315           *(unsigned int *) reloc_addr =
 316             ((*(unsigned int *)reloc_addr & ~0xfff) |
 317              (value & 0xfff));
 318           break;
 319
 320         /* MEDANY code model relocs */
 321         case R_SPARC_HH22:
 322           *(unsigned int *) reloc_addr =
 323             ((*(unsigned int *)reloc_addr & 0xffc00000) |
 324              (value >> 42));
 325           break;
 326         case R_SPARC_HM10:
 327           *(unsigned int *) reloc_addr =
 328             ((*(unsigned int *)reloc_addr & ~0x3ff) |
 329              ((value >> 32) & 0x3ff));
 330           break;
 331         case R_SPARC_LM22:
 332           *(unsigned int *) reloc_addr =
 333             ((*(unsigned int *)reloc_addr & 0xffc00000) |
 334              ((value >> 10) & 0x003fffff));
 335           break;
 336 #endif
 337         case R_SPARC_JMP_SLOT:
 338           elf_machine_fixup_plt(map, 0, reloc, reloc_addr, value);
 339           break;
 340 #ifndef RTLD_BOOTSTRAP
 341         case R_SPARC_UA64:
 342           if (! ((long) reloc_addr & 3))
 343             {
 344               /* Common in .eh_frame */
 345               ((unsigned int *) reloc_addr) [0] = value >> 32;
 346               ((unsigned int *) reloc_addr) [1] = value;
 347               break;
 348             }
 349           ((unsigned char *) reloc_addr) [0] = value >> 56;
 350           ((unsigned char *) reloc_addr) [1] = value >> 48;
 351           ((unsigned char *) reloc_addr) [2] = value >> 40;
 352           ((unsigned char *) reloc_addr) [3] = value >> 32;
 353           ((unsigned char *) reloc_addr) [4] = value >> 24;
 354           ((unsigned char *) reloc_addr) [5] = value >> 16;
 355           ((unsigned char *) reloc_addr) [6] = value >> 8;
 356           ((unsigned char *) reloc_addr) [7] = value;
 357           break;
 358 #endif
 359 #if !defined RTLD_BOOTSTRAP || defined _NDEBUG
 360         default:
 361           _dl_reloc_bad_type (map, ELFW(R_TYPE) (reloc->r_info), 0);
 362           break;
 363 #endif
 364         }
 365     }
 366 }
 367
 368 static inline void
 369 elf_machine_lazy_rel (struct link_map *map,
 370                       Elf64_Addr l_addr, const Elf64_Rela *reloc)
 371 {
 372   switch (ELF64_R_TYPE (reloc->r_info))
 373     {
 374     case R_SPARC_NONE:
 375       break;
 376     case R_SPARC_JMP_SLOT:
 377       break;
 378     default:
 379       _dl_reloc_bad_type (map, ELFW(R_TYPE) (reloc->r_info), 1);
 380       break;
 381     }
 382 }
 383
 384 #endif  /* RESOLVE */
 385
 386 /* Nonzero iff TYPE should not be allowed to resolve to one of
 387    the main executable's symbols, as for a COPY reloc.  */
 388 #define elf_machine_lookup_noexec_p(type) ((type) == R_SPARC_COPY)
 389
 390 /* Nonzero iff TYPE describes relocation of a PLT entry, so
 391    PLT entries should not be allowed to define the value.  */
 392 #define elf_machine_lookup_noplt_p(type) ((type) == R_SPARC_JMP_SLOT)
 393
 394 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
 395 #define ELF_MACHINE_JMP_SLOT    R_SPARC_JMP_SLOT
 396
 397 /* The SPARC never uses Elf64_Rel relocations.  */
 398 #define ELF_MACHINE_NO_REL 1
 399
 400 /* The SPARC overlaps DT_RELA and DT_PLTREL.  */
 401 #define ELF_MACHINE_PLTREL_OVERLAP 1
 402
 403 /* Set up the loaded object described by L so its unrelocated PLT
 404    entries will jump to the on-demand fixup code in dl-runtime.c.  */
 405
 406 static inline int
 407 elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
 408 {
 409   if (l->l_info[DT_JMPREL] && lazy)
 410     {
 411       extern void _dl_runtime_resolve_0 (void);
 412       extern void _dl_runtime_resolve_1 (void);
 413       extern void _dl_runtime_profile_0 (void);
 414       extern void _dl_runtime_profile_1 (void);
 415       Elf64_Addr res0_addr, res1_addr;
 416       unsigned int *plt = (void *) D_PTR (l, l_info[DT_PLTGOT]);
 417
 418       if (! profile)
 419         {
 420           res0_addr = (Elf64_Addr) &_dl_runtime_resolve_0;
 421           res1_addr = (Elf64_Addr) &_dl_runtime_resolve_1;
 422         }
 423       else
 424         {
 425           res0_addr = (Elf64_Addr) &_dl_runtime_profile_0;
 426           res1_addr = (Elf64_Addr) &_dl_runtime_profile_1;
 427           if (_dl_name_match_p (_dl_profile, l))
 428             _dl_profile_map = l;
 429         }
 430
 431       /* PLT0 looks like:
 432
 433          save   %sp, -192, %sp
 434          sethi  %hh(_dl_runtime_{resolve,profile}_0), %l0
 435          sethi  %lm(_dl_runtime_{resolve,profile}_0), %l1
 436          or     %l0, %hm(_dl_runtime_{resolve,profile}_0), %l0
 437          or     %l1, %lo(_dl_runtime_{resolve,profile}_0), %l1
 438          sllx   %l0, 32, %l0
 439          jmpl   %l0 + %l1, %l6
 440           sethi %hi(0xffc00), %l2
 441        */
 442
 443       plt[0] = 0x9de3bf40;
 444       plt[1] = 0x21000000 | (res0_addr >> (64 - 22));
 445       plt[2] = 0x23000000 | ((res0_addr >> 10) & 0x003fffff);
 446       plt[3] = 0xa0142000 | ((res0_addr >> 32) & 0x3ff);
 447       plt[4] = 0xa2146000 | (res0_addr & 0x3ff);
 448       plt[5] = 0xa12c3020;
 449       plt[6] = 0xadc40011;
 450       plt[7] = 0x250003ff;
 451
 452       /* PLT1 looks like:
 453
 454          save   %sp, -192, %sp
 455          sethi  %hh(_dl_runtime_{resolve,profile}_1), %l0
 456          sethi  %lm(_dl_runtime_{resolve,profile}_1), %l1
 457          or     %l0, %hm(_dl_runtime_{resolve,profile}_1), %l0
 458          or     %l1, %lo(_dl_runtime_{resolve,profile}_1), %l1
 459          sllx   %l0, 32, %l0
 460          jmpl   %l0 + %l1, %l6
 461           srlx  %g1, 12, %o1
 462        */
 463
 464       plt[8 + 0] = 0x9de3bf40;
 465       plt[8 + 1] = 0x21000000 | (res1_addr >> (64 - 22));
 466       plt[8 + 2] = 0x23000000 | ((res1_addr >> 10) & 0x003fffff);
 467       plt[8 + 3] = 0xa0142000 | ((res1_addr >> 32) & 0x3ff);
 468       plt[8 + 4] = 0xa2146000 | (res1_addr & 0x3ff);
 469       plt[8 + 5] = 0xa12c3020;
 470       plt[8 + 6] = 0xadc40011;
 471       plt[8 + 7] = 0x9330700c;
 472
 473       /* Now put the magic cookie at the beginning of .PLT2
 474          Entry .PLT3 is unused by this implementation.  */
 475       *((struct link_map **)(&plt[16 + 0])) = l;
 476     }
 477
 478   return lazy;
 479 }
 480
 481 /* This code is used in dl-runtime.c to call the `fixup' function
 482    and then redirect to the address it returns.  */
 483 #define TRAMPOLINE_TEMPLATE(tramp_name, fixup_name)     \
 484   asm ("\n"                                             \
 485 "       .text\n"                                        \
 486 "       .globl  " #tramp_name "_0\n"                    \
 487 "       .type   " #tramp_name "_0, @function\n"         \
 488 "       .align  32\n"                                   \
 489 "\t" #tramp_name "_0:\n"                                \
 490 "       ! sethi   %hi(1047552), %l2 - Done in .PLT0\n"  \
 491 "       ldx     [%l6 + 32 + 8], %o0\n"                  \
 492 "       sub     %g1, %l6, %l0\n"                        \
 493 "       xor     %l2, -1016, %l2\n"                      \
 494 "       sethi   %hi(5120), %l3  ! 160 * 32\n"           \
 495 "       add     %l0, %l2, %l0\n"                        \
 496 "       sethi   %hi(32768), %l4\n"                      \
 497 "       udivx   %l0, %l3, %l3\n"                        \
 498 "       sllx    %l3, 2, %l1\n"                          \
 499 "       add     %l1, %l3, %l1\n"                        \
 500 "       sllx    %l1, 10, %l2\n"                         \
 501 "       sub     %l4, 4, %l4     ! No thanks to Sun for not obeying their own ABI\n" \
 502 "       sllx    %l1, 5, %l1\n"                          \
 503 "       sub     %l0, %l2, %l0\n"                        \
 504 "       udivx   %l0, 24, %l0\n"                         \
 505 "       add     %l0, %l4, %l0\n"                        \
 506 "       add     %l1, %l0, %l1\n"                        \
 507 "       add     %l1, %l1, %l0\n"                        \
 508 "       add     %l0, %l1, %l0\n"                        \
 509 "       mov     %i7, %o2\n"                             \
 510 "       call    " #fixup_name "\n"                      \
 511 "        sllx    %l0, 3, %o1\n"                         \
 512 "       jmp     %o0\n"                                  \
 513 "        restore\n"                                     \
 514 "       .size   " #tramp_name "_0, . - " #tramp_name "_0\n" \
 515 "\n"                                                    \
 516 "       .globl  " #tramp_name "_1\n"                    \
 517 "       .type   " #tramp_name "_1, @function\n"         \
 518 "       .align  32\n"                                   \
 519 "\t" #tramp_name "_1:\n"                                \
 520 "       ! srlx  %g1, 12, %o1 - Done in .PLT1\n"         \
 521 "       ldx     [%l6 + 8], %o0\n"                       \
 522 "       add     %o1, %o1, %o3\n"                        \
 523 "       sub     %o1, 96, %o1    ! No thanks to Sun for not obeying their own ABI\n" \
 524 "       mov     %i7, %o2\n"                             \
 525 "       call    " #fixup_name "\n"                      \
 526 "        add    %o1, %o3, %o1\n"                        \
 527 "       jmp     %o0\n"                                  \
 528 "        restore\n"                                     \
 529 "       .size   " #tramp_name "_1, . - " #tramp_name "_1\n" \
 530 "       .previous\n");
 531
 532 #ifndef PROF
 533 #define ELF_MACHINE_RUNTIME_TRAMPOLINE                  \
 534   TRAMPOLINE_TEMPLATE (_dl_runtime_resolve, fixup);     \
 535   TRAMPOLINE_TEMPLATE (_dl_runtime_profile, profile_fixup);
 536 #else
 537 #define ELF_MACHINE_RUNTIME_TRAMPOLINE                  \
 538   TRAMPOLINE_TEMPLATE (_dl_runtime_resolve, fixup);     \
 539   TRAMPOLINE_TEMPLATE (_dl_runtime_profile, fixup);
 540 #endif
 541
 542 /* The PLT uses Elf64_Rela relocs.  */
 543 #define elf_machine_relplt elf_machine_rela
 544
 545 /* Initial entry point code for the dynamic linker.
 546    The C function `_dl_start' is the real entry point;
 547    its return value is the user program's entry point.  */
 548
 549 #define __S1(x) #x
 550 #define __S(x)  __S1(x)
 551
 552 #define RTLD_START __asm__ ( "\n"                                       \
 553 "       .text\n"                                                        \
 554 "       .global _start\n"                                               \
 555 "       .type   _start, @function\n"                                    \
 556 "       .align  32\n"                                                   \
 557 "_start:\n"                                                             \
 558 "   /* Make room for functions to drop their arguments on the stack.  */\n" \
 559 "       sub     %sp, 6*8, %sp\n"                                        \
 560 "   /* Pass pointer to argument block to _dl_start.  */\n"              \
 561 "       call    _dl_start\n"                                            \
 562 "        add     %sp," __S(STACK_BIAS) "+22*8,%o0\n"                    \
 563 "       /* FALLTHRU */\n"                                               \
 564 "       .size _start, .-_start\n"                                       \
 565 "\n"                                                                    \
 566 "       .global _dl_start_user\n"                                       \
 567 "       .type   _dl_start_user, @function\n"                            \
 568 "_dl_start_user:\n"                                                     \
 569 "   /* Load the GOT register.  */\n"                                    \
 570 "1:     call    11f\n"                                                  \
 571 "        sethi  %hi(_GLOBAL_OFFSET_TABLE_-(1b-.)), %l7\n"               \
 572 "11:    or      %l7, %lo(_GLOBAL_OFFSET_TABLE_-(1b-.)), %l7\n"          \
 573 "  /* Store the highest stack address.  */\n"                           \
 574 "       sethi   %hi(__libc_stack_end), %g5\n"                           \
 575 "       add     %l7, %o7, %l7\n"                                        \
 576 "       or      %g5, %lo(__libc_stack_end), %g5\n"                      \
 577 "   /* Save the user entry point address in %l0.  */\n"                 \
 578 "       mov     %o0, %l0\n"                                             \
 579 "       ldx     [%l7 + %g5], %l1\n"                                     \
 580 "       sethi   %hi(_dl_skip_args), %g5\n"                              \
 581 "       add     %sp, 6*8, %l2\n"                                        \
 582 "   /* See if we were run as a command with the executable file name as an\n" \
 583 "      extra leading argument.  If so, we must shift things around since we\n" \
 584 "      must keep the stack doubleword aligned.  */\n"                   \
 585 "       or      %g5, %lo(_dl_skip_args), %g5\n"                         \
 586 "       stx     %l2, [%l1]\n"                                           \
 587 "       ldx     [%l7 + %g5], %i0\n"                                     \
 588 "       ld      [%i0], %i0\n"                                           \
 589 "       brz,pt  %i0, 2f\n"                                              \
 590 "        ldx    [%sp + " __S(STACK_BIAS) " + 22*8], %i5\n"              \
 591 "       /* Find out how far to shift.  */\n"                            \
 592 "       sethi   %hi(_dl_argv), %l4\n"                                   \
 593 "       sub     %i5, %i0, %i5\n"                                        \
 594 "       or      %l4, %lo(_dl_argv), %l4\n"                              \
 595 "       sllx    %i0, 3, %l6\n"                                          \
 596 "       ldx     [%l7 + %l4], %l4\n"                                     \
 597 "       stx     %i5, [%sp + " __S(STACK_BIAS) " + 22*8]\n"              \
 598 "       add     %sp, " __S(STACK_BIAS) " + 23*8, %i1\n"                 \
 599 "       add     %i1, %l6, %i2\n"                                        \
 600 "       ldx     [%l4], %l5\n"                                           \
 601 "       /* Copy down argv.  */\n"                                       \
 602 "12:    ldx     [%i2], %i3\n"                                           \
 603 "       add     %i2, 8, %i2\n"                                          \
 604 "       stx     %i3, [%i1]\n"                                           \
 605 "       brnz,pt %i3, 12b\n"                                             \
 606 "        add    %i1, 8, %i1\n"                                          \
 607 "       sub     %l5, %l6, %l5\n"                                        \
 608 "       /* Copy down envp.  */\n"                                       \
 609 "13:    ldx     [%i2], %i3\n"                                           \
 610 "       add     %i2, 8, %i2\n"                                          \
 611 "       stx     %i3, [%i1]\n"                                           \
 612 "       brnz,pt %i3, 13b\n"                                             \
 613 "        add    %i1, 8, %i1\n"                                          \
 614 "       /* Copy down auxiliary table.  */\n"                            \
 615 "14:    ldx     [%i2], %i3\n"                                           \
 616 "       ldx     [%i2 + 8], %i4\n"                                       \
 617 "       add     %i2, 16, %i2\n"                                         \
 618 "       stx     %i3, [%i1]\n"                                           \
 619 "       stx     %i4, [%i1 + 8]\n"                                       \
 620 "       brnz,pt %i3, 14b\n"                                             \
 621 "        add    %i1, 16, %i1\n"                                         \
 622 "       stx     %l5, [%l4]\n"                                           \
 623 "  /* %o0 = _dl_loaded, %o1 = argc, %o2 = argv, %o3 = envp.  */\n"      \
 624 "2:     sethi   %hi(_dl_loaded), %o0\n"                                 \
 625 "       add     %sp, " __S(STACK_BIAS) " + 23*8, %o2\n"                 \
 626 "       orcc    %o0, %lo(_dl_loaded), %o0\n"                            \
 627 "       sllx    %i5, 3, %o3\n"                                          \
 628 "       ldx     [%l7 + %o0], %o0\n"                                     \
 629 "       add     %o3, 8, %o3\n"                                          \
 630 "       mov     %i5, %o1\n"                                             \
 631 "       add     %o2, %o3, %o3\n"                                        \
 632 "       call    _dl_init\n"                                             \
 633 "        ldx    [%o0], %o0\n"                                           \
 634 "   /* Pass our finalizer function to the user in %g1.  */\n"           \
 635 "       sethi   %hi(_dl_fini), %g1\n"                                   \
 636 "       or      %g1, %lo(_dl_fini), %g1\n"                              \
 637 "       ldx     [%l7 + %g1], %g1\n"                                     \
 638 "  /* Jump to the user's entry point and deallocate the extra stack we got.  */\n" \
 639 "       jmp     %l0\n"                                                  \
 640 "        add    %sp, 6*8, %sp\n"                                        \
 641 "       .size   _dl_start_user, . - _dl_start_user\n"                   \
 642 "       .previous\n");