sysdeps/mips/dl-machine.h

   1 /* Machine-dependent ELF dynamic relocation inline functions.  MIPS version.
   2    Copyright (C) 1996-2001, 2002 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Kazumoto Kojima <kkojima@info.kanagawa-u.ac.jp>.
   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 /*  FIXME: Profiling of shared libraries is not implemented yet.  */
  22 #ifndef dl_machine_h
  23 #define dl_machine_h
  24
  25 #define ELF_MACHINE_NAME "MIPS"
  26
  27 #define ELF_MACHINE_NO_PLT
  28
  29 #include <entry.h>
  30
  31 #ifndef ENTRY_POINT
  32 #error ENTRY_POINT needs to be defined for MIPS.
  33 #endif
  34
  35 /* The offset of gp from GOT might be system-dependent.  It's set by
  36    ld.  The same value is also */
  37 #define OFFSET_GP_GOT 0x7ff0
  38
  39 #ifndef _RTLD_PROLOGUE
  40 # define _RTLD_PROLOGUE(entry)                                          \
  41         ".globl\t" __STRING(entry) "\n\t"                               \
  42         ".ent\t" __STRING(entry) "\n\t"                                 \
  43         ".type\t" __STRING(entry) ", @function\n"                       \
  44         __STRING(entry) ":\n\t"
  45 #endif
  46
  47 #ifndef _RTLD_EPILOGUE
  48 # define _RTLD_EPILOGUE(entry)                                          \
  49         ".end\t" __STRING(entry) "\n\t"                                 \
  50         ".size\t" __STRING(entry) ", . - " __STRING(entry) "\n\t"
  51 #endif
  52
  53 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.
  54    This makes no sense on MIPS but we have to define this to R_MIPS_REL32
  55    to avoid the asserts in dl-lookup.c from blowing.  */
  56 #define ELF_MACHINE_JMP_SLOT                    R_MIPS_REL32
  57 #define elf_machine_type_class(type)            ELF_RTYPE_CLASS_PLT
  58
  59 /* Translate a processor specific dynamic tag to the index
  60    in l_info array.  */
  61 #define DT_MIPS(x) (DT_MIPS_##x - DT_LOPROC + DT_NUM)
  62
  63 /* If there is a DT_MIPS_RLD_MAP entry in the dynamic section, fill it in
  64    with the run-time address of the r_debug structure  */
  65 #define ELF_MACHINE_DEBUG_SETUP(l,r) \
  66 do { if ((l)->l_info[DT_MIPS (RLD_MAP)]) \
  67        *(ElfW(Addr) *)((l)->l_info[DT_MIPS (RLD_MAP)]->d_un.d_ptr) = \
  68        (ElfW(Addr)) (r); \
  69    } while (0)
  70
  71 /* Return nonzero iff ELF header is compatible with the running host.  */
  72 static inline int __attribute_used__
  73 elf_machine_matches_host (const ElfW(Ehdr) *ehdr)
  74 {
  75   switch (ehdr->e_machine)
  76     {
  77     case EM_MIPS:
  78     case EM_MIPS_RS3_LE:
  79       return 1;
  80     default:
  81       return 0;
  82     }
  83 }
  84
  85 static inline ElfW(Addr) *
  86 elf_mips_got_from_gpreg (ElfW(Addr) gpreg)
  87 {
  88   /* FIXME: the offset of gp from GOT may be system-dependent. */
  89   return (ElfW(Addr) *) (gpreg - OFFSET_GP_GOT);
  90 }
  91
  92 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
  93    first element of the GOT.  This must be inlined in a function which
  94    uses global data.  */
  95 static inline ElfW(Addr)
  96 elf_machine_dynamic (void)
  97 {
  98   register ElfW(Addr) gp __asm__ ("$28");
  99   return *elf_mips_got_from_gpreg (gp);
 100 }
 101
 102
 103 /* Return the run-time load address of the shared object.  */
 104 static inline ElfW(Addr)
 105 elf_machine_load_address (void)
 106 {
 107   ElfW(Addr) addr;
 108   asm ("        .set noreorder\n"
 109        "        la %0, here\n"
 110        "        bltzal $0, here\n"
 111        "        nop\n"
 112        "here:   subu %0, $31, %0\n"
 113        "        .set reorder\n"
 114        :        "=r" (addr)
 115        :        /* No inputs */
 116        :        "$31");
 117   return addr;
 118 }
 119
 120 /* The MSB of got[1] of a gnu object is set to identify gnu objects.  */
 121 #define ELF_MIPS_GNU_GOT1_MASK  0x80000000
 122
 123 /* We can't rely on elf_machine_got_rel because _dl_object_relocation_scope
 124    fiddles with global data.  */
 125 #define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info)                     \
 126 do {                                                                    \
 127   struct link_map *map = &bootstrap_map;                                \
 128   ElfW(Sym) *sym;                                                       \
 129   ElfW(Addr) *got;                                                      \
 130   int i, n;                                                             \
 131                                                                         \
 132   got = (ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]);                  \
 133                                                                         \
 134   if (__builtin_expect (map->l_addr == 0, 1))                           \
 135     break;                                                              \
 136                                                                         \
 137   /* got[0] is reserved. got[1] is also reserved for the dynamic object \
 138      generated by gnu ld. Skip these reserved entries from              \
 139      relocation.  */                                                    \
 140   i = (got[1] & ELF_MIPS_GNU_GOT1_MASK)? 2 : 1;                         \
 141   n = map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val;                   \
 142                                                                         \
 143   /* Add the run-time displacement to all local got entries. */         \
 144   while (i < n)                                                         \
 145     got[i++] += map->l_addr;                                            \
 146                                                                         \
 147   /* Handle global got entries. */                                      \
 148   got += n;                                                             \
 149   sym = (ElfW(Sym) *) D_PTR(map, l_info[DT_SYMTAB])                     \
 150        + map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;                     \
 151   i = (map->l_info[DT_MIPS (SYMTABNO)]->d_un.d_val                      \
 152        - map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val);                    \
 153                                                                         \
 154   while (i--)                                                           \
 155     {                                                                   \
 156       if (sym->st_shndx == SHN_UNDEF || sym->st_shndx == SHN_COMMON)    \
 157         *got = map->l_addr + sym->st_value;                             \
 158       else if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC                 \
 159                && *got != sym->st_value)                                \
 160         *got += map->l_addr;                                            \
 161       else if (ELFW(ST_TYPE) (sym->st_info) == STT_SECTION)             \
 162         {                                                               \
 163           if (sym->st_other == 0)                                       \
 164             *got += map->l_addr;                                        \
 165         }                                                               \
 166       else                                                              \
 167         *got = map->l_addr + sym->st_value;                             \
 168                                                                         \
 169       got++;                                                            \
 170       sym++;                                                            \
 171     }                                                                   \
 172 } while(0)
 173
 174
 175 /* Get link map for callers object containing STUB_PC.  */
 176 static inline struct link_map *
 177 elf_machine_runtime_link_map (ElfW(Addr) gpreg, ElfW(Addr) stub_pc)
 178 {
 179   extern int _dl_mips_gnu_objects;
 180
 181   /* got[1] is reserved to keep its link map address for the shared
 182      object generated by the gnu linker.  If all are such objects, we
 183      can find the link map from current GPREG simply.  If not so, get
 184      the link map for caller's object containing STUB_PC.  */
 185
 186   if (_dl_mips_gnu_objects)
 187     {
 188       ElfW(Addr) *got = elf_mips_got_from_gpreg (gpreg);
 189       ElfW(Word) g1;
 190
 191       g1 = ((ElfW(Word) *) got)[1];
 192
 193       if ((g1 & ELF_MIPS_GNU_GOT1_MASK) != 0)
 194         {
 195           struct link_map *l =
 196             (struct link_map *) (g1 & ~ELF_MIPS_GNU_GOT1_MASK);
 197           ElfW(Addr) base, limit;
 198           const ElfW(Phdr) *p = l->l_phdr;
 199           ElfW(Half) this, nent = l->l_phnum;
 200
 201           /* For the common case of a stub being called from the containing
 202              object, STUB_PC will point to somewhere within the object that
 203              is described by the link map fetched via got[1].  Otherwise we
 204              have to scan all maps.  */
 205           for (this = 0; this < nent; this++)
 206             {
 207               if (p[this].p_type == PT_LOAD)
 208                 {
 209                   base = p[this].p_vaddr + l->l_addr;
 210                   limit = base + p[this].p_memsz;
 211                   if (stub_pc >= base && stub_pc < limit)
 212                     return l;
 213                 }
 214             }
 215         }
 216     }
 217
 218     {
 219       struct link_map *l = GL(dl_loaded);
 220
 221       while (l)
 222         {
 223           ElfW(Addr) base, limit;
 224           const ElfW(Phdr) *p = l->l_phdr;
 225           ElfW(Half) this, nent = l->l_phnum;
 226
 227           for (this = 0; this < nent; ++this)
 228             {
 229               if (p[this].p_type == PT_LOAD)
 230                 {
 231                   base = p[this].p_vaddr + l->l_addr;
 232                   limit = base + p[this].p_memsz;
 233                   if (stub_pc >= base && stub_pc < limit)
 234                     return l;
 235                 }
 236             }
 237           l = l->l_next;
 238         }
 239     }
 240
 241   _dl_signal_error (0, NULL, NULL, "cannot find runtime link map");
 242   return NULL;
 243 }
 244
 245 /* Define mips specific runtime resolver. The function __dl_runtime_resolve
 246    is called from assembler function _dl_runtime_resolve which converts
 247    special argument registers t7 ($15) and t8 ($24):
 248      t7  address to return to the caller of the function
 249      t8  index for this function symbol in .dynsym
 250    to usual c arguments.
 251
 252    Other architectures call fixup from dl-runtime.c in
 253    _dl_runtime_resolve.  MIPS instead calls __dl_runtime_resolve.  We
 254    have to use our own version because of the way the got section is
 255    treated on MIPS (we've also got ELF_MACHINE_PLT defined).  */
 256
 257 #define ELF_MACHINE_RUNTIME_TRAMPOLINE                                        \
 258 /* The flag _dl_mips_gnu_objects is set if all dynamic objects are            \
 259    generated by the gnu linker. */                                            \
 260 int _dl_mips_gnu_objects = 1;                                                 \
 261                                                                               \
 262 /* This is called from assembly stubs below which the compiler can't see.  */ \
 263 static ElfW(Addr)                                                             \
 264 __dl_runtime_resolve (ElfW(Word), ElfW(Word), ElfW(Addr), ElfW(Addr))         \
 265                   __attribute_used__;                                         \
 266                                                                               \
 267 static ElfW(Addr)                                                             \
 268 __dl_runtime_resolve (ElfW(Word) sym_index,                                   \
 269                       ElfW(Word) return_address,                              \
 270                       ElfW(Addr) old_gpreg,                                   \
 271                       ElfW(Addr) stub_pc)                                     \
 272 {                                                                             \
 273   struct link_map *l = elf_machine_runtime_link_map (old_gpreg, stub_pc);     \
 274   const ElfW(Sym) *const symtab                                               \
 275     = (const void *) D_PTR (l, l_info[DT_SYMTAB]);                            \
 276   const char *strtab                                                          \
 277     = (const void *) D_PTR (l, l_info[DT_STRTAB]);                            \
 278   ElfW(Addr) *got                                                             \
 279     = (ElfW(Addr) *) D_PTR (l, l_info[DT_PLTGOT]);                            \
 280   const ElfW(Word) local_gotno                                                \
 281     = (const ElfW(Word)) l->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val;        \
 282   const ElfW(Word) gotsym                                                     \
 283     = (const ElfW(Word)) l->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;             \
 284   const ElfW(Sym) *sym = &symtab[sym_index];                                  \
 285   ElfW(Addr) value;                                                           \
 286                                                                               \
 287   /* FIXME: The symbol versioning stuff is not tested yet.  */                \
 288   if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)         \
 289     {                                                                         \
 290       switch (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)                       \
 291         {                                                                     \
 292         default:                                                              \
 293           {                                                                   \
 294             const ElfW(Half) *vernum =                                        \
 295               (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);        \
 296             ElfW(Half) ndx = vernum[sym_index];                               \
 297             const struct r_found_version *version = &l->l_versions[ndx];      \
 298                                                                               \
 299             if (version->hash != 0)                                           \
 300               {                                                               \
 301                 value = _dl_lookup_versioned_symbol(strtab + sym->st_name, l, \
 302                                                     &sym, l->l_scope, version,\
 303                                                     ELF_RTYPE_CLASS_PLT, 0);  \
 304                 break;                                                        \
 305               }                                                               \
 306             /* Fall through.  */                                              \
 307           }                                                                   \
 308         case 0:                                                               \
 309           value = _dl_lookup_symbol (strtab + sym->st_name, l, &sym,          \
 310                                      l->l_scope, ELF_RTYPE_CLASS_PLT, 0);     \
 311         }                                                                     \
 312                                                                               \
 313       /* Currently value contains the base load address of the object         \
 314          that defines sym.  Now add in the symbol offset.  */                 \
 315       value = (sym ? value + sym->st_value : 0);                              \
 316     }                                                                         \
 317   else                                                                        \
 318     /* We already found the symbol.  The module (and therefore its load       \
 319        address) is also known.  */                                            \
 320     value = l->l_addr + sym->st_value;                                        \
 321                                                                               \
 322   /* Apply the relocation with that value.  */                                \
 323   *(got + local_gotno + sym_index - gotsym) = value;                          \
 324                                                                               \
 325   return value;                                                               \
 326 }                                                                             \
 327                                                                               \
 328 asm ("\n                                                                      \
 329         .text\n                                                               \
 330         .align  2\n                                                           \
 331         .globl  _dl_runtime_resolve\n                                         \
 332         .type   _dl_runtime_resolve,@function\n                               \
 333         .ent    _dl_runtime_resolve\n                                         \
 334 _dl_runtime_resolve:\n                                                        \
 335         .frame  $29, 40, $31\n                                                \
 336         .set noreorder\n                                                      \
 337         # Save GP.\n                                                          \
 338         move    $3, $28\n                                                     \
 339         # Modify t9 ($25) so as to point .cpload instruction.\n               \
 340         addu    $25, 8\n                                                      \
 341         # Compute GP.\n                                                       \
 342         .cpload $25\n                                                         \
 343         .set reorder\n                                                        \
 344         # Save slot call pc.\n                                                \
 345         move    $2, $31\n                                                     \
 346         # Save arguments and sp value in stack.\n                             \
 347         subu    $29, 40\n                                                     \
 348         .cprestore 32\n                                                       \
 349         sw      $15, 36($29)\n                                                \
 350         sw      $4, 16($29)\n                                                 \
 351         sw      $5, 20($29)\n                                                 \
 352         sw      $6, 24($29)\n                                                 \
 353         sw      $7, 28($29)\n                                                 \
 354         move    $4, $24\n                                                     \
 355         move    $5, $15\n                                                     \
 356         move    $6, $3\n                                                      \
 357         move    $7, $2\n                                                      \
 358         jal     __dl_runtime_resolve\n                                        \
 359         lw      $31, 36($29)\n                                                \
 360         lw      $4, 16($29)\n                                                 \
 361         lw      $5, 20($29)\n                                                 \
 362         lw      $6, 24($29)\n                                                 \
 363         lw      $7, 28($29)\n                                                 \
 364         addu    $29, 40\n                                                     \
 365         move    $25, $2\n                                                     \
 366         jr      $25\n                                                         \
 367         .end    _dl_runtime_resolve\n                                         \
 368         .previous\n                                                           \
 369 ");
 370
 371 /* Mask identifying addresses reserved for the user program,
 372    where the dynamic linker should not map anything.  */
 373 #define ELF_MACHINE_USER_ADDRESS_MASK   0x80000000UL
 374
 375
 376
 377 /* Initial entry point code for the dynamic linker.
 378    The C function `_dl_start' is the real entry point;
 379    its return value is the user program's entry point.
 380    Note how we have to be careful about two things:
 381
 382    1) That we allocate a minimal stack of 24 bytes for
 383       every function call, the MIPS ABI states that even
 384       if all arguments are passed in registers the procedure
 385       called can use the 16 byte area pointed to by $sp
 386       when it is called to store away the arguments passed
 387       to it.
 388
 389    2) That under Linux the entry is named __start
 390       and not just plain _start.  */
 391
 392 #define RTLD_START asm (\
 393         ".text\n"\
 394         _RTLD_PROLOGUE(ENTRY_POINT)\
 395         ".set noreorder\n\
 396         bltzal $0, 0f\n\
 397         nop\n\
 398 0:      .cpload $31\n\
 399         .set reorder\n\
 400         # i386 ABI book says that the first entry of GOT holds\n\
 401         # the address of the dynamic structure. Though MIPS ABI\n\
 402         # doesn't say nothing about this, I emulate this here.\n\
 403         la $4, _DYNAMIC\n\
 404         # Subtract OFFSET_GP_GOT\n\
 405         sw $4, -0x7ff0($28)\n\
 406         move $4, $29\n\
 407         subu $29, 16\n\
 408         \n\
 409         la $8, coff\n\
 410         bltzal $8, coff\n\
 411 coff:   subu $8, $31, $8\n\
 412         \n\
 413         la $25, _dl_start\n\
 414         addu $25, $8\n\
 415         jalr $25\n\
 416         \n\
 417         addiu $29, 16\n\
 418         # Get the value of label '_dl_start_user' in t9 ($25).\n\
 419         la $25, _dl_start_user\n\
 420         .globl _dl_start_user\n\
 421 _dl_start_user:\n\
 422         .set noreorder\n\
 423         .cpload $25\n\
 424         .set reorder\n\
 425         move $16, $28\n\
 426         # Save the user entry point address in a saved register.\n\
 427         move $17, $2\n\
 428         # Store the highest stack address\n\
 429         sw $29, __libc_stack_end\n\
 430         # See if we were run as a command with the executable file\n\
 431         # name as an extra leading argument.\n\
 432         lw $2, _dl_skip_args\n\
 433         beq $2, $0, 1f\n\
 434         # Load the original argument count.\n\
 435         lw $4, 0($29)\n\
 436         # Subtract _dl_skip_args from it.\n\
 437         subu $4, $2\n\
 438         # Adjust the stack pointer to skip _dl_skip_args words.\n\
 439         sll $2, 2\n\
 440         addu $29, $2\n\
 441         # Save back the modified argument count.\n\
 442         sw $4, 0($29)\n\
 443 1:      # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env) \n\
 444         lw $4, _rtld_global\n\
 445         lw $5, 0($29)\n\
 446         la $6, 4($29)\n\
 447         sll $7, $5, 2\n\
 448         addu $7, $7, $6\n\
 449         addu $7, $7, 4\n\
 450         subu $29, 16\n\
 451         # Call the function to run the initializers.\n\
 452         jal _dl_init_internal\n\
 453         addiu $29, 16\n\
 454         # Pass our finalizer function to the user in $2 as per ELF ABI.\n\
 455         la $2, _dl_fini\n\
 456         # Jump to the user entry point.\n\
 457         move $25, $17\n\
 458         jr $25\n\t"\
 459         _RTLD_EPILOGUE(ENTRY_POINT)\
 460         ".previous"\
 461 );
 462
 463 /* The MIPS never uses Elfxx_Rela relocations.  */
 464 #define ELF_MACHINE_NO_RELA 1
 465
 466 #endif /* !dl_machine_h */
 467
 468 #ifdef RESOLVE
 469
 470 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 471    MAP is the object containing the reloc.  */
 472
 473 static inline void
 474 elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
 475                  const ElfW(Sym) *sym, const struct r_found_version *version,
 476                  ElfW(Addr) *const reloc_addr)
 477 {
 478   const unsigned long int r_type = ELFW(R_TYPE) (reloc->r_info);
 479
 480 #if !defined RTLD_BOOTSTRAP && !defined SHARED
 481   /* This is defined in rtld.c, but nowhere in the static libc.a;
 482      make the reference weak so static programs can still link.  This
 483      declaration cannot be done when compiling rtld.c (i.e.  #ifdef
 484      RTLD_BOOTSTRAP) because rtld.c contains the common defn for
 485      _dl_rtld_map, which is incompatible with a weak decl in the same
 486      file.  */
 487   weak_extern (GL(dl_rtld_map));
 488 #endif
 489
 490   switch (r_type)
 491     {
 492     case R_MIPS_REL32:
 493       {
 494         int symidx = ELFW(R_SYM) (reloc->r_info);
 495
 496         if (symidx)
 497           {
 498             const ElfW(Word) gotsym
 499               = (const ElfW(Word)) map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;
 500
 501             if (symidx < gotsym)
 502               {
 503 #ifndef RTLD_BOOTSTRAP
 504                 if (map != &GL(dl_rtld_map))
 505 #endif
 506                   *reloc_addr += sym->st_value + map->l_addr;
 507               }
 508             else
 509               {
 510 #ifndef RTLD_BOOTSTRAP
 511                 const ElfW(Addr) *got
 512                   = (const ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]);
 513                 const ElfW(Word) local_gotno
 514                   = (const ElfW(Word))
 515                     map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val;
 516
 517                 *reloc_addr += got[symidx + local_gotno - gotsym];
 518 #endif
 519               }
 520           }
 521         else
 522 #ifndef RTLD_BOOTSTRAP
 523           if (map != &GL(dl_rtld_map))
 524 #endif
 525             *reloc_addr += map->l_addr;
 526       }
 527       break;
 528     case R_MIPS_NONE:           /* Alright, Wilbur.  */
 529       break;
 530     default:
 531       _dl_reloc_bad_type (map, r_type, 0);
 532       break;
 533     }
 534 }
 535
 536 static inline void
 537 elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
 538                           ElfW(Addr) *const reloc_addr)
 539 {
 540   /* XXX Nothing to do.  There is no relative relocation, right?  */
 541 }
 542
 543 static inline void
 544 elf_machine_lazy_rel (struct link_map *map,
 545                       ElfW(Addr) l_addr, const ElfW(Rel) *reloc)
 546 {
 547   /* Do nothing.  */
 548 }
 549
 550 #ifndef RTLD_BOOTSTRAP
 551 /* Relocate GOT. */
 552 static inline void
 553 elf_machine_got_rel (struct link_map *map, int lazy)
 554 {
 555   ElfW(Addr) *got;
 556   ElfW(Sym) *sym;
 557   const ElfW(Half) *vernum;
 558   int i, n, symidx;
 559
 560 #define RESOLVE_GOTSYM(sym,vernum,sym_index)                              \
 561     ({                                                                    \
 562       const ElfW(Sym) *ref = sym;                                         \
 563       const struct r_found_version *version                               \
 564         = vernum ? &map->l_versions[vernum[sym_index]] : NULL;            \
 565       ElfW(Addr) value;                                                   \
 566       value = RESOLVE (&ref, version, R_MIPS_REL32);                      \
 567       (ref)? value + ref->st_value: 0;                                    \
 568     })
 569
 570   if (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 571     vernum = (const void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
 572   else
 573     vernum = NULL;
 574
 575   got = (ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]);
 576
 577   n = map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val;
 578   /* The dynamic linker's local got entries have already been relocated.  */
 579   if (map != &GL(dl_rtld_map))
 580     {
 581       /* got[0] is reserved. got[1] is also reserved for the dynamic object
 582          generated by gnu ld. Skip these reserved entries from relocation.  */
 583       i = (got[1] & ELF_MIPS_GNU_GOT1_MASK)? 2 : 1;
 584
 585       /* Add the run-time displacement to all local got entries if
 586          needed.  */
 587       if (__builtin_expect (map->l_addr != 0, 0))
 588         {
 589           while (i < n)
 590             got[i++] += map->l_addr;
 591         }
 592     }
 593
 594   /* Handle global got entries. */
 595   got += n;
 596   /* Keep track of the symbol index.  */
 597   symidx = map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val;
 598   sym = (ElfW(Sym) *) D_PTR (map, l_info[DT_SYMTAB]) + symidx;
 599   i = (map->l_info[DT_MIPS (SYMTABNO)]->d_un.d_val
 600        - map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val);
 601
 602   /* This loop doesn't handle Quickstart.  */
 603   while (i--)
 604     {
 605       if (sym->st_shndx == SHN_UNDEF)
 606         {
 607           if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC
 608               && sym->st_value && lazy)
 609             *got = sym->st_value + map->l_addr;
 610           else
 611             *got = RESOLVE_GOTSYM (sym, vernum, symidx);
 612         }
 613       else if (sym->st_shndx == SHN_COMMON)
 614         *got = RESOLVE_GOTSYM (sym, vernum, symidx);
 615       else if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC
 616                && *got != sym->st_value
 617                && lazy)
 618         *got += map->l_addr;
 619       else if (ELFW(ST_TYPE) (sym->st_info) == STT_SECTION)
 620         {
 621           if (sym->st_other == 0)
 622             *got += map->l_addr;
 623         }
 624       else
 625         *got = RESOLVE_GOTSYM (sym, vernum, symidx);
 626
 627       ++got;
 628       ++sym;
 629       ++symidx;
 630     }
 631
 632 #undef RESOLVE_GOTSYM
 633 }
 634 #endif
 635
 636 /* Set up the loaded object described by L so its stub function
 637    will jump to the on-demand fixup code __dl_runtime_resolve.  */
 638
 639 static inline int
 640 elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
 641 {
 642 # ifndef RTLD_BOOTSTRAP
 643   ElfW(Addr) *got;
 644   extern void _dl_runtime_resolve (ElfW(Word));
 645   extern int _dl_mips_gnu_objects;
 646
 647   if (lazy)
 648     {
 649       /* The GOT entries for functions have not yet been filled in.
 650          Their initial contents will arrange when called to put an
 651          offset into the .dynsym section in t8, the return address
 652          in t7 and then jump to _GLOBAL_OFFSET_TABLE[0].  */
 653       got = (ElfW(Addr) *) D_PTR (l, l_info[DT_PLTGOT]);
 654
 655       /* This function will get called to fix up the GOT entry indicated by
 656          the register t8, and then jump to the resolved address.  */
 657       got[0] = (ElfW(Addr)) &_dl_runtime_resolve;
 658
 659       /* Store l to _GLOBAL_OFFSET_TABLE[1] for gnu object. The MSB
 660          of got[1] of a gnu object is set to identify gnu objects.
 661          Where we can store l for non gnu objects? XXX  */
 662       if ((got[1] & ELF_MIPS_GNU_GOT1_MASK) != 0)
 663         got[1] = (ElfW(Addr)) ((unsigned) l | ELF_MIPS_GNU_GOT1_MASK);
 664       else
 665         _dl_mips_gnu_objects = 0;
 666     }
 667
 668   /* Relocate global offset table.  */
 669   elf_machine_got_rel (l, lazy);
 670
 671 # endif
 672   return lazy;
 673 }
 674
 675 #endif /* RESOLVE */