1 /* Machine-dependent ELF dynamic relocation inline functions. MIPS version.
2 Copyright (C) 1996-2015 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>.
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.
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.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library. If not, see
18 <http://www.gnu.org/licenses/>. */
20 /* FIXME: Profiling of shared libraries is not implemented yet. */
24 #define ELF_MACHINE_NAME "MIPS"
29 #error ENTRY_POINT needs to be defined for MIPS.
36 /* The offset of gp from GOT might be system-dependent. It's set by
37 ld. The same value is also */
38 #define OFFSET_GP_GOT 0x7ff0
40 #ifndef _RTLD_PROLOGUE
41 # define _RTLD_PROLOGUE(entry) \
42 ".globl\t" __STRING(entry) "\n\t" \
43 ".ent\t" __STRING(entry) "\n\t" \
44 ".type\t" __STRING(entry) ", @function\n" \
45 __STRING(entry) ":\n\t"
48 #ifndef _RTLD_EPILOGUE
49 # define _RTLD_EPILOGUE(entry) \
50 ".end\t" __STRING(entry) "\n\t" \
51 ".size\t" __STRING(entry) ", . - " __STRING(entry) "\n\t"
54 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.
55 This only makes sense on MIPS when using PLTs, so choose the
56 PLT relocation (not encountered when not using PLTs). */
57 #define ELF_MACHINE_JMP_SLOT R_MIPS_JUMP_SLOT
58 #define elf_machine_type_class(type) \
59 ((((type) == ELF_MACHINE_JMP_SLOT) * ELF_RTYPE_CLASS_PLT) \
60 | (((type) == R_MIPS_COPY) * ELF_RTYPE_CLASS_COPY))
62 #define ELF_MACHINE_PLT_REL 1
63 #define ELF_MACHINE_NO_REL 0
64 #define ELF_MACHINE_NO_RELA 0
66 /* Translate a processor specific dynamic tag to the index
68 #define DT_MIPS(x) (DT_MIPS_##x - DT_LOPROC + DT_NUM)
70 /* If there is a DT_MIPS_RLD_MAP entry in the dynamic section, fill it in
71 with the run-time address of the r_debug structure */
72 #define ELF_MACHINE_DEBUG_SETUP(l,r) \
73 do { if ((l)->l_info[DT_MIPS (RLD_MAP)]) \
74 *(ElfW(Addr) *)((l)->l_info[DT_MIPS (RLD_MAP)]->d_un.d_ptr) = \
78 #if ((defined __mips_nan2008 && !defined HAVE_MIPS_NAN2008) \
79 || (!defined __mips_nan2008 && defined HAVE_MIPS_NAN2008))
80 # error "Configuration inconsistency: __mips_nan2008 != HAVE_MIPS_NAN2008, overridden CFLAGS?"
83 # define ELF_MACHINE_NAN2008 EF_MIPS_NAN2008
85 # define ELF_MACHINE_NAN2008 0
88 /* Return nonzero iff ELF header is compatible with the running host. */
89 static inline int __attribute_used__
90 elf_machine_matches_host (const ElfW(Ehdr
) *ehdr
)
92 #if _MIPS_SIM == _ABIO32 || _MIPS_SIM == _ABIN32
93 /* Don't link o32 and n32 together. */
94 if (((ehdr
->e_flags
& EF_MIPS_ABI2
) != 0) != (_MIPS_SIM
== _ABIN32
))
98 /* Don't link 2008-NaN and legacy-NaN objects together. */
99 if ((ehdr
->e_flags
& EF_MIPS_NAN2008
) != ELF_MACHINE_NAN2008
)
102 /* Ensure that the old O32 FP64 ABI is never loaded, it is not supported
104 if (ehdr
->e_flags
& EF_MIPS_FP64
)
107 switch (ehdr
->e_machine
)
117 static inline ElfW(Addr
) *
118 elf_mips_got_from_gpreg (ElfW(Addr
) gpreg
)
120 /* FIXME: the offset of gp from GOT may be system-dependent. */
121 return (ElfW(Addr
) *) (gpreg
- OFFSET_GP_GOT
);
124 /* Return the link-time address of _DYNAMIC. Conveniently, this is the
125 first element of the GOT. This must be inlined in a function which
126 uses global data. We assume its $gp points to the primary GOT. */
127 static inline ElfW(Addr
)
128 elf_machine_dynamic (void)
130 register ElfW(Addr
) gp
__asm__ ("$28");
131 return *elf_mips_got_from_gpreg (gp
);
134 #define STRINGXP(X) __STRING(X)
135 #define STRINGXV(X) STRINGV_(X)
136 #define STRINGV_(...) # __VA_ARGS__
138 /* Return the run-time load address of the shared object. */
139 static inline ElfW(Addr
)
140 elf_machine_load_address (void)
144 asm (" .set noreorder\n"
145 " " STRINGXP (PTR_LA
) " %0, 0f\n"
148 "0: " STRINGXP (PTR_SUBU
) " %0, $31, %0\n"
155 asm (" .set noreorder\n"
157 " lw %1,%%got(0f)(%1)\n"
158 "0: .fill 0\n" /* Clear the ISA bit on 0:. */
160 " addiu %1,%%lo(0b)\n"
163 : "=d" (addr
), "=d" (tmp
)
169 /* The MSB of got[1] of a gnu object is set to identify gnu objects. */
170 #if _MIPS_SIM == _ABI64
171 # define ELF_MIPS_GNU_GOT1_MASK 0x8000000000000000L
173 # define ELF_MIPS_GNU_GOT1_MASK 0x80000000L
176 /* We can't rely on elf_machine_got_rel because _dl_object_relocation_scope
177 fiddles with global data. */
178 #define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) \
180 struct link_map *map = &bootstrap_map; \
185 got = (ElfW(Addr) *) D_PTR (map, l_info[DT_PLTGOT]); \
187 if (__builtin_expect (map->l_addr == 0, 1)) \
190 /* got[0] is reserved. got[1] is also reserved for the dynamic object \
191 generated by gnu ld. Skip these reserved entries from \
193 i = (got[1] & ELF_MIPS_GNU_GOT1_MASK)? 2 : 1; \
194 n = map->l_info[DT_MIPS (LOCAL_GOTNO)]->d_un.d_val; \
196 /* Add the run-time displacement to all local got entries. */ \
198 got[i++] += map->l_addr; \
200 /* Handle global got entries. */ \
202 sym = (ElfW(Sym) *) D_PTR(map, l_info[DT_SYMTAB]) \
203 + map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val; \
204 i = (map->l_info[DT_MIPS (SYMTABNO)]->d_un.d_val \
205 - map->l_info[DT_MIPS (GOTSYM)]->d_un.d_val); \
209 if (sym->st_shndx == SHN_UNDEF || sym->st_shndx == SHN_COMMON) \
210 *got = map->l_addr + sym->st_value; \
211 else if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC \
212 && *got != sym->st_value) \
213 *got += map->l_addr; \
214 else if (ELFW(ST_TYPE) (sym->st_info) == STT_SECTION) \
216 if (sym->st_other == 0) \
217 *got += map->l_addr; \
220 *got = map->l_addr + sym->st_value; \
228 /* Mask identifying addresses reserved for the user program,
229 where the dynamic linker should not map anything. */
230 #define ELF_MACHINE_USER_ADDRESS_MASK 0x80000000UL
233 /* Initial entry point code for the dynamic linker.
234 The C function `_dl_start' is the real entry point;
235 its return value is the user program's entry point.
236 Note how we have to be careful about two things:
238 1) That we allocate a minimal stack of 24 bytes for
239 every function call, the MIPS ABI states that even
240 if all arguments are passed in registers the procedure
241 called can use the 16 byte area pointed to by $sp
242 when it is called to store away the arguments passed
245 2) That under Unix the entry is named __start
246 and not just plain _start. */
249 # define RTLD_START asm (\
251 " _RTLD_PROLOGUE(ENTRY_POINT) "\
252 " STRINGXV(SETUP_GPX($25)) "\n\
253 " STRINGXV(SETUP_GPX64($18,$25)) "\n\
254 # i386 ABI book says that the first entry of GOT holds\n\
255 # the address of the dynamic structure. Though MIPS ABI\n\
256 # doesn't say nothing about this, I emulate this here.\n\
257 " STRINGXP(PTR_LA) " $4, _DYNAMIC\n\
258 # Subtract OFFSET_GP_GOT\n\
259 " STRINGXP(PTR_S) " $4, -0x7ff0($28)\n\
261 " STRINGXP(PTR_SUBIU) " $29, 16\n\
263 " STRINGXP(PTR_LA) " $8, .Lcoff\n\
265 .Lcoff: " STRINGXP(PTR_SUBU) " $8, $31, $8\n\
267 " STRINGXP(PTR_LA) " $25, _dl_start\n\
268 " STRINGXP(PTR_ADDU) " $25, $8\n\
271 " STRINGXP(PTR_ADDIU) " $29, 16\n\
272 # Get the value of label '_dl_start_user' in t9 ($25).\n\
273 " STRINGXP(PTR_LA) " $25, _dl_start_user\n\
274 " _RTLD_EPILOGUE(ENTRY_POINT) "\
277 " _RTLD_PROLOGUE(_dl_start_user) "\
278 " STRINGXP(SETUP_GP) "\n\
279 " STRINGXV(SETUP_GP64($18,_dl_start_user)) "\n\
281 # Save the user entry point address in a saved register.\n\
283 # See if we were run as a command with the executable file\n\
284 # name as an extra leading argument.\n\
285 lw $2, _dl_skip_args\n\
287 # Load the original argument count.\n\
288 " STRINGXP(PTR_L) " $4, 0($29)\n\
289 # Subtract _dl_skip_args from it.\n\
291 # Adjust the stack pointer to skip _dl_skip_args words.\n\
292 sll $2, " STRINGXP (PTRLOG) "\n\
293 " STRINGXP(PTR_ADDU) " $29, $2\n\
294 # Save back the modified argument count.\n\
295 " STRINGXP(PTR_S) " $4, 0($29)\n\
296 1: # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env) \n\
297 " STRINGXP(PTR_L) " $4, _rtld_local\n\
298 " STRINGXP(PTR_L) /* or lw??? fixme */ " $5, 0($29)\n\
299 " STRINGXP(PTR_LA) " $6, " STRINGXP (PTRSIZE) "($29)\n\
300 sll $7, $5, " STRINGXP (PTRLOG) "\n\
301 " STRINGXP(PTR_ADDU) " $7, $7, $6\n\
302 " STRINGXP(PTR_ADDU) " $7, $7, " STRINGXP (PTRSIZE) " \n\
303 # Make sure the stack pointer is aligned for _dl_init.\n\
304 and $2, $29, -2 * " STRINGXP(SZREG) "\n\
306 " STRINGXP(PTR_SUBIU) " $29, $2, 32\n\
307 " STRINGXP(PTR_S) " $8, (32 - " STRINGXP(SZREG) ")($29)\n\
308 " STRINGXP(SAVE_GP(16)) "\n\
309 # Call the function to run the initializers.\n\
311 # Restore the stack pointer for _start.\n\
312 " STRINGXP(PTR_L) " $29, (32 - " STRINGXP(SZREG) ")($29)\n\
313 # Pass our finalizer function to the user in $2 as per ELF ABI.\n\
314 " STRINGXP(PTR_LA) " $2, _dl_fini\n\
315 # Jump to the user entry point.\n\
318 _RTLD_EPILOGUE(_dl_start_user)\
323 /* MIPS16 version. We currently only support O32 under MIPS16; the proper
324 assembly preprocessor abstractions will need to be added if other ABIs
325 are to be supported. */
327 # define RTLD_START asm (\
330 " _RTLD_PROLOGUE (ENTRY_POINT) "\
331 # Construct GP value in $3.\n\
332 li $3, %hi(_gp_disp)\n\
333 addiu $4, $pc, %lo(_gp_disp)\n\
337 lw $4, %got(_DYNAMIC)($3)\n\
338 sw $4, -0x7ff0($3)\n\
341 # _dl_start() is sufficiently near to use pc-relative\n\
347 " _RTLD_EPILOGUE (ENTRY_POINT) "\
350 " _RTLD_PROLOGUE (_dl_start_user) "\
351 li $16, %hi(_gp_disp)\n\
352 addiu $4, $pc, %lo(_gp_disp)\n\
357 lw $4, %got(_dl_skip_args)($16)\n\
360 # Load the original argument count.\n\
362 # Subtract _dl_skip_args from it.\n\
364 # Adjust the stack pointer to skip _dl_skip_args words.\n\
365 sll $4, " STRINGXP (PTRLOG) "\n\
369 # Save back the modified argument count.\n\
371 1: # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env) \n\
372 lw $4, %got(_rtld_local)($16)\n\
375 addiu $6, $sp, " STRINGXP (PTRSIZE) "\n\
376 sll $7, $5, " STRINGXP (PTRLOG) "\n\
378 addu $7, " STRINGXP (PTRSIZE) "\n\
379 # Make sure the stack pointer is aligned for _dl_init.\n\
380 li $2, 2 * " STRINGXP (SZREG) "\n\
384 sw $3, -" STRINGXP (SZREG) "($2)\n\
388 # Call the function to run the initializers.\n\
389 lw $2, %call16(_dl_init)($16)\n\
392 # Restore the stack pointer for _start.\n\
393 lw $2, 32-" STRINGXP (SZREG) "($sp)\n\
396 # Pass our finalizer function to the user in $2 as per ELF ABI.\n\
397 lw $2, %call16(_dl_fini)($16)\n\
398 # Jump to the user entry point.\n\
401 _RTLD_EPILOGUE (_dl_start_user)\
405 #endif /* __mips16 */
407 /* Names of the architecture-specific auditing callback functions. */
408 # if _MIPS_SIM == _ABIO32
409 # define ARCH_LA_PLTENTER mips_o32_gnu_pltenter
410 # define ARCH_LA_PLTEXIT mips_o32_gnu_pltexit
411 # elif _MIPS_SIM == _ABIN32
412 # define ARCH_LA_PLTENTER mips_n32_gnu_pltenter
413 # define ARCH_LA_PLTEXIT mips_n32_gnu_pltexit
415 # define ARCH_LA_PLTENTER mips_n64_gnu_pltenter
416 # define ARCH_LA_PLTEXIT mips_n64_gnu_pltexit
419 /* We define an initialization function. This is called very early in
421 #define DL_PLATFORM_INIT dl_platform_init ()
423 static inline void __attribute__ ((unused
))
424 dl_platform_init (void)
426 if (GLRO(dl_platform
) != NULL
&& *GLRO(dl_platform
) == '\0')
427 /* Avoid an empty string which would disturb us. */
428 GLRO(dl_platform
) = NULL
;
431 /* For a non-writable PLT, rewrite the .got.plt entry at RELOC_ADDR to
432 point at the symbol with address VALUE. For a writable PLT, rewrite
433 the corresponding PLT entry instead. */
434 static inline ElfW(Addr
)
435 elf_machine_fixup_plt (struct link_map
*map
, lookup_t t
,
436 const ElfW(Rel
) *reloc
,
437 ElfW(Addr
) *reloc_addr
, ElfW(Addr
) value
)
439 return *reloc_addr
= value
;
442 static inline ElfW(Addr
)
443 elf_machine_plt_value (struct link_map
*map
, const ElfW(Rel
) *reloc
,
449 /* The semantics of zero/non-zero values of undefined symbols differs
450 depending on whether the non-PIC ABI is in use. Under the non-PIC
451 ABI, a non-zero value indicates that there is an address reference
452 to the symbol and thus it must always be resolved (except when
453 resolving a jump slot relocation) to the PLT entry whose address is
454 provided as the symbol's value; a zero value indicates that this
455 canonical-address behaviour is not required. Yet under the classic
456 MIPS psABI, a zero value indicates that there is an address
457 reference to the function and the dynamic linker must resolve the
458 symbol immediately upon loading. To avoid conflict, symbols for
459 which the dynamic linker must assume the non-PIC ABI semantics are
460 marked with the STO_MIPS_PLT flag. */
461 #define ELF_MACHINE_SYM_NO_MATCH(sym) \
462 ((sym)->st_shndx == SHN_UNDEF && !((sym)->st_other & STO_MIPS_PLT))
464 #endif /* !dl_machine_h */
468 /* Perform a relocation described by R_INFO at the location pointed to
469 by RELOC_ADDR. SYM is the relocation symbol specified by R_INFO and
470 MAP is the object containing the reloc. */
473 __attribute__ ((always_inline
))
474 elf_machine_reloc (struct link_map
*map
, ElfW(Addr
) r_info
,
475 const ElfW(Sym
) *sym
, const struct r_found_version
*version
,
476 void *reloc_addr
, ElfW(Addr
) r_addend
, int inplace_p
)
478 const unsigned long int r_type
= ELFW(R_TYPE
) (r_info
);
479 ElfW(Addr
) *addr_field
= (ElfW(Addr
) *) reloc_addr
;
481 #if !defined RTLD_BOOTSTRAP && !defined SHARED
482 /* This is defined in rtld.c, but nowhere in the static libc.a;
483 make the reference weak so static programs can still link. This
484 declaration cannot be done when compiling rtld.c (i.e. #ifdef
485 RTLD_BOOTSTRAP) because rtld.c contains the common defn for
486 _dl_rtld_map, which is incompatible with a weak decl in the same
488 weak_extern (GL(dl_rtld_map
));
493 #if !defined (RTLD_BOOTSTRAP)
494 # if _MIPS_SIM == _ABI64
495 case R_MIPS_TLS_DTPMOD64
:
496 case R_MIPS_TLS_DTPREL64
:
497 case R_MIPS_TLS_TPREL64
:
499 case R_MIPS_TLS_DTPMOD32
:
500 case R_MIPS_TLS_DTPREL32
:
501 case R_MIPS_TLS_TPREL32
:
504 struct link_map
*sym_map
= RESOLVE_MAP (&sym
, version
, r_type
);
508 case R_MIPS_TLS_DTPMOD64
:
509 case R_MIPS_TLS_DTPMOD32
:
511 *addr_field
= sym_map
->l_tls_modid
;
514 case R_MIPS_TLS_DTPREL64
:
515 case R_MIPS_TLS_DTPREL32
:
519 r_addend
= *addr_field
;
520 *addr_field
= r_addend
+ TLS_DTPREL_VALUE (sym
);
524 case R_MIPS_TLS_TPREL32
:
525 case R_MIPS_TLS_TPREL64
:
528 CHECK_STATIC_TLS (map
, sym_map
);
530 r_addend
= *addr_field
;
531 *addr_field
= r_addend
+ TLS_TPREL_VALUE (sym_map
, sym
);
540 #if _MIPS_SIM == _ABI64
541 case (R_MIPS_64
<< 8) | R_MIPS_REL32
:
546 int symidx
= ELFW(R_SYM
) (r_info
);
547 ElfW(Addr
) reloc_value
;
550 /* Support relocations on mis-aligned offsets. */
551 __builtin_memcpy (&reloc_value
, reloc_addr
, sizeof (reloc_value
));
553 reloc_value
= r_addend
;
557 const ElfW(Word
) gotsym
558 = (const ElfW(Word
)) map
->l_info
[DT_MIPS (GOTSYM
)]->d_un
.d_val
;
560 if ((ElfW(Word
))symidx
< gotsym
)
562 /* This wouldn't work for a symbol imported from other
563 libraries for which there's no GOT entry, but MIPS
564 requires every symbol referenced in a dynamic
565 relocation to have a GOT entry in the primary GOT,
566 so we only get here for locally-defined symbols.
567 For section symbols, we should *NOT* be adding
568 sym->st_value (per the definition of the meaning of
569 S in reloc expressions in the ELF64 MIPS ABI),
570 since it should have already been added to
571 reloc_value by the linker, but older versions of
572 GNU ld didn't add it, and newer versions don't emit
573 useless relocations to section symbols any more, so
574 it is safe to keep on adding sym->st_value, even
575 though it's not ABI compliant. Some day we should
576 bite the bullet and stop doing this. */
577 #ifndef RTLD_BOOTSTRAP
578 if (map
!= &GL(dl_rtld_map
))
580 reloc_value
+= sym
->st_value
+ map
->l_addr
;
584 #ifndef RTLD_BOOTSTRAP
585 const ElfW(Addr
) *got
586 = (const ElfW(Addr
) *) D_PTR (map
, l_info
[DT_PLTGOT
]);
587 const ElfW(Word
) local_gotno
589 map
->l_info
[DT_MIPS (LOCAL_GOTNO
)]->d_un
.d_val
;
591 reloc_value
+= got
[symidx
+ local_gotno
- gotsym
];
596 #ifndef RTLD_BOOTSTRAP
597 if (map
!= &GL(dl_rtld_map
))
599 reloc_value
+= map
->l_addr
;
601 __builtin_memcpy (reloc_addr
, &reloc_value
, sizeof (reloc_value
));
604 #ifndef RTLD_BOOTSTRAP
605 #if _MIPS_SIM == _ABI64
606 case (R_MIPS_64
<< 8) | R_MIPS_GLOB_DAT
:
608 case R_MIPS_GLOB_DAT
:
611 int symidx
= ELFW(R_SYM
) (r_info
);
612 const ElfW(Word
) gotsym
613 = (const ElfW(Word
)) map
->l_info
[DT_MIPS (GOTSYM
)]->d_un
.d_val
;
615 if (__builtin_expect ((ElfW(Word
)) symidx
>= gotsym
, 1))
617 const ElfW(Addr
) *got
618 = (const ElfW(Addr
) *) D_PTR (map
, l_info
[DT_PLTGOT
]);
619 const ElfW(Word
) local_gotno
620 = ((const ElfW(Word
))
621 map
->l_info
[DT_MIPS (LOCAL_GOTNO
)]->d_un
.d_val
);
623 ElfW(Addr
) reloc_value
= got
[symidx
+ local_gotno
- gotsym
];
624 __builtin_memcpy (reloc_addr
, &reloc_value
, sizeof (reloc_value
));
629 case R_MIPS_NONE
: /* Alright, Wilbur. */
632 case R_MIPS_JUMP_SLOT
:
634 struct link_map
*sym_map
;
637 /* The addend for a jump slot relocation must always be zero:
638 calls via the PLT always branch to the symbol's address and
639 not to the address plus a non-zero offset. */
641 _dl_signal_error (0, map
->l_name
, NULL
,
642 "found jump slot relocation with non-zero addend");
644 sym_map
= RESOLVE_MAP (&sym
, version
, r_type
);
645 value
= sym_map
== NULL
? 0 : sym_map
->l_addr
+ sym
->st_value
;
653 const ElfW(Sym
) *const refsym
= sym
;
654 struct link_map
*sym_map
;
657 /* Calculate the address of the symbol. */
658 sym_map
= RESOLVE_MAP (&sym
, version
, r_type
);
659 value
= sym_map
== NULL
? 0 : sym_map
->l_addr
+ sym
->st_value
;
661 if (__builtin_expect (sym
== NULL
, 0))
662 /* This can happen in trace mode if an object could not be
665 if (__builtin_expect (sym
->st_size
> refsym
->st_size
, 0)
666 || (__builtin_expect (sym
->st_size
< refsym
->st_size
, 0)
667 && GLRO(dl_verbose
)))
671 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
673 %s: Symbol `%s' has different size in shared object, consider re-linking\n",
674 RTLD_PROGNAME
, strtab
+ refsym
->st_name
);
676 memcpy (reloc_addr
, (void *) value
,
677 MIN (sym
->st_size
, refsym
->st_size
));
681 #if _MIPS_SIM == _ABI64
683 /* For full compliance with the ELF64 ABI, one must precede the
684 _REL32/_64 pair of relocations with a _64 relocation, such
685 that the in-place addend is read as a 64-bit value. IRIX
686 didn't pick up on this requirement, so we treat the
687 _REL32/_64 relocation as a 64-bit relocation even if it's by
688 itself. For ABI compliance, we ignore such _64 dummy
689 relocations. For RELA, this may be simply removed, since
690 it's totally unnecessary. */
691 if (ELFW(R_SYM
) (r_info
) == 0)
696 _dl_reloc_bad_type (map
, r_type
, 0);
701 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
702 MAP is the object containing the reloc. */
705 __attribute__ ((always_inline
))
706 elf_machine_rel (struct link_map
*map
, const ElfW(Rel
) *reloc
,
707 const ElfW(Sym
) *sym
, const struct r_found_version
*version
,
708 void *const reloc_addr
, int skip_ifunc
)
710 elf_machine_reloc (map
, reloc
->r_info
, sym
, version
, reloc_addr
, 0, 1);
714 __attribute__((always_inline
))
715 elf_machine_rel_relative (ElfW(Addr
) l_addr
, const ElfW(Rel
) *reloc
,
716 void *const reloc_addr
)
718 /* XXX Nothing to do. There is no relative relocation, right? */
722 __attribute__((always_inline
))
723 elf_machine_lazy_rel (struct link_map
*map
,
724 ElfW(Addr
) l_addr
, const ElfW(Rel
) *reloc
,
727 ElfW(Addr
) *const reloc_addr
= (void *) (l_addr
+ reloc
->r_offset
);
728 const unsigned int r_type
= ELFW(R_TYPE
) (reloc
->r_info
);
729 /* Check for unexpected PLT reloc type. */
730 if (__builtin_expect (r_type
== R_MIPS_JUMP_SLOT
, 1))
732 if (__builtin_expect (map
->l_mach
.plt
, 0) == 0)
734 /* Nothing is required here since we only support lazy
735 relocation in executables. */
738 *reloc_addr
= map
->l_mach
.plt
;
741 _dl_reloc_bad_type (map
, r_type
, 1);
745 __attribute__ ((always_inline
))
746 elf_machine_rela (struct link_map
*map
, const ElfW(Rela
) *reloc
,
747 const ElfW(Sym
) *sym
, const struct r_found_version
*version
,
748 void *const reloc_addr
, int skip_ifunc
)
750 elf_machine_reloc (map
, reloc
->r_info
, sym
, version
, reloc_addr
,
755 __attribute__((always_inline
))
756 elf_machine_rela_relative (ElfW(Addr
) l_addr
, const ElfW(Rela
) *reloc
,
757 void *const reloc_addr
)
761 #ifndef RTLD_BOOTSTRAP
764 __attribute__((always_inline
))
765 elf_machine_got_rel (struct link_map
*map
, int lazy
)
769 const ElfW(Half
) *vernum
;
772 #define RESOLVE_GOTSYM(sym,vernum,sym_index,reloc) \
774 const ElfW(Sym) *ref = sym; \
775 const struct r_found_version *version __attribute__ ((unused)) \
776 = vernum ? &map->l_versions[vernum[sym_index] & 0x7fff] : NULL; \
777 struct link_map *sym_map; \
778 sym_map = RESOLVE_MAP (&ref, version, reloc); \
779 ref ? sym_map->l_addr + ref->st_value : 0; \
782 if (map
->l_info
[VERSYMIDX (DT_VERSYM
)] != NULL
)
783 vernum
= (const void *) D_PTR (map
, l_info
[VERSYMIDX (DT_VERSYM
)]);
787 got
= (ElfW(Addr
) *) D_PTR (map
, l_info
[DT_PLTGOT
]);
789 n
= map
->l_info
[DT_MIPS (LOCAL_GOTNO
)]->d_un
.d_val
;
790 /* The dynamic linker's local got entries have already been relocated. */
791 if (map
!= &GL(dl_rtld_map
))
793 /* got[0] is reserved. got[1] is also reserved for the dynamic object
794 generated by gnu ld. Skip these reserved entries from relocation. */
795 i
= (got
[1] & ELF_MIPS_GNU_GOT1_MASK
)? 2 : 1;
797 /* Add the run-time displacement to all local got entries if
799 if (__builtin_expect (map
->l_addr
!= 0, 0))
802 got
[i
++] += map
->l_addr
;
806 /* Handle global got entries. */
808 /* Keep track of the symbol index. */
809 symidx
= map
->l_info
[DT_MIPS (GOTSYM
)]->d_un
.d_val
;
810 sym
= (ElfW(Sym
) *) D_PTR (map
, l_info
[DT_SYMTAB
]) + symidx
;
811 i
= (map
->l_info
[DT_MIPS (SYMTABNO
)]->d_un
.d_val
812 - map
->l_info
[DT_MIPS (GOTSYM
)]->d_un
.d_val
);
814 /* This loop doesn't handle Quickstart. */
817 if (sym
->st_shndx
== SHN_UNDEF
)
819 if (ELFW(ST_TYPE
) (sym
->st_info
) == STT_FUNC
&& sym
->st_value
820 && !(sym
->st_other
& STO_MIPS_PLT
))
823 *got
= sym
->st_value
+ map
->l_addr
;
825 /* This is a lazy-binding stub, so we don't need the
826 canonical address. */
827 *got
= RESOLVE_GOTSYM (sym
, vernum
, symidx
, R_MIPS_JUMP_SLOT
);
830 *got
= RESOLVE_GOTSYM (sym
, vernum
, symidx
, R_MIPS_32
);
832 else if (sym
->st_shndx
== SHN_COMMON
)
833 *got
= RESOLVE_GOTSYM (sym
, vernum
, symidx
, R_MIPS_32
);
834 else if (ELFW(ST_TYPE
) (sym
->st_info
) == STT_FUNC
835 && *got
!= sym
->st_value
)
840 /* This is a lazy-binding stub, so we don't need the
841 canonical address. */
842 *got
= RESOLVE_GOTSYM (sym
, vernum
, symidx
, R_MIPS_JUMP_SLOT
);
844 else if (ELFW(ST_TYPE
) (sym
->st_info
) == STT_SECTION
)
846 if (sym
->st_other
== 0)
850 *got
= RESOLVE_GOTSYM (sym
, vernum
, symidx
, R_MIPS_32
);
857 #undef RESOLVE_GOTSYM
861 /* Set up the loaded object described by L so its stub function
862 will jump to the on-demand fixup code __dl_runtime_resolve. */
865 __attribute__((always_inline
))
866 elf_machine_runtime_setup (struct link_map
*l
, int lazy
, int profile
)
868 # ifndef RTLD_BOOTSTRAP
870 extern void _dl_runtime_resolve (ElfW(Word
));
871 extern void _dl_runtime_pltresolve (void);
872 extern int _dl_mips_gnu_objects
;
876 /* The GOT entries for functions have not yet been filled in.
877 Their initial contents will arrange when called to put an
878 offset into the .dynsym section in t8, the return address
879 in t7 and then jump to _GLOBAL_OFFSET_TABLE[0]. */
880 got
= (ElfW(Addr
) *) D_PTR (l
, l_info
[DT_PLTGOT
]);
882 /* This function will get called to fix up the GOT entry indicated by
883 the register t8, and then jump to the resolved address. */
884 got
[0] = (ElfW(Addr
)) &_dl_runtime_resolve
;
886 /* Store l to _GLOBAL_OFFSET_TABLE[1] for gnu object. The MSB
887 of got[1] of a gnu object is set to identify gnu objects.
888 Where we can store l for non gnu objects? XXX */
889 if ((got
[1] & ELF_MIPS_GNU_GOT1_MASK
) != 0)
890 got
[1] = ((ElfW(Addr
)) l
| ELF_MIPS_GNU_GOT1_MASK
);
892 _dl_mips_gnu_objects
= 0;
895 /* Relocate global offset table. */
896 elf_machine_got_rel (l
, lazy
);
898 /* If using PLTs, fill in the first two entries of .got.plt. */
899 if (l
->l_info
[DT_JMPREL
] && lazy
)
902 gotplt
= (ElfW(Addr
) *) D_PTR (l
, l_info
[DT_MIPS (PLTGOT
)]);
903 /* If a library is prelinked but we have to relocate anyway,
904 we have to be able to undo the prelinking of .got.plt.
905 The prelinker saved the address of .plt for us here. */
907 l
->l_mach
.plt
= gotplt
[1] + l
->l_addr
;
908 gotplt
[0] = (ElfW(Addr
)) &_dl_runtime_pltresolve
;
909 gotplt
[1] = (ElfW(Addr
)) l
;
916 #endif /* RESOLVE_MAP */