1 /* Machine-dependent ELF dynamic relocation inline functions. SPARC version.
2 Copyright (C) 1996-2003, 2004, 2005, 2006, 2007, 2010
3 Free Software Foundation, Inc.
4 This file is part of the GNU C Library.
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, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24 #define ELF_MACHINE_NAME "sparc"
27 #include <sys/param.h>
33 # define VALIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM \
34 + DT_EXTRANUM + DT_VALTAGIDX (tag))
37 /* Return nonzero iff ELF header is compatible with the running host. */
39 elf_machine_matches_host (const Elf32_Ehdr
*ehdr
)
41 if (ehdr
->e_machine
== EM_SPARC
)
43 else if (ehdr
->e_machine
== EM_SPARC32PLUS
)
45 /* XXX The following is wrong! Dave Miller rejected to implement it
46 correctly. If this causes problems shoot *him*! */
48 return GLRO(dl_hwcap
) & GLRO(dl_hwcap_mask
) & HWCAP_SPARC_V9
;
50 return GLRO(dl_hwcap
) & HWCAP_SPARC_V9
;
57 /* We have to do this because elf_machine_{dynamic,load_address} can be
58 invoked from functions that have no GOT references, and thus the compiler
59 has no obligation to load the PIC register. */
60 #define LOAD_PIC_REG(PIC_REG) \
61 do { register Elf32_Addr pc __asm("o7"); \
62 __asm("sethi %%hi(_GLOBAL_OFFSET_TABLE_-4), %1\n\t" \
64 "add %1, %%lo(_GLOBAL_OFFSET_TABLE_+4), %1\n" \
65 "1:\tadd %1, %0, %1" \
66 : "=r" (pc), "=r" (PIC_REG)); \
69 /* Return the link-time address of _DYNAMIC. Conveniently, this is the
70 first element of the GOT. This must be inlined in a function which
72 static inline Elf32_Addr
73 elf_machine_dynamic (void)
75 register Elf32_Addr
*got
asm ("%l7");
82 /* Return the run-time load address of the shared object. */
83 static inline Elf32_Addr
84 elf_machine_load_address (void)
86 register Elf32_Addr
*pc
__asm ("%o7"), *got
__asm ("%l7");
88 __asm ("sethi %%hi(_GLOBAL_OFFSET_TABLE_-4), %1\n\t"
90 " add %1, %%lo(_GLOBAL_OFFSET_TABLE_+4), %1\n\t"
92 "call _GLOBAL_OFFSET_TABLE_\n"
93 "1:\tadd %1, %0, %1\n\t" : "=r" (pc
), "=r" (got
));
95 /* got is now l_addr + _GLOBAL_OFFSET_TABLE_
97 pc[2]*4 is l_addr + _DYNAMIC - (long)pc - 8
98 pc[3]*4 is l_addr + _GLOBAL_OFFSET_TABLE_ - (long)pc - 12 */
99 return (Elf32_Addr
) got
- *got
+ (pc
[2] - pc
[3]) * 4 - 4;
102 /* Set up the loaded object described by L so its unrelocated PLT
103 entries will jump to the on-demand fixup code in dl-runtime.c. */
106 elf_machine_runtime_setup (struct link_map
*l
, int lazy
, int profile
)
109 extern void _dl_runtime_resolve (Elf32_Word
);
110 extern void _dl_runtime_profile (Elf32_Word
);
112 if (l
->l_info
[DT_JMPREL
] && lazy
)
116 /* The entries for functions in the PLT have not yet been filled in.
117 Their initial contents will arrange when called to set the high 22
118 bits of %g1 with an offset into the .rela.plt section and jump to
119 the beginning of the PLT. */
120 plt
= (Elf32_Addr
*) D_PTR (l
, l_info
[DT_PLTGOT
]);
121 if (__builtin_expect(profile
, 0))
123 rfunc
= (Elf32_Addr
) &_dl_runtime_profile
;
125 if (GLRO(dl_profile
) != NULL
126 && _dl_name_match_p (GLRO(dl_profile
), l
))
127 GL(dl_profile_map
) = l
;
131 rfunc
= (Elf32_Addr
) &_dl_runtime_resolve
;
134 /* The beginning of the PLT does:
136 sethi %hi(_dl_runtime_{resolve,profile}), %g2
137 pltpc: jmpl %g2 + %lo(_dl_runtime_{resolve,profile}), %g2
141 The PC value (pltpc) saved in %g2 by the jmpl points near the
142 location where we store the link_map pointer for this object. */
144 plt
[0] = 0x05000000 | ((rfunc
>> 10) & 0x003fffff);
145 plt
[1] = 0x85c0a000 | (rfunc
& 0x3ff);
146 plt
[2] = OPCODE_NOP
; /* Fill call delay slot. */
147 plt
[3] = (Elf32_Addr
) l
;
148 if (__builtin_expect (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] != NULL
, 0)
149 || __builtin_expect (l
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
, 0))
151 /* Need to reinitialize .plt to undo prelinking. */
152 Elf32_Rela
*rela
= (Elf32_Rela
*) D_PTR (l
, l_info
[DT_JMPREL
]);
154 = (Elf32_Rela
*) ((char *) rela
155 + l
->l_info
[DT_PLTRELSZ
]->d_un
.d_val
);
156 #if !defined RTLD_BOOTSTRAP && !defined __sparc_v9__
157 /* Note that we don't mask the hwcap here, as the flush is
158 essential to functionality on those cpu's that implement it.
159 For sparcv9 we can assume flush is present. */
160 const int do_flush
= GLRO(dl_hwcap
) & HWCAP_SPARC_FLUSH
;
162 const int do_flush
= 1;
165 /* prelink must ensure there are no R_SPARC_NONE relocs left
167 while (rela
< relaend
)
169 *(unsigned int *) (rela
->r_offset
+ l
->l_addr
)
170 = OPCODE_SETHI_G1
| (rela
->r_offset
+ l
->l_addr
172 *(unsigned int *) (rela
->r_offset
+ l
->l_addr
+ 4)
173 = OPCODE_BA
| ((((Elf32_Addr
) plt
174 - rela
->r_offset
- l
->l_addr
- 4) >> 2)
178 __asm
__volatile ("flush %0" : : "r" (rela
->r_offset
180 __asm
__volatile ("flush %0+4" : : "r" (rela
->r_offset
191 /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry, so
192 PLT entries should not be allowed to define the value.
193 ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to one
194 of the main executable's symbols, as for a COPY reloc. */
195 #if !defined RTLD_BOOTSTRAP || USE___THREAD
196 # define elf_machine_type_class(type) \
197 ((((type) == R_SPARC_JMP_SLOT \
198 || ((type) >= R_SPARC_TLS_GD_HI22 && (type) <= R_SPARC_TLS_TPOFF64)) \
199 * ELF_RTYPE_CLASS_PLT) \
200 | (((type) == R_SPARC_COPY) * ELF_RTYPE_CLASS_COPY))
202 # define elf_machine_type_class(type) \
203 ((((type) == R_SPARC_JMP_SLOT) * ELF_RTYPE_CLASS_PLT) \
204 | (((type) == R_SPARC_COPY) * ELF_RTYPE_CLASS_COPY))
207 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries. */
208 #define ELF_MACHINE_JMP_SLOT R_SPARC_JMP_SLOT
210 /* The SPARC never uses Elf32_Rel relocations. */
211 #define ELF_MACHINE_NO_REL 1
213 /* The SPARC overlaps DT_RELA and DT_PLTREL. */
214 #define ELF_MACHINE_PLTREL_OVERLAP 1
216 /* Undo the sub %sp, 6*4, %sp; add %sp, 22*4, %o0 below to get at the
217 value we want in __libc_stack_end. */
218 #define DL_STACK_END(cookie) \
219 ((void *) (((long) (cookie)) - (22 - 6) * 4))
221 /* Initial entry point code for the dynamic linker.
222 The C function `_dl_start' is the real entry point;
223 its return value is the user program's entry point. */
225 #define RTLD_START __asm__ ("\
228 .type _start, @function\n\
231 /* Allocate space for functions to drop their arguments. */\n\
233 /* Pass pointer to argument block to _dl_start. */\n\
235 add %sp, 22*4, %o0\n\
237 .globl _dl_start_user\n\
238 .type _dl_start_user, @function\n\
240 /* Load the PIC register. */\n\
242 sethi %hi(_GLOBAL_OFFSET_TABLE_-(1b-.)), %l7\n\
243 2: or %l7, %lo(_GLOBAL_OFFSET_TABLE_-(1b-.)), %l7\n\
245 /* Save the user entry point address in %l0 */\n\
247 /* See if we were run as a command with the executable file name as an\n\
248 extra leading argument. If so, adjust the contents of the stack. */\n\
249 sethi %hi(_dl_skip_args), %g2\n\
250 or %g2, %lo(_dl_skip_args), %g2\n\
255 ld [%sp+22*4], %i5 /* load argc */\n\
256 /* Find out how far to shift. */\n\
257 sethi %hi(_dl_argv), %l3\n\
258 or %l3, %lo(_dl_argv), %l3\n\
263 st %i5, [%sp+22*4]\n\
265 add %sp, 23*4, %i1\n\
268 /* Copy down argv */\n\
275 /* Copy down env */\n\
282 /* Copy down auxiliary table. */\n\
291 /* %o0 = _dl_loaded, %o1 = argc, %o2 = argv, %o3 = envp. */\n\
292 3: sethi %hi(_rtld_local), %o0\n\
293 add %sp, 23*4, %o2\n\
294 orcc %o0, %lo(_rtld_local), %o0\n\
300 call _dl_init_internal\n\
302 /* Pass our finalizer function to the user in %g1. */\n\
303 sethi %hi(_dl_fini), %g1\n\
304 or %g1, %lo(_dl_fini), %g1\n\
306 /* Jump to the user's entry point and deallocate the extra stack we got. */\n\
309 .size _dl_start_user, . - _dl_start_user\n\
312 static inline Elf32_Addr
313 elf_machine_fixup_plt (struct link_map
*map
, lookup_t t
,
314 const Elf32_Rela
*reloc
,
315 Elf32_Addr
*reloc_addr
, Elf32_Addr value
)
318 /* Sparc v9 can assume flush is always present. */
319 const int do_flush
= 1;
321 /* Note that we don't mask the hwcap here, as the flush is essential to
322 functionality on those cpu's that implement it. */
323 const int do_flush
= GLRO(dl_hwcap
) & HWCAP_SPARC_FLUSH
;
325 return sparc_fixup_plt (reloc
, reloc_addr
, value
, 1, do_flush
);
328 /* Return the final value of a plt relocation. */
329 static inline Elf32_Addr
330 elf_machine_plt_value (struct link_map
*map
, const Elf32_Rela
*reloc
,
333 return value
+ reloc
->r_addend
;
336 #endif /* dl_machine_h */
338 #define ARCH_LA_PLTENTER sparc32_gnu_pltenter
339 #define ARCH_LA_PLTEXIT sparc32_gnu_pltexit
343 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
344 MAP is the object containing the reloc. */
347 __attribute__ ((always_inline
))
348 elf_machine_rela (struct link_map
*map
, const Elf32_Rela
*reloc
,
349 const Elf32_Sym
*sym
, const struct r_found_version
*version
,
350 void *const reloc_addr_arg
)
352 Elf32_Addr
*const reloc_addr
= reloc_addr_arg
;
353 const Elf32_Sym
*const refsym
= sym
;
355 const unsigned int r_type
= ELF32_R_TYPE (reloc
->r_info
);
356 struct link_map
*sym_map
= NULL
;
358 #if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
359 /* This is defined in rtld.c, but nowhere in the static libc.a; make the
360 reference weak so static programs can still link. This declaration
361 cannot be done when compiling rtld.c (i.e. #ifdef RTLD_BOOTSTRAP)
362 because rtld.c contains the common defn for _dl_rtld_map, which is
363 incompatible with a weak decl in the same file. */
364 weak_extern (_dl_rtld_map
);
367 if (__builtin_expect (r_type
== R_SPARC_NONE
, 0))
370 #if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
371 if (__builtin_expect (r_type
== R_SPARC_RELATIVE
, 0))
373 # if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
374 if (map
!= &_dl_rtld_map
) /* Already done in rtld itself. */
376 *reloc_addr
+= map
->l_addr
+ reloc
->r_addend
;
381 #ifndef RESOLVE_CONFLICT_FIND_MAP
382 if (__builtin_expect (ELF32_ST_BIND (sym
->st_info
) == STB_LOCAL
, 0)
383 && sym
->st_shndx
!= SHN_UNDEF
)
389 sym_map
= RESOLVE_MAP (&sym
, version
, r_type
);
390 value
= sym_map
== NULL
? 0 : sym_map
->l_addr
+ sym
->st_value
;
396 value
+= reloc
->r_addend
; /* Assume copy relocs have zero addend. */
399 && __builtin_expect (ELFW(ST_TYPE
) (sym
->st_info
) == STT_GNU_IFUNC
, 0)
400 && __builtin_expect (sym
->st_shndx
!= SHN_UNDEF
, 1))
402 value
= ((Elf32_Addr (*) (void)) value
) ();
407 #if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
410 /* This can happen in trace mode if an object could not be
413 if (sym
->st_size
> refsym
->st_size
414 || (GLRO(dl_verbose
) && sym
->st_size
< refsym
->st_size
))
418 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
420 %s: Symbol `%s' has different size in shared object, consider re-linking\n",
421 rtld_progname
?: "<program name unknown>",
422 strtab
+ refsym
->st_name
);
424 memcpy (reloc_addr_arg
, (void *) value
,
425 MIN (sym
->st_size
, refsym
->st_size
));
428 case R_SPARC_GLOB_DAT
:
432 case R_SPARC_IRELATIVE
:
433 value
= ((Elf32_Addr (*) (void)) value
) ();
436 case R_SPARC_JMP_IREL
:
437 value
= ((Elf32_Addr (*) (void)) value
) ();
439 case R_SPARC_JMP_SLOT
:
441 #if !defined RTLD_BOOTSTRAP && !defined __sparc_v9__
442 /* Note that we don't mask the hwcap here, as the flush is
443 essential to functionality on those cpu's that implement
444 it. For sparcv9 we can assume flush is present. */
445 const int do_flush
= GLRO(dl_hwcap
) & HWCAP_SPARC_FLUSH
;
447 /* Unfortunately, this is necessary, so that we can ensure
448 ld.so will not execute corrupt PLT entry instructions. */
449 const int do_flush
= 1;
451 /* At this point we don't need to bother with thread safety,
452 so we can optimize the first instruction of .plt out. */
453 sparc_fixup_plt (reloc
, reloc_addr
, value
, 0, do_flush
);
456 #if (!defined RTLD_BOOTSTRAP || USE___THREAD) \
457 && !defined RESOLVE_CONFLICT_FIND_MAP
458 case R_SPARC_TLS_DTPMOD32
:
459 /* Get the information from the link map returned by the
462 *reloc_addr
= sym_map
->l_tls_modid
;
464 case R_SPARC_TLS_DTPOFF32
:
465 /* During relocation all TLS symbols are defined and used.
466 Therefore the offset is already correct. */
467 *reloc_addr
= (sym
== NULL
? 0 : sym
->st_value
) + reloc
->r_addend
;
469 case R_SPARC_TLS_TPOFF32
:
470 /* The offset is negative, forward from the thread pointer. */
471 /* We know the offset of object the symbol is contained in.
472 It is a negative value which will be added to the
476 CHECK_STATIC_TLS (map
, sym_map
);
477 *reloc_addr
= sym
->st_value
- sym_map
->l_tls_offset
481 # ifndef RTLD_BOOTSTRAP
482 case R_SPARC_TLS_LE_HIX22
:
483 case R_SPARC_TLS_LE_LOX10
:
486 CHECK_STATIC_TLS (map
, sym_map
);
487 value
= sym
->st_value
- sym_map
->l_tls_offset
489 if (r_type
== R_SPARC_TLS_LE_HIX22
)
490 *reloc_addr
= (*reloc_addr
& 0xffc00000) | ((~value
) >> 10);
492 *reloc_addr
= (*reloc_addr
& 0xffffe000) | (value
& 0x3ff)
498 #ifndef RTLD_BOOTSTRAP
500 *(char *) reloc_addr
= value
;
503 *(short *) reloc_addr
= value
;
506 *(char *) reloc_addr
= (value
- (Elf32_Addr
) reloc_addr
);
509 *(short *) reloc_addr
= (value
- (Elf32_Addr
) reloc_addr
);
512 *reloc_addr
= (value
- (Elf32_Addr
) reloc_addr
);
515 *reloc_addr
= (*reloc_addr
& ~0x3ff) | (value
& 0x3ff);
517 case R_SPARC_WDISP30
:
518 *reloc_addr
= ((*reloc_addr
& 0xc0000000)
519 | ((value
- (unsigned int) reloc_addr
) >> 2));
522 *reloc_addr
= (*reloc_addr
& 0xffc00000) | (value
>> 10);
525 ((unsigned char *) reloc_addr_arg
) [0] = value
>> 8;
526 ((unsigned char *) reloc_addr_arg
) [1] = value
;
529 ((unsigned char *) reloc_addr_arg
) [0] = value
>> 24;
530 ((unsigned char *) reloc_addr_arg
) [1] = value
>> 16;
531 ((unsigned char *) reloc_addr_arg
) [2] = value
>> 8;
532 ((unsigned char *) reloc_addr_arg
) [3] = value
;
535 #if !defined RTLD_BOOTSTRAP || defined _NDEBUG
537 _dl_reloc_bad_type (map
, r_type
, 0);
544 __attribute__ ((always_inline
))
545 elf_machine_rela_relative (Elf32_Addr l_addr
, const Elf32_Rela
*reloc
,
546 void *const reloc_addr_arg
)
548 Elf32_Addr
*const reloc_addr
= reloc_addr_arg
;
549 *reloc_addr
+= l_addr
+ reloc
->r_addend
;
553 __attribute__ ((always_inline
))
554 elf_machine_lazy_rel (struct link_map
*map
,
555 Elf32_Addr l_addr
, const Elf32_Rela
*reloc
)
557 Elf32_Addr
*const reloc_addr
= (void *) (l_addr
+ reloc
->r_offset
);
558 const unsigned int r_type
= ELF32_R_TYPE (reloc
->r_info
);
560 if (__builtin_expect (r_type
== R_SPARC_JMP_SLOT
, 1))
562 else if (r_type
== R_SPARC_JMP_IREL
)
564 Elf32_Addr value
= map
->l_addr
+ reloc
->r_addend
;
565 value
= ((Elf32_Addr (*) (void)) value
) ();
566 sparc_fixup_plt (reloc
, reloc_addr
, value
, 1, 1);
568 else if (r_type
== R_SPARC_NONE
)
571 _dl_reloc_bad_type (map
, r_type
, 1);
574 #endif /* RESOLVE_MAP */