]>
git.ipfire.org Git - thirdparty/glibc.git/blob - sysdeps/sparc/sparc32/dl-machine.h
1 /* Machine-dependent ELF dynamic relocation inline functions. SPARC version.
2 Copyright (C) 1996-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
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 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
22 #define ELF_MACHINE_NAME "sparc"
25 #include <sys/param.h>
30 #include <elf/dl-hwcaps.h>
32 /* Return nonzero iff ELF header is compatible with the running host. */
34 elf_machine_matches_host (const Elf32_Ehdr
*ehdr
)
36 if (ehdr
->e_machine
== EM_SPARC
)
38 else if (ehdr
->e_machine
== EM_SPARC32PLUS
)
40 #if HAVE_TUNABLES || defined SHARED
41 uint64_t hwcap_mask
= GET_HWCAP_MASK();
42 return GLRO(dl_hwcap
) & hwcap_mask
& HWCAP_SPARC_V9
;
44 return GLRO(dl_hwcap
) & HWCAP_SPARC_V9
;
51 /* We have to do this because elf_machine_{dynamic,load_address} can be
52 invoked from functions that have no GOT references, and thus the compiler
53 has no obligation to load the PIC register. */
54 #define LOAD_PIC_REG(PIC_REG) \
55 do { register Elf32_Addr pc __asm("o7"); \
56 __asm("sethi %%hi(_GLOBAL_OFFSET_TABLE_-4), %1\n\t" \
58 "add %1, %%lo(_GLOBAL_OFFSET_TABLE_+4), %1\n" \
59 "1:\tadd %1, %0, %1" \
60 : "=r" (pc), "=r" (PIC_REG)); \
63 /* Return the link-time address of _DYNAMIC. Conveniently, this is the
64 first element of the GOT. This must be inlined in a function which
66 static inline Elf32_Addr
67 elf_machine_dynamic (void)
69 register Elf32_Addr
*got
asm ("%l7");
76 /* Return the run-time load address of the shared object. */
77 static inline Elf32_Addr
78 elf_machine_load_address (void)
80 register Elf32_Addr
*pc
__asm ("%o7"), *got
__asm ("%l7");
82 __asm ("sethi %%hi(_GLOBAL_OFFSET_TABLE_-4), %1\n\t"
84 " add %1, %%lo(_GLOBAL_OFFSET_TABLE_+4), %1\n\t"
86 "call _GLOBAL_OFFSET_TABLE_\n"
87 "1:\tadd %1, %0, %1\n\t" : "=r" (pc
), "=r" (got
));
89 /* got is now l_addr + _GLOBAL_OFFSET_TABLE_
91 pc[2]*4 is l_addr + _DYNAMIC - (long)pc - 8
92 pc[3]*4 is l_addr + _GLOBAL_OFFSET_TABLE_ - (long)pc - 12 */
93 return (Elf32_Addr
) got
- *got
+ (pc
[2] - pc
[3]) * 4 - 4;
96 /* Set up the loaded object described by L so its unrelocated PLT
97 entries will jump to the on-demand fixup code in dl-runtime.c. */
100 elf_machine_runtime_setup (struct link_map
*l
, struct r_scope_elem
*scope
[],
101 int lazy
, int profile
)
104 extern void _dl_runtime_resolve (Elf32_Word
);
105 extern void _dl_runtime_profile (Elf32_Word
);
107 if (l
->l_info
[DT_JMPREL
] && lazy
)
111 /* The entries for functions in the PLT have not yet been filled in.
112 Their initial contents will arrange when called to set the high 22
113 bits of %g1 with an offset into the .rela.plt section and jump to
114 the beginning of the PLT. */
115 plt
= (Elf32_Addr
*) D_PTR (l
, l_info
[DT_PLTGOT
]);
116 if (__builtin_expect(profile
, 0))
118 rfunc
= (Elf32_Addr
) &_dl_runtime_profile
;
120 if (GLRO(dl_profile
) != NULL
121 && _dl_name_match_p (GLRO(dl_profile
), l
))
122 GL(dl_profile_map
) = l
;
126 rfunc
= (Elf32_Addr
) &_dl_runtime_resolve
;
129 /* The beginning of the PLT does:
131 sethi %hi(_dl_runtime_{resolve,profile}), %g2
132 pltpc: jmpl %g2 + %lo(_dl_runtime_{resolve,profile}), %g2
136 The PC value (pltpc) saved in %g2 by the jmpl points near the
137 location where we store the link_map pointer for this object. */
139 plt
[0] = 0x05000000 | ((rfunc
>> 10) & 0x003fffff);
140 plt
[1] = 0x85c0a000 | (rfunc
& 0x3ff);
141 plt
[2] = OPCODE_NOP
; /* Fill call delay slot. */
142 plt
[3] = (Elf32_Addr
) l
;
143 if (__builtin_expect (l
->l_info
[VALIDX(DT_GNU_PRELINKED
)] != NULL
, 0)
144 || __builtin_expect (l
->l_info
[VALIDX (DT_GNU_LIBLISTSZ
)] != NULL
, 0))
146 /* Need to reinitialize .plt to undo prelinking. */
147 Elf32_Rela
*rela
= (Elf32_Rela
*) D_PTR (l
, l_info
[DT_JMPREL
]);
149 = (Elf32_Rela
*) ((char *) rela
150 + l
->l_info
[DT_PLTRELSZ
]->d_un
.d_val
);
151 #if !defined RTLD_BOOTSTRAP && !defined __sparc_v9__
152 /* Note that we don't mask the hwcap here, as the flush is
153 essential to functionality on those cpu's that implement it.
154 For sparcv9 we can assume flush is present. */
155 const int do_flush
= GLRO(dl_hwcap
) & HWCAP_SPARC_FLUSH
;
157 const int do_flush
= 1;
160 /* prelink must ensure there are no R_SPARC_NONE relocs left
162 while (rela
< relaend
)
164 *(unsigned int *) (rela
->r_offset
+ l
->l_addr
)
165 = OPCODE_SETHI_G1
| (rela
->r_offset
+ l
->l_addr
167 *(unsigned int *) (rela
->r_offset
+ l
->l_addr
+ 4)
168 = OPCODE_BA
| ((((Elf32_Addr
) plt
169 - rela
->r_offset
- l
->l_addr
- 4) >> 2)
173 __asm
__volatile ("flush %0" : : "r" (rela
->r_offset
175 __asm
__volatile ("flush %0+4" : : "r" (rela
->r_offset
186 /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry, so
187 PLT entries should not be allowed to define the value.
188 ELF_RTYPE_CLASS_COPY iff TYPE should not be allowed to resolve to one
189 of the main executable's symbols, as for a COPY reloc. */
190 #define elf_machine_type_class(type) \
191 ((((type) == R_SPARC_JMP_SLOT \
192 || ((type) >= R_SPARC_TLS_GD_HI22 && (type) <= R_SPARC_TLS_TPOFF64)) \
193 * ELF_RTYPE_CLASS_PLT) \
194 | (((type) == R_SPARC_COPY) * ELF_RTYPE_CLASS_COPY))
196 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries. */
197 #define ELF_MACHINE_JMP_SLOT R_SPARC_JMP_SLOT
199 /* The SPARC never uses Elf32_Rel relocations. */
200 #define ELF_MACHINE_NO_REL 1
201 #define ELF_MACHINE_NO_RELA 0
203 /* Undo the sub %sp, 6*4, %sp; add %sp, 22*4, %o0 below to get at the
204 value we want in __libc_stack_end. */
205 #define DL_STACK_END(cookie) \
206 ((void *) (((long) (cookie)) - (22 - 6) * 4))
208 /* Initial entry point code for the dynamic linker.
209 The C function `_dl_start' is the real entry point;
210 its return value is the user program's entry point. */
212 #define RTLD_GOT_ADDRESS(pic_reg, reg, symbol) \
213 "sethi %gdop_hix22(" #symbol "), " #reg "\n\t" \
214 "xor " #reg ", %gdop_lox10(" #symbol "), " #reg "\n\t" \
215 "ld [" #pic_reg " + " #reg "], " #reg ", %gdop(" #symbol ")"
217 #define RTLD_START __asm__ ("\
220 .type _start, @function\n\
223 /* Allocate space for functions to drop their arguments. */\n\
225 /* Pass pointer to argument block to _dl_start. */\n\
227 add %sp, 22*4, %o0\n\
229 .globl _dl_start_user\n\
230 .type _dl_start_user, @function\n\
232 /* Load the PIC register. */\n\
234 sethi %hi(_GLOBAL_OFFSET_TABLE_-(1b-.)), %l7\n\
235 2: or %l7, %lo(_GLOBAL_OFFSET_TABLE_-(1b-.)), %l7\n\
237 /* Save the user entry point address in %l0 */\n\
239 /* See if we were run as a command with the executable file name as an\n\
240 extra leading argument. If so, adjust the contents of the stack. */\n\
241 " RTLD_GOT_ADDRESS(%l7, %g2, _dl_skip_args) "\n\
245 ld [%sp+22*4], %i5 /* load argc */\n\
246 /* Find out how far to shift. */\n\
247 " RTLD_GOT_ADDRESS(%l7, %l3, _dl_argv) "\n\
251 st %i5, [%sp+22*4]\n\
253 add %sp, 23*4, %i1\n\
256 /* Copy down argv */\n\
263 /* Copy down env */\n\
270 /* Copy down auxiliary table. */\n\
279 /* %o0 = _dl_loaded, %o1 = argc, %o2 = argv, %o3 = envp. */\n\
280 3: " RTLD_GOT_ADDRESS(%l7, %o0, _rtld_local) "\n\
281 add %sp, 23*4, %o2\n\
288 /* Pass our finalizer function to the user in %g1. */\n\
289 " RTLD_GOT_ADDRESS(%l7, %g1, _dl_fini) "\n\
290 /* Jump to the user's entry point and deallocate the extra stack we got. */\n\
293 .size _dl_start_user, . - _dl_start_user\n\
296 static inline Elf32_Addr
297 elf_machine_fixup_plt (struct link_map
*map
, lookup_t t
,
298 const ElfW(Sym
) *refsym
, const ElfW(Sym
) *sym
,
299 const Elf32_Rela
*reloc
,
300 Elf32_Addr
*reloc_addr
, Elf32_Addr value
)
303 /* Sparc v9 can assume flush is always present. */
304 const int do_flush
= 1;
306 /* Note that we don't mask the hwcap here, as the flush is essential to
307 functionality on those cpu's that implement it. */
308 const int do_flush
= GLRO(dl_hwcap
) & HWCAP_SPARC_FLUSH
;
310 return sparc_fixup_plt (reloc
, reloc_addr
, value
, 1, do_flush
);
313 /* Return the final value of a plt relocation. */
314 static inline Elf32_Addr
315 elf_machine_plt_value (struct link_map
*map
, const Elf32_Rela
*reloc
,
318 return value
+ reloc
->r_addend
;
321 #endif /* dl_machine_h */
323 #define ARCH_LA_PLTENTER sparc32_gnu_pltenter
324 #define ARCH_LA_PLTEXIT sparc32_gnu_pltexit
328 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
329 MAP is the object containing the reloc. */
332 __attribute__ ((always_inline
))
333 elf_machine_rela (struct link_map
*map
, struct r_scope_elem
*scope
[],
334 const Elf32_Rela
*reloc
, const Elf32_Sym
*sym
,
335 const struct r_found_version
*version
,
336 void *const reloc_addr_arg
, int skip_ifunc
)
338 Elf32_Addr
*const reloc_addr
= reloc_addr_arg
;
339 #if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
340 const Elf32_Sym
*const refsym
= sym
;
343 const unsigned int r_type
= ELF32_R_TYPE (reloc
->r_info
);
344 #if !defined RESOLVE_CONFLICT_FIND_MAP
345 struct link_map
*sym_map
= NULL
;
348 #if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
349 /* This is defined in rtld.c, but nowhere in the static libc.a; make the
350 reference weak so static programs can still link. This declaration
351 cannot be done when compiling rtld.c (i.e. #ifdef RTLD_BOOTSTRAP)
352 because rtld.c contains the common defn for _dl_rtld_map, which is
353 incompatible with a weak decl in the same file. */
354 weak_extern (_dl_rtld_map
);
357 if (__glibc_unlikely (r_type
== R_SPARC_NONE
))
360 if (__glibc_unlikely (r_type
== R_SPARC_SIZE32
))
362 *reloc_addr
= sym
->st_size
+ reloc
->r_addend
;
366 #if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
367 if (__glibc_unlikely (r_type
== R_SPARC_RELATIVE
))
369 # if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
370 if (map
!= &_dl_rtld_map
) /* Already done in rtld itself. */
372 *reloc_addr
+= map
->l_addr
+ reloc
->r_addend
;
377 #ifndef RESOLVE_CONFLICT_FIND_MAP
378 if (__builtin_expect (ELF32_ST_BIND (sym
->st_info
) == STB_LOCAL
, 0)
379 && sym
->st_shndx
!= SHN_UNDEF
)
386 sym_map
= RESOLVE_MAP (map
, scope
, &sym
, version
, r_type
);
387 value
= SYMBOL_ADDRESS (sym_map
, sym
, true);
393 value
+= reloc
->r_addend
; /* Assume copy relocs have zero addend. */
396 && __builtin_expect (ELFW(ST_TYPE
) (sym
->st_info
) == STT_GNU_IFUNC
, 0)
397 && __builtin_expect (sym
->st_shndx
!= SHN_UNDEF
, 1)
398 && __builtin_expect (!skip_ifunc
, 1))
400 value
= ((Elf32_Addr (*) (int)) value
) (GLRO(dl_hwcap
));
405 #if !defined RTLD_BOOTSTRAP && !defined RESOLVE_CONFLICT_FIND_MAP
408 /* This can happen in trace mode if an object could not be
411 if (sym
->st_size
> refsym
->st_size
412 || (GLRO(dl_verbose
) && sym
->st_size
< refsym
->st_size
))
416 strtab
= (const void *) D_PTR (map
, l_info
[DT_STRTAB
]);
418 %s: Symbol `%s' has different size in shared object, consider re-linking\n",
419 RTLD_PROGNAME
, strtab
+ refsym
->st_name
);
421 memcpy (reloc_addr_arg
, (void *) value
,
422 MIN (sym
->st_size
, refsym
->st_size
));
425 case R_SPARC_GLOB_DAT
:
429 case R_SPARC_IRELATIVE
:
430 if (__glibc_likely (!skip_ifunc
))
431 value
= ((Elf32_Addr (*) (int)) value
) (GLRO(dl_hwcap
));
434 case R_SPARC_JMP_IREL
:
435 if (__glibc_likely (!skip_ifunc
))
436 value
= ((Elf32_Addr (*) (int)) value
) (GLRO(dl_hwcap
));
438 case R_SPARC_JMP_SLOT
:
440 #if !defined RTLD_BOOTSTRAP && !defined __sparc_v9__
441 /* Note that we don't mask the hwcap here, as the flush is
442 essential to functionality on those cpu's that implement
443 it. For sparcv9 we can assume flush is present. */
444 const int do_flush
= GLRO(dl_hwcap
) & HWCAP_SPARC_FLUSH
;
446 /* Unfortunately, this is necessary, so that we can ensure
447 ld.so will not execute corrupt PLT entry instructions. */
448 const int do_flush
= 1;
450 /* At this point we don't need to bother with thread safety,
451 so we can optimize the first instruction of .plt out. */
452 sparc_fixup_plt (reloc
, reloc_addr
, value
, 0, do_flush
);
455 #ifndef RESOLVE_CONFLICT_FIND_MAP
456 case R_SPARC_TLS_DTPMOD32
:
457 /* Get the information from the link map returned by the
460 *reloc_addr
= sym_map
->l_tls_modid
;
462 case R_SPARC_TLS_DTPOFF32
:
463 /* During relocation all TLS symbols are defined and used.
464 Therefore the offset is already correct. */
465 *reloc_addr
= (sym
== NULL
? 0 : sym
->st_value
) + reloc
->r_addend
;
467 case R_SPARC_TLS_TPOFF32
:
468 /* The offset is negative, forward from the thread pointer. */
469 /* We know the offset of object the symbol is contained in.
470 It is a negative value which will be added to the
474 CHECK_STATIC_TLS (map
, sym_map
);
475 *reloc_addr
= sym
->st_value
- sym_map
->l_tls_offset
479 # ifndef RTLD_BOOTSTRAP
480 case R_SPARC_TLS_LE_HIX22
:
481 case R_SPARC_TLS_LE_LOX10
:
484 CHECK_STATIC_TLS (map
, sym_map
);
485 value
= sym
->st_value
- sym_map
->l_tls_offset
487 if (r_type
== R_SPARC_TLS_LE_HIX22
)
488 *reloc_addr
= (*reloc_addr
& 0xffc00000) | ((~value
) >> 10);
490 *reloc_addr
= (*reloc_addr
& 0xffffe000) | (value
& 0x3ff)
496 #ifndef RTLD_BOOTSTRAP
498 *(char *) reloc_addr
= value
;
501 *(short *) reloc_addr
= value
;
504 *(char *) reloc_addr
= (value
- (Elf32_Addr
) reloc_addr
);
507 *(short *) reloc_addr
= (value
- (Elf32_Addr
) reloc_addr
);
510 *reloc_addr
= (value
- (Elf32_Addr
) reloc_addr
);
513 *reloc_addr
= (*reloc_addr
& ~0x3ff) | (value
& 0x3ff);
515 case R_SPARC_WDISP30
:
516 *reloc_addr
= ((*reloc_addr
& 0xc0000000)
517 | ((value
- (unsigned int) reloc_addr
) >> 2));
520 *reloc_addr
= (*reloc_addr
& 0xffc00000) | (value
>> 10);
523 ((unsigned char *) reloc_addr_arg
) [0] = value
>> 8;
524 ((unsigned char *) reloc_addr_arg
) [1] = value
;
527 ((unsigned char *) reloc_addr_arg
) [0] = value
>> 24;
528 ((unsigned char *) reloc_addr_arg
) [1] = value
>> 16;
529 ((unsigned char *) reloc_addr_arg
) [2] = value
>> 8;
530 ((unsigned char *) reloc_addr_arg
) [3] = value
;
533 #if !defined RTLD_BOOTSTRAP || defined _NDEBUG
535 _dl_reloc_bad_type (map
, r_type
, 0);
542 __attribute__ ((always_inline
))
543 elf_machine_rela_relative (Elf32_Addr l_addr
, const Elf32_Rela
*reloc
,
544 void *const reloc_addr_arg
)
546 Elf32_Addr
*const reloc_addr
= reloc_addr_arg
;
547 *reloc_addr
+= l_addr
+ reloc
->r_addend
;
551 __attribute__ ((always_inline
))
552 elf_machine_lazy_rel (struct link_map
*map
, struct r_scope_elem
*scope
[],
553 Elf32_Addr l_addr
, const Elf32_Rela
*reloc
,
556 Elf32_Addr
*const reloc_addr
= (void *) (l_addr
+ reloc
->r_offset
);
557 const unsigned int r_type
= ELF32_R_TYPE (reloc
->r_info
);
559 if (__glibc_likely (r_type
== R_SPARC_JMP_SLOT
))
561 else if (r_type
== R_SPARC_JMP_IREL
)
563 Elf32_Addr value
= map
->l_addr
+ reloc
->r_addend
;
564 if (__glibc_likely (!skip_ifunc
))
565 value
= ((Elf32_Addr (*) (int)) value
) (GLRO(dl_hwcap
));
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 */