]>
git.ipfire.org Git - thirdparty/glibc.git/blob - sysdeps/sh/dl-machine.h
1 /* Machine-dependent ELF dynamic relocation inline functions. SH version.
2 Copyright (C) 1999, 2000, 2001 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 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.
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.
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 not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
23 /* Only dummy. This doesn't work. */
25 #define ELF_MACHINE_NAME "SH"
27 #include <sys/param.h>
31 /* Return nonzero iff ELF header is compatible with the running host. */
32 static inline int __attribute__ ((unused
))
33 elf_machine_matches_host (const Elf32_Ehdr
*ehdr
)
35 return ehdr
->e_machine
== EM_SH
;
39 /* Return the link-time address of _DYNAMIC. Conveniently, this is the
40 first element of the GOT. This must be inlined in a function which
42 static inline Elf32_Addr
__attribute__ ((unused
))
43 elf_machine_dynamic (void)
45 register Elf32_Addr
*got
;
46 asm ("mov r12,%0" :"=r" (got
));
51 /* Return the run-time load address of the shared object. */
52 static inline Elf32_Addr
__attribute__ ((unused
))
53 elf_machine_load_address (void)
63 .L1: .long _dl_start@GOT
64 .L3: .long _dl_start@GOTOFF
66 : "=r" (addr
) : : "r0", "r1", "r2");
71 /* Set up the loaded object described by L so its unrelocated PLT
72 entries will jump to the on-demand fixup code in dl-runtime.c. */
74 static inline int __attribute__ ((unused
))
75 elf_machine_runtime_setup (struct link_map
*l
, int lazy
, int profile
)
78 extern void _dl_runtime_resolve (Elf32_Word
);
79 extern void _dl_runtime_profile (Elf32_Word
);
81 if (l
->l_info
[DT_JMPREL
] && lazy
)
83 /* The GOT entries for functions in the PLT have not yet been filled
84 in. Their initial contents will arrange when called to load an
85 offset into the .rela.plt section and _GLOBAL_OFFSET_TABLE_[1],
86 and then jump to _GLOBAL_OFFSET_TABLE[2]. */
87 got
= (Elf32_Addr
*) D_PTR (l
, l_info
[DT_PLTGOT
]);
88 got
[1] = (Elf32_Addr
) l
; /* Identify this shared object. */
90 /* The got[2] entry contains the address of a function which gets
91 called to get the address of a so far unresolved function and
92 jump to it. The profiling extension of the dynamic linker allows
93 to intercept the calls to collect information. In this case we
94 don't store the address in the GOT so that all future calls also
95 end in this function. */
98 got
[2] = (Elf32_Addr
) &_dl_runtime_profile
;
99 /* Say that we really want profiling and the timers are started. */
103 /* This function will get called to fix up the GOT entry indicated by
104 the offset on the stack, and then jump to the resolved address. */
105 got
[2] = (Elf32_Addr
) &_dl_runtime_resolve
;
110 /* This code is used in dl-runtime.c to call the `fixup' function
111 and then redirect to the address it returns. */
113 #define ELF_MACHINE_RUNTIME_FIXUP_ARGS int plt_type
120 add r0,r2 ! Get GOT address in r2
122 1: .long _GLOBAL_OFFSET_TABLE_
125 #define GOTJMP(x) #x "@GOTOFF"
162 # define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\
164 .globl _dl_runtime_resolve
165 .type _dl_runtime_resolve, @function
174 movt r3 ! Save T flag.
179 mov r2,r5 ! link map address
181 jsr @r0 ! Call resolver.
182 mov r1,r6 ! reloc offset
183 lds.l @r15+,pr ! Get register content back.
186 shal r3 ! Lode T flag.
192 jmp @r0 ! Jump to function address.
196 .long " GOTJMP (fixup) "
197 .size _dl_runtime_resolve, .-_dl_runtime_resolve
199 .globl _dl_runtime_profile
200 .type _dl_runtime_profile, @function
209 movt r3 ! Save T flag.
214 mov r2,r5 ! link map address
215 sts pr,r7 ! return address
217 jsr @r0 ! Call resolver.
218 mov r1,r6 ! reloc offset
219 lds.l @r15+,pr ! Get register content back.
222 shal r3 ! Lode T flag.
228 jmp @r0 ! Jump to function address.
232 .long " GOTJMP (profile_fixup) "
233 .size _dl_runtime_profile, .-_dl_runtime_profile
237 # define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\
239 .globl _dl_runtime_resolve
240 .globl _dl_runtime_profile
241 .type _dl_runtime_resolve, @function
242 .type _dl_runtime_profile, @function
252 movt r3 ! Save T flag.
257 mov r2,r5 ! link map address
258 sts pr,r7 ! return address
260 jsr @r0 ! Call resolver.
261 mov r1,r6 ! reloc offset
262 lds.l @r15+,pr ! Get register content back.
265 shal r3 ! Lode T flag.
271 jmp @r0 ! Jump to function address.
275 .long " GOTJMP (fixup) "
276 .size _dl_runtime_resolve, .-_dl_runtime_resolve
277 .size _dl_runtime_profile, .-_dl_runtime_profile
282 /* Mask identifying addresses reserved for the user program,
283 where the dynamic linker should not map anything. */
284 #define ELF_MACHINE_USER_ADDRESS_MASK 0x80000000UL
286 /* Initial entry point code for the dynamic linker.
287 The C function `_dl_start' is the real entry point;
288 its return value is the user program's entry point. */
290 #define RTLD_START asm ("\
293 .globl _dl_start_user\n\
296 mov.l .L_dl_start,r1\n\
297 mova .L_dl_start,r0\n\
302 ! Save the user entry point address in r8.\n\
304 ! Point r12 at the GOT.\n\
310 1: .long _GLOBAL_OFFSET_TABLE_\n\
311 2: ! Store the highest stack address\n\
312 mov.l .L_stack_end,r0\n\
313 mov.l @(r0,r12),r0\n\
315 ! See if we were run as a command with the executable file\n\
316 ! name as an extra leading argument.\n\
317 mov.l .L_dl_skip_args,r0\n\
318 mov.l @(r0,r12),r0\n\
320 ! Get the original argument count.\n\
322 ! Subtract _dl_skip_args from it.\n\
324 ! Adjust the stack pointer to skip _dl_skip_args words.\n\
327 ! Store back the modified argument count.\n\
329 ! Compute argv address and envp.\n\
335 mov.l .L_dl_loaded,r0\n\
336 mov.l @(r0,r12),r0\n\
339 mov.l .L_dl_init,r1\n\
340 mova .L_dl_init,r0\n\
344 1: ! Clear the startup flag.\n\
345 mov.l .L_dl_starting_up,r0\n\
346 mov.l @(r0,r12),r0\n\
349 ! Pass our finalizer function to the user in r4, as per ELF ABI.\n\
350 mov.l .L_dl_fini,r0\n\
351 mov.l @(r0,r12),r4\n\
352 ! Jump to the user's entry point.\n\
357 .long _dl_start@PLT\n\
359 .long __libc_stack_end@GOT\n\
361 .long _dl_skip_args@GOT\n\
363 .long _dl_init@PLT\n\
365 .long _dl_loaded@GOT\n\
366 .L_dl_starting_up:\n\
367 .long _dl_starting_up@GOT\n\
369 .long _dl_fini@GOT\n\
373 /* Nonzero iff TYPE should not be allowed to resolve to one of
374 the main executable's symbols, as for a COPY reloc. */
375 #define elf_machine_lookup_noexec_p(type) ((type) == R_SH_COPY)
377 /* Nonzero iff TYPE describes relocation of a PLT entry, so
378 PLT entries should not be allowed to define the value. */
379 #define elf_machine_lookup_noplt_p(type) ((type) == R_SH_JMP_SLOT)
381 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries. */
382 #define ELF_MACHINE_JMP_SLOT R_SH_JMP_SLOT
384 /* We define an initialization functions. This is called very early in
386 #define DL_PLATFORM_INIT dl_platform_init ()
388 extern const char *_dl_platform
;
390 static inline void __attribute__ ((unused
))
391 dl_platform_init (void)
393 if (_dl_platform
!= NULL
&& *_dl_platform
== '\0')
394 /* Avoid an empty string which would disturb us. */
398 static inline Elf32_Addr
399 elf_machine_fixup_plt (struct link_map
*map
, lookup_t t
,
400 const Elf32_Rela
*reloc
,
401 Elf32_Addr
*reloc_addr
, Elf32_Addr value
)
403 return *reloc_addr
= value
;
406 /* Return the final value of a plt relocation. */
407 static inline Elf32_Addr
408 elf_machine_plt_value (struct link_map
*map
, const Elf32_Rela
*reloc
,
411 return value
+ reloc
->r_addend
;
414 #endif /* !dl_machine_h */
418 /* SH never uses Elf32_Rel relocations. */
419 #define ELF_MACHINE_NO_REL 1
421 extern char **_dl_argv
;
423 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
424 MAP is the object containing the reloc. */
427 elf_machine_rela (struct link_map
*map
, const Elf32_Rela
*reloc
,
428 const Elf32_Sym
*sym
, const struct r_found_version
*version
,
429 Elf32_Addr
*const reloc_addr
)
431 if (ELF32_R_TYPE (reloc
->r_info
) == R_SH_RELATIVE
)
433 #ifndef RTLD_BOOTSTRAP
434 if (map
!= &_dl_rtld_map
) /* Already done in rtld itself. */
438 *reloc_addr
= map
->l_addr
+ reloc
->r_addend
;
440 *reloc_addr
+= map
->l_addr
;
443 else if (ELF32_R_TYPE (reloc
->r_info
) != R_SH_NONE
)
445 const Elf32_Sym
*const refsym
= sym
;
446 Elf32_Addr value
= RESOLVE (&sym
, version
, ELF32_R_TYPE (reloc
->r_info
));
448 value
+= sym
->st_value
;
449 value
+= reloc
->r_addend
;
451 switch (ELF32_R_TYPE (reloc
->r_info
))
455 /* This can happen in trace mode if an object could not be
458 if (sym
->st_size
> refsym
->st_size
459 || (sym
->st_size
< refsym
->st_size
&& _dl_verbose
))
463 strtab
= (const char *) D_PTR (map
, l_info
[DT_STRTAB
]);
465 %s: Symbol `%s' has different size in shared object, consider re-linking\n"
466 _dl_argv
[0] ?: "<program name unknown>",
467 strtab
+ refsym
->st_name
);
469 memcpy (reloc_addr
, (void *) value
, MIN (sym
->st_size
,
478 #ifndef RTLD_BOOTSTRAP
479 /* This is defined in rtld.c, but nowhere in the static
480 libc.a; make the reference weak so static programs can
481 still link. This declaration cannot be done when
482 compiling rtld.c (i.e. #ifdef RTLD_BOOTSTRAP) because
483 rtld.c contains the common defn for _dl_rtld_map, which
484 is incompatible with a weak decl in the same file. */
485 weak_extern (_dl_rtld_map
);
486 if (map
== &_dl_rtld_map
)
487 /* Undo the relocation done here during bootstrapping.
488 Now we will relocate it anew, possibly using a
489 binding found in the user program or a loaded library
490 rather than the dynamic linker's built-in definitions
491 used while loading those libraries. */
492 value
-= map
->l_addr
+ refsym
->st_value
+ reloc
->r_addend
;
498 *reloc_addr
= (value
- (Elf32_Addr
) reloc_addr
);
501 _dl_reloc_bad_type (map
, ELF32_R_TYPE (reloc
->r_info
), 0);
508 elf_machine_lazy_rel (struct link_map
*map
,
509 Elf32_Addr l_addr
, const Elf32_Rela
*reloc
)
511 Elf32_Addr
*const reloc_addr
= (void *) (l_addr
+ reloc
->r_offset
);
512 /* Check for unexpected PLT reloc type. */
513 if (ELF32_R_TYPE (reloc
->r_info
) == R_SH_JMP_SLOT
)
514 *reloc_addr
+= l_addr
;
516 _dl_reloc_bad_type (map
, ELF32_R_TYPE (reloc
->r_info
), 1);