-/* Machine-dependent ELF dynamic relocation inline functions.
+/* Machine-dependent ELF dynamic relocation inline functions.
PowerPC64 version.
- Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+ Copyright 1995-2015 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
- License along with the GNU C Library; see the file COPYING.LIB. If not,
- write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ License along with the GNU C Library; see the file COPYING.LIB. If
+ not, see <http://www.gnu.org/licenses/>. */
#ifndef dl_machine_h
#define dl_machine_h
#include <assert.h>
#include <sys/param.h>
+#include <dl-tls.h>
+#include <sysdep.h>
/* Translate a processor specific dynamic tag to the index
in l_info array. */
#define DT_PPC64(x) (DT_PPC64_##x - DT_LOPROC + DT_NUM)
+#if _CALL_ELF != 2
/* A PowerPC64 function descriptor. The .plt (procedure linkage
table) and .opd (official procedure descriptor) sections are
arrays of these. */
Elf64_Addr fd_toc;
Elf64_Addr fd_aux;
} Elf64_FuncDesc;
+#endif
#define ELF_MULT_MACHINES_SUPPORTED
static inline int
elf_machine_matches_host (const Elf64_Ehdr *ehdr)
{
+ /* Verify that the binary matches our ABI version. */
+ if ((ehdr->e_flags & EF_PPC64_ABI) != 0)
+ {
+#if _CALL_ELF != 2
+ if ((ehdr->e_flags & EF_PPC64_ABI) != 1)
+ return 0;
+#else
+ if ((ehdr->e_flags & EF_PPC64_ABI) != 2)
+ return 0;
+#endif
+ }
+
return ehdr->e_machine == EM_PPC64;
}
/* The PLT uses Elf64_Rela relocs. */
#define elf_machine_relplt elf_machine_rela
-/* This code gets called via a .glink stub which loads PLT0. It is
- used in dl-runtime.c to call the `fixup' function and then redirect
- to the address `fixup' returns.
-
- Enter with r0 = plt reloc index,
- r2 = ld.so tocbase,
- r11 = ld.so link map. */
-
-#define TRAMPOLINE_TEMPLATE(tramp_name, fixup_name) \
- asm (".section \".text\"\n" \
-" .align 2\n" \
-" .globl ." #tramp_name "\n" \
-" .type ." #tramp_name ",@function\n" \
-" .section \".opd\",\"aw\"\n" \
-" .align 3\n" \
-" .globl " #tramp_name "\n" \
-" .size " #tramp_name ",24\n" \
-#tramp_name ":\n" \
-" .quad ." #tramp_name ",.TOC.@tocbase,0\n" \
-" .previous\n" \
-"." #tramp_name ":\n" \
-/* We need to save the registers used to pass parameters, ie. r3 thru \
- r10; the registers are saved in a stack frame. */ \
-" stdu 1,-128(1)\n" \
-" std 3,48(1)\n" \
-" mr 3,11\n" \
-" std 4,56(1)\n" \
-" sldi 4,0,1\n" \
-" std 5,64(1)\n" \
-" add 4,4,0\n" \
-" std 6,72(1)\n" \
-" sldi 4,4,3\n" \
-" std 7,80(1)\n" \
-" mflr 0\n" \
-" std 8,88(1)\n" \
-/* Store the LR in the LR Save area of the previous frame. */ \
-" std 0,128+16(1)\n" \
-" mfcr 0\n" \
-" std 9,96(1)\n" \
-" std 10,104(1)\n" \
-/* I'm almost certain we don't have to save cr... be safe. */ \
-" std 0,8(1)\n" \
-" bl ." #fixup_name "\n" \
-/* Put the registers back. */ \
-" ld 0,128+16(1)\n" \
-" ld 10,104(1)\n" \
-" ld 9,96(1)\n" \
-" ld 8,88(1)\n" \
-" ld 7,80(1)\n" \
-" mtlr 0\n" \
-" ld 0,8(1)\n" \
-" ld 6,72(1)\n" \
-" ld 5,64(1)\n" \
-" ld 4,56(1)\n" \
-" mtcrf 0xFF,0\n" \
-/* Load the target address, toc and static chain reg from the function \
- descriptor returned by fixup. */ \
-" ld 0,0(3)\n" \
-" ld 2,8(3)\n" \
-" mtctr 0\n" \
-" ld 11,16(3)\n" \
-" ld 3,48(1)\n" \
-/* Unwind the stack frame, and jump. */ \
-" addi 1,1,128\n" \
-" bctr\n" \
-".LT_" #tramp_name ":\n" \
-" .long 0\n" \
-" .byte 0x00,0x0c,0x24,0x40,0x00,0x00,0x00,0x00\n" \
-" .long .LT_" #tramp_name "-."#tramp_name "\n" \
-" .short .LT_" #tramp_name "_name_end-.LT_" #tramp_name "_name_start\n" \
-".LT_" #tramp_name "_name_start:\n" \
-" .ascii \"" #tramp_name "\"\n" \
-".LT_" #tramp_name "_name_end:\n" \
-" .align 2\n" \
-" .size ." #tramp_name ",. - ." #tramp_name "\n" \
-" .previous");
-#ifndef PROF
-#define ELF_MACHINE_RUNTIME_TRAMPOLINE \
- TRAMPOLINE_TEMPLATE (_dl_runtime_resolve, fixup); \
- TRAMPOLINE_TEMPLATE (_dl_profile_resolve, profile_fixup);
+#ifdef HAVE_INLINED_SYSCALLS
+/* We do not need _dl_starting_up. */
+# define DL_STARTING_UP_DEF
#else
-#define ELF_MACHINE_RUNTIME_TRAMPOLINE \
- TRAMPOLINE_TEMPLATE (_dl_runtime_resolve, fixup); \
- void _dl_runtime_resolve (void); \
- strong_alias (_dl_runtime_resolve, _dl_profile_resolve);
+# define DL_STARTING_UP_DEF \
+".LC__dl_starting_up:\n" \
+" .tc __GI__dl_starting_up[TC],__GI__dl_starting_up\n"
#endif
`_dl_start' is the real entry point; its return value is the user
program's entry point. */
#define RTLD_START \
- asm (".section \".text\"\n" \
+ asm (".pushsection \".text\"\n" \
" .align 2\n" \
-" .globl ._start\n" \
-" .type ._start,@function\n" \
-" .section \".opd\",\"aw\"\n" \
-" .align 3\n" \
-" .globl _start\n" \
-" .size _start,24\n" \
-"_start:\n" \
-" .quad ._start,.TOC.@tocbase,0\n" \
-" .previous\n" \
-"._start:\n" \
+" " ENTRY_2(_start) "\n" \
+BODY_PREFIX "_start:\n" \
+" " LOCALENTRY(_start) "\n" \
/* We start with the following on the stack, from top: \
argc (4 bytes); \
arguments for program (terminated by NULL); \
" li 4,0\n" \
" stdu 4,-128(1)\n" \
/* Call _dl_start with one parameter pointing at argc. */ \
-" bl ._dl_start\n" \
+" bl " DOT_PREFIX "_dl_start\n" \
" nop\n" \
/* Transfer control to _dl_start_user! */ \
-" b ._dl_start_user\n" \
-".LT__start:\n" \
-" .long 0\n" \
+" b " DOT_PREFIX "_dl_start_user\n" \
+".LT__start:\n" \
+" .long 0\n" \
" .byte 0x00,0x0c,0x24,0x40,0x00,0x00,0x00,0x00\n" \
-" .long .LT__start-._start\n" \
+" .long .LT__start-" BODY_PREFIX "_start\n" \
" .short .LT__start_name_end-.LT__start_name_start\n" \
".LT__start_name_start:\n" \
" .ascii \"_start\"\n" \
".LT__start_name_end:\n" \
" .align 2\n" \
-" .size ._start,.-._start\n" \
-" .globl _dl_start_user\n" \
-" .section \".opd\",\"aw\"\n" \
-"_dl_start_user:\n" \
-" .quad ._dl_start_user, .TOC.@tocbase, 0\n" \
-" .previous\n" \
-" .globl ._dl_start_user\n" \
-" .type ._dl_start_user,@function\n" \
-/* Now, we do our main work of calling initialisation procedures. \
- The ELF ABI doesn't say anything about parameters for these, \
- so we just pass argc, argv, and the environment. \
- Changing these is strongly discouraged (not least because argc is \
- passed by value!). */ \
-"._dl_start_user:\n" \
+" " END_2(_start) "\n" \
+" .pushsection \".toc\",\"aw\"\n" \
+DL_STARTING_UP_DEF \
+".LC__rtld_local:\n" \
+" .tc _rtld_local[TC],_rtld_local\n" \
+".LC__dl_argc:\n" \
+" .tc _dl_argc[TC],_dl_argc\n" \
+".LC__dl_argv:\n" \
+" .tc __GI__dl_argv[TC],__GI__dl_argv\n" \
+".LC__dl_fini:\n" \
+" .tc _dl_fini[TC],_dl_fini\n" \
+" .popsection\n" \
+" " ENTRY_2(_dl_start_user) "\n" \
+/* Now, we do our main work of calling initialisation procedures. \
+ The ELF ABI doesn't say anything about parameters for these, \
+ so we just pass argc, argv, and the environment. \
+ Changing these is strongly discouraged (not least because argc is \
+ passed by value!). */ \
+BODY_PREFIX "_dl_start_user:\n" \
+" " LOCALENTRY(_dl_start_user) "\n" \
/* the address of _start in r30. */ \
" mr 30,3\n" \
/* &_dl_argc in 29, &_dl_argv in 27, and _dl_loaded in 28. */ \
-" ld 28,_rtld_global@got(2)\n" \
-" ld 29,_dl_argc@got(2)\n" \
-" ld 27,_dl_argv@got(2)\n" \
+" ld 28,.LC__rtld_local@toc(2)\n" \
+" ld 29,.LC__dl_argc@toc(2)\n" \
+" ld 27,.LC__dl_argv@toc(2)\n" \
/* _dl_init (_dl_loaded, _dl_argc, _dl_argv, _dl_argv+_dl_argc+1). */ \
" ld 3,0(28)\n" \
" lwa 4,0(29)\n" \
" sldi 6,4,3\n" \
" add 6,5,6\n" \
" addi 6,6,8\n" \
-" bl ._dl_init\n" \
+" bl " DOT_PREFIX "_dl_init\n" \
" nop\n" \
/* Now, to conform to the ELF ABI, we have to: \
Pass argc (actually _dl_argc) in r3; */ \
" sldi 5,3,3\n" \
" add 6,4,5\n" \
" addi 5,6,8\n" \
-/* Pass the auxilary vector in r6. This is passed to us just after \
+/* Pass the auxiliary vector in r6. This is passed to us just after \
_envp. */ \
"2: ldu 0,8(6)\n" \
" cmpdi 0,0\n" \
" addi 6,6,8\n" \
/* Pass a termination function pointer (in this case _dl_fini) in \
r7. */ \
-" ld 7,_dl_fini@got(2)\n" \
-" ld 26,_dl_starting_up@got(2)\n" \
+" ld 7,.LC__dl_fini@toc(2)\n" \
/* Pass the stack pointer in r1 (so far so good), pointing to a NULL \
value. This lets our startup code distinguish between a program \
linked statically, which linux will call with argc on top of the \
stack which will hopefully never be zero, and a dynamically linked \
program which will always have a NULL on the top of the stack. \
- Take the opportunity to clear LR, so anyone who accidentally \
+ Take the opportunity to clear LR, so anyone who accidentally \
returns from _start gets SEGV. Also clear the next few words of \
the stack. */ \
" li 31,0\n" \
" std 31,8(1)\n" \
" std 31,16(1)\n" \
" std 31,24(1)\n" \
-/* Clear _dl_starting_up. */ \
-" stw 31,0(26)\n" \
/* Now, call the start function descriptor at r30... */ \
-" .globl ._dl_main_dispatch\n" \
-"._dl_main_dispatch:\n" \
-" ld 0,0(30)\n" \
-" ld 2,8(30)\n" \
-" mtctr 0\n" \
-" ld 11,16(30)\n" \
+" .globl ._dl_main_dispatch\n" \
+"._dl_main_dispatch:\n" \
+" " PPC64_LOAD_FUNCPTR(30) "\n" \
" bctr\n" \
-".LT__dl_start_user:\n" \
+".LT__dl_start_user:\n" \
" .long 0\n" \
" .byte 0x00,0x0c,0x24,0x40,0x00,0x00,0x00,0x00\n" \
-" .long .LT__dl_start_user-._dl_start_user\n" \
+" .long .LT__dl_start_user-" BODY_PREFIX "_dl_start_user\n" \
" .short .LT__dl_start_user_name_end-.LT__dl_start_user_name_start\n" \
".LT__dl_start_user_name_start:\n" \
" .ascii \"_dl_start_user\"\n" \
".LT__dl_start_user_name_end:\n" \
" .align 2\n" \
-" .size ._dl_start_user,.-._dl_start_user\n" \
-" .previous");
-
-/* Nonzero iff TYPE should not be allowed to resolve to one of
- the main executable's symbols, as for a COPY reloc. */
-#define elf_machine_lookup_noexec_p(type) ((type) == R_PPC64_COPY)
-
-/* Nonzero iff TYPE describes relocation of a PLT entry, so
- PLT entries should not be allowed to define the value. */
-#define elf_machine_lookup_noplt_p(type) ((type) == R_PPC64_JMP_SLOT)
+" " END_2(_dl_start_user) "\n" \
+" .popsection");
+
+/* ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to
+ one of the main executable's symbols, as for a COPY reloc.
+
+ To make function pointer comparisons work on most targets, the
+ relevant ABI states that the address of a non-local function in a
+ dynamically linked executable is the address of the PLT entry for
+ that function. This is quite reasonable since using the real
+ function address in a non-PIC executable would typically require
+ dynamic relocations in .text, something to be avoided. For such
+ functions, the linker emits a SHN_UNDEF symbol in the executable
+ with value equal to the PLT entry address. Normally, SHN_UNDEF
+ symbols have a value of zero, so this is a clue to ld.so that it
+ should treat these symbols specially. For relocations not in
+ ELF_RTYPE_CLASS_PLT (eg. those on function pointers), ld.so should
+ use the value of the executable SHN_UNDEF symbol, ie. the PLT entry
+ address. For relocations in ELF_RTYPE_CLASS_PLT (eg. the relocs in
+ the PLT itself), ld.so should use the value of the corresponding
+ defined symbol in the object that defines the function, ie. the
+ real function address. This complicates ld.so in that there are
+ now two possible values for a given symbol, and it gets even worse
+ because protected symbols need yet another set of rules.
+
+ On PowerPC64 we don't need any of this. The linker won't emit
+ SHN_UNDEF symbols with non-zero values. ld.so can make all
+ relocations behave "normally", ie. always use the real address
+ like PLT relocations. So always set ELF_RTYPE_CLASS_PLT. */
+
+#if _CALL_ELF != 2
+#define elf_machine_type_class(type) \
+ (ELF_RTYPE_CLASS_PLT | (((type) == R_PPC64_COPY) * ELF_RTYPE_CLASS_COPY))
+#else
+/* And now that you have read that large comment, you can disregard it
+ all for ELFv2. ELFv2 does need the special SHN_UNDEF treatment. */
+#define IS_PPC64_TLS_RELOC(R) \
+ (((R) >= R_PPC64_TLS && (R) <= R_PPC64_DTPREL16_HIGHESTA) \
+ || ((R) >= R_PPC64_TPREL16_HIGH && (R) <= R_PPC64_DTPREL16_HIGHA))
-/* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry, so
- PLT entries should not be allowed to define the value.
- ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to one
- of the main executable's symbols, as for a COPY reloc. */
#define elf_machine_type_class(type) \
- ((((type) == R_PPC64_ADDR24) * ELF_RTYPE_CLASS_PLT) \
+ ((((type) == R_PPC64_JMP_SLOT \
+ || (type) == R_PPC64_ADDR24 \
+ || IS_PPC64_TLS_RELOC (type)) * ELF_RTYPE_CLASS_PLT) \
| (((type) == R_PPC64_COPY) * ELF_RTYPE_CLASS_COPY))
+#endif
/* A reloc type used for ld.so cmdline arg lookups to reject PLT entries. */
#define ELF_MACHINE_JMP_SLOT R_PPC64_JMP_SLOT
/* The PowerPC never uses REL relocations. */
#define ELF_MACHINE_NO_REL 1
+#define ELF_MACHINE_NO_RELA 0
/* Stuff for the PLT. */
+#if _CALL_ELF != 2
#define PLT_INITIAL_ENTRY_WORDS 3
+#define PLT_ENTRY_WORDS 3
+#define GLINK_INITIAL_ENTRY_WORDS 8
+/* The first 32k entries of glink can set an index and branch using two
+ instructions; past that point, glink uses three instructions. */
+#define GLINK_ENTRY_WORDS(I) (((I) < 0x8000)? 2 : 3)
+#else
+#define PLT_INITIAL_ENTRY_WORDS 2
+#define PLT_ENTRY_WORDS 1
#define GLINK_INITIAL_ENTRY_WORDS 8
+#define GLINK_ENTRY_WORDS(I) 1
+#endif
#define PPC_DCBST(where) asm volatile ("dcbst 0,%0" : : "r"(where) : "memory")
+#define PPC_DCBT(where) asm volatile ("dcbt 0,%0" : : "r"(where) : "memory")
+#define PPC_DCBF(where) asm volatile ("dcbf 0,%0" : : "r"(where) : "memory")
#define PPC_SYNC asm volatile ("sync" : : : "memory")
#define PPC_ISYNC asm volatile ("sync; isync" : : : "memory")
#define PPC_ICBI(where) asm volatile ("icbi 0,%0" : : "r"(where) : "memory")
/* Set up the loaded object described by MAP so its unrelocated PLT
entries will jump to the on-demand fixup code in dl-runtime.c. */
-static inline int
+static inline int __attribute__ ((always_inline))
elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
{
if (map->l_info[DT_JMPREL])
/* Relocate the DT_PPC64_GLINK entry in the _DYNAMIC section.
elf_get_dynamic_info takes care of the standard entries but
- doesn't know exactly what to do with processor specific
- entires. */
+ doesn't know exactly what to do with processor specific
+ entries. */
if (info[DT_PPC64(GLINK)] != NULL)
info[DT_PPC64(GLINK)]->d_un.d_ptr += l_addr;
if (lazy)
{
- /* The function descriptor of the appropriate trampline
- routine is used to set the 1st and 2nd doubleword of the
- plt_reserve. */
- Elf64_FuncDesc *resolve_fd;
Elf64_Word glink_offset;
- /* the plt_reserve area is the 1st 3 doublewords of the PLT */
- Elf64_FuncDesc *plt_reserve = (Elf64_FuncDesc *) plt;
Elf64_Word offset;
+ Elf64_Addr dlrr;
- resolve_fd = (Elf64_FuncDesc *) (profile ? _dl_profile_resolve
- : _dl_runtime_resolve);
- if (profile && _dl_name_match_p (GL(dl_profile), map))
+ dlrr = (Elf64_Addr) (profile ? _dl_profile_resolve
+ : _dl_runtime_resolve);
+ if (profile && GLRO(dl_profile) != NULL
+ && _dl_name_match_p (GLRO(dl_profile), map))
/* This is the object we are looking for. Say that we really
want profiling and the timers are started. */
GL(dl_profile_map) = map;
-
+#if _CALL_ELF != 2
/* We need to stuff the address/TOC of _dl_runtime_resolve
into doublewords 0 and 1 of plt_reserve. Then we need to
stuff the map address into doubleword 2 of plt_reserve.
This allows the GLINK0 code to transfer control to the
correct trampoline which will transfer control to fixup
in dl-machine.c. */
- plt_reserve->fd_func = resolve_fd->fd_func;
- plt_reserve->fd_toc = resolve_fd->fd_toc;
- plt_reserve->fd_aux = (Elf64_Addr) map;
+ {
+ /* The plt_reserve area is the 1st 3 doublewords of the PLT. */
+ Elf64_FuncDesc *plt_reserve = (Elf64_FuncDesc *) plt;
+ Elf64_FuncDesc *resolve_fd = (Elf64_FuncDesc *) dlrr;
+ plt_reserve->fd_func = resolve_fd->fd_func;
+ plt_reserve->fd_toc = resolve_fd->fd_toc;
+ plt_reserve->fd_aux = (Elf64_Addr) map;
#ifdef RTLD_BOOTSTRAP
- /* When we're bootstrapping, the opd entry will not have
- been relocated yet. */
- plt_reserve->fd_func += l_addr;
- plt_reserve->fd_toc += l_addr;
+ /* When we're bootstrapping, the opd entry will not have
+ been relocated yet. */
+ plt_reserve->fd_func += l_addr;
+ plt_reserve->fd_toc += l_addr;
+#endif
+ }
+#else
+ /* When we don't have function descriptors, the first doubleword
+ of the PLT holds the address of _dl_runtime_resolve, and the
+ second doubleword holds the map address. */
+ plt[0] = dlrr;
+ plt[1] = (Elf64_Addr) map;
#endif
-
+
/* Set up the lazy PLT entries. */
glink = (Elf64_Word *) D_PTR (map, l_info[DT_PPC64(GLINK)]);
offset = PLT_INITIAL_ENTRY_WORDS;
{
plt[offset] = (Elf64_Xword) &glink[glink_offset];
- offset += 3;
- /* The first 32k entries of glink can set an index and
- branch using two instructions; Past that point,
- glink uses three instructions. */
- if (i < 0x8000)
- glink_offset += 2;
- else
- glink_offset += 3;
+ offset += PLT_ENTRY_WORDS;
+ glink_offset += GLINK_ENTRY_WORDS (i);
}
/* Now, we've modified data. We need to write the changes from
return lazy;
}
+#if _CALL_ELF == 2
+/* If the PLT entry whose reloc is 'reloc' resolves to a function in
+ the same object, return the target function's local entry point
+ offset if usable. */
+static inline Elf64_Addr __attribute__ ((always_inline))
+ppc64_local_entry_offset (struct link_map *map, lookup_t sym_map,
+ const Elf64_Rela *reloc)
+{
+ const Elf64_Sym *symtab;
+ const Elf64_Sym *sym;
+
+ /* If the target function is in a different object, we cannot
+ use the local entry point. */
+ if (sym_map != map)
+ return 0;
+
+ /* If the linker inserted multiple TOCs, we cannot use the
+ local entry point. */
+ if (map->l_info[DT_PPC64(OPT)]
+ && (map->l_info[DT_PPC64(OPT)]->d_un.d_val & PPC64_OPT_MULTI_TOC))
+ return 0;
+
+ /* Otherwise, we can use the local entry point. Retrieve its offset
+ from the symbol's ELF st_other field. */
+ symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
+ sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
+
+ /* If the target function is an ifunc then the local entry offset is
+ for the resolver, not the final destination. */
+ if (__builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
+ return 0;
+
+ return PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
+}
+#endif
+
/* Change the PLT entry whose reloc is 'reloc' to call the actual
routine. */
-static inline Elf64_Addr
+static inline Elf64_Addr __attribute__ ((always_inline))
elf_machine_fixup_plt (struct link_map *map, lookup_t sym_map,
const Elf64_Rela *reloc,
Elf64_Addr *reloc_addr, Elf64_Addr finaladdr)
{
+#if _CALL_ELF != 2
Elf64_FuncDesc *plt = (Elf64_FuncDesc *) reloc_addr;
Elf64_FuncDesc *rel = (Elf64_FuncDesc *) finaladdr;
Elf64_Addr offset = 0;
-#ifndef RTLD_BOOTSTRAP
- weak_extern (GL(dl_rtld_map));
-#endif
+
+ PPC_DCBT (&plt->fd_aux);
+ PPC_DCBT (&plt->fd_func);
+ PPC_DCBT (&rel->fd_aux);
+ PPC_DCBT (&rel->fd_func);
/* If sym_map is NULL, it's a weak undefined sym; Leave the plt zero. */
if (sym_map == NULL)
/* If the opd entry is not yet relocated (because it's from a shared
object that hasn't been processed yet), then manually reloc it. */
if (map != sym_map && !sym_map->l_relocated
-#ifndef RTLD_BOOTSTRAP
+#if !defined RTLD_BOOTSTRAP && defined SHARED
/* Bootstrap map doesn't have l_relocated set for it. */
&& sym_map != &GL(dl_rtld_map)
#endif
plt->fd_aux = rel->fd_aux + offset;
plt->fd_toc = rel->fd_toc + offset;
- PPC_DCBST (&plt->fd_aux);
- PPC_DCBST (&plt->fd_toc);
- PPC_SYNC;
+ PPC_DCBF (&plt->fd_toc);
+ PPC_ISYNC;
plt->fd_func = rel->fd_func + offset;
PPC_DCBST (&plt->fd_func);
- PPC_SYNC;
+ PPC_ISYNC;
+#else
+ finaladdr += ppc64_local_entry_offset (map, sym_map, reloc);
+ *reloc_addr = finaladdr;
+#endif
return finaladdr;
}
+static inline void __attribute__ ((always_inline))
+elf_machine_plt_conflict (struct link_map *map, lookup_t sym_map,
+ const Elf64_Rela *reloc,
+ Elf64_Addr *reloc_addr, Elf64_Addr finaladdr)
+{
+#if _CALL_ELF != 2
+ Elf64_FuncDesc *plt = (Elf64_FuncDesc *) reloc_addr;
+ Elf64_FuncDesc *rel = (Elf64_FuncDesc *) finaladdr;
+
+ plt->fd_func = rel->fd_func;
+ plt->fd_aux = rel->fd_aux;
+ plt->fd_toc = rel->fd_toc;
+ PPC_DCBST (&plt->fd_func);
+ PPC_DCBST (&plt->fd_aux);
+ PPC_DCBST (&plt->fd_toc);
+ PPC_SYNC;
+#else
+ finaladdr += ppc64_local_entry_offset (map, sym_map, reloc);
+ *reloc_addr = finaladdr;
+#endif
+}
+
/* Return the final value of a plt relocation. */
static inline Elf64_Addr
elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
{
return value + reloc->r_addend;
}
-
+
+
+/* Names of the architecture-specific auditing callback functions. */
+#if _CALL_ELF != 2
+#define ARCH_LA_PLTENTER ppc64_gnu_pltenter
+#define ARCH_LA_PLTEXIT ppc64_gnu_pltexit
+#else
+#define ARCH_LA_PLTENTER ppc64v2_gnu_pltenter
+#define ARCH_LA_PLTEXIT ppc64v2_gnu_pltexit
+#endif
+
#endif /* dl_machine_h */
#ifdef RESOLVE_MAP
#define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
#define PPC_HIGHEST(v) (((v) >> 48) & 0xffff)
#define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
-#define BIT_INSERT(old, val, mask) ((old & ~(Elf64_Addr) mask) | (val & mask))
+#define BIT_INSERT(var, val, mask) \
+ ((var) = ((var) & ~(Elf64_Addr) (mask)) | ((val) & (mask)))
#define dont_expect(X) __builtin_expect ((X), 0)
extern void _dl_reloc_overflow (struct link_map *map,
- const char *name,
- Elf64_Addr *const reloc_addr,
- const Elf64_Sym *sym,
- const Elf64_Sym *refsym)
- attribute_hidden;
+ const char *name,
+ Elf64_Addr *const reloc_addr,
+ const Elf64_Sym *refsym)
+ attribute_hidden;
-static inline void
+auto inline void __attribute__ ((always_inline))
elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
- Elf64_Addr *const reloc_addr)
+ void *const reloc_addr_arg)
{
+ Elf64_Addr *const reloc_addr = reloc_addr_arg;
*reloc_addr = l_addr + reloc->r_addend;
-}
+}
+
+/* This computes the value used by TPREL* relocs. */
+auto inline Elf64_Addr __attribute__ ((always_inline, const))
+elf_machine_tprel (struct link_map *map,
+ struct link_map *sym_map,
+ const Elf64_Sym *sym,
+ const Elf64_Rela *reloc)
+{
+#ifndef RTLD_BOOTSTRAP
+ if (sym_map)
+ {
+ CHECK_STATIC_TLS (map, sym_map);
+#endif
+ return TLS_TPREL_VALUE (sym_map, sym, reloc);
+#ifndef RTLD_BOOTSTRAP
+ }
+#endif
+ return 0;
+}
+
+/* Call function at address VALUE (an OPD entry) to resolve ifunc relocs. */
+auto inline Elf64_Addr __attribute__ ((always_inline))
+resolve_ifunc (Elf64_Addr value,
+ const struct link_map *map, const struct link_map *sym_map)
+{
+#if _CALL_ELF != 2
+#ifndef RESOLVE_CONFLICT_FIND_MAP
+ /* The function we are calling may not yet have its opd entry relocated. */
+ Elf64_FuncDesc opd;
+ if (map != sym_map
+# if !defined RTLD_BOOTSTRAP && defined SHARED
+ /* Bootstrap map doesn't have l_relocated set for it. */
+ && sym_map != &GL(dl_rtld_map)
+# endif
+ && !sym_map->l_relocated)
+ {
+ Elf64_FuncDesc *func = (Elf64_FuncDesc *) value;
+ opd.fd_func = func->fd_func + sym_map->l_addr;
+ opd.fd_toc = func->fd_toc + sym_map->l_addr;
+ opd.fd_aux = func->fd_aux;
+ value = (Elf64_Addr) &opd;
+ }
+#endif
+#endif
+ return ((Elf64_Addr (*) (unsigned long int)) value) (GLRO(dl_hwcap));
+}
/* Perform the relocation specified by RELOC and SYM (which is fully
resolved). MAP is the object containing the reloc. */
-static inline void
+auto inline void __attribute__ ((always_inline))
elf_machine_rela (struct link_map *map,
const Elf64_Rela *reloc,
const Elf64_Sym *sym,
const struct r_found_version *version,
- Elf64_Addr *const reloc_addr)
+ void *const reloc_addr_arg,
+ int skip_ifunc)
{
- int r_type = ELF64_R_TYPE (reloc->r_info);
- struct link_map *sym_map;
- Elf64_Addr value;
-#ifndef RTLD_BOOTSTRAP
+ Elf64_Addr *const reloc_addr = reloc_addr_arg;
+ const int r_type = ELF64_R_TYPE (reloc->r_info);
const Elf64_Sym *const refsym = sym;
- /* This is defined in rtld.c, but nowhere in the static libc.a; make the
- reference weak so static programs can still link. This declaration
- cannot be done when compiling rtld.c (i.e. #ifdef RTLD_BOOTSTRAP)
- because rtld.c contains the common defn for _dl_rtld_map, which is
- incompatible with a weak decl in the same file. */
- weak_extern (GL(dl_rtld_map));
-#endif
+ union unaligned
+ {
+ uint16_t u2;
+ uint32_t u4;
+ uint64_t u8;
+ } __attribute__ ((__packed__));
if (r_type == R_PPC64_RELATIVE)
{
-#ifndef RTLD_BOOTSTRAP
- /* Already done in dynamic linker. */
- if (map != &GL(dl_rtld_map))
-#endif
- *reloc_addr = map->l_addr + reloc->r_addend;
+ *reloc_addr = map->l_addr + reloc->r_addend;
return;
}
- if (r_type == R_PPC64_NONE)
+ if (__glibc_unlikely (r_type == R_PPC64_NONE))
return;
- sym_map = RESOLVE_MAP (&sym, version, r_type);
- value = 0;
- if (sym_map)
- {
- if (sym)
- value = sym_map->l_addr + sym->st_value;
- value += reloc->r_addend;
- }
+ /* We need SYM_MAP even in the absence of TLS, for elf_machine_fixup_plt
+ and STT_GNU_IFUNC. */
+ struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
+ Elf64_Addr value = ((sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value)
+ + reloc->r_addend);
+ if (sym != NULL
+ && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0)
+ && __builtin_expect (sym->st_shndx != SHN_UNDEF, 1)
+ && __builtin_expect (!skip_ifunc, 1))
+ value = resolve_ifunc (value, map, sym_map);
+
+ /* For relocs that don't edit code, return.
+ For relocs that might edit instructions, break from the switch. */
switch (r_type)
{
case R_PPC64_ADDR64:
*reloc_addr = value;
return;
- case R_PPC64_JMP_SLOT:
+ case R_PPC64_IRELATIVE:
+ if (__glibc_likely (!skip_ifunc))
+ value = resolve_ifunc (value, map, sym_map);
+ *reloc_addr = value;
+ return;
+ case R_PPC64_JMP_IREL:
+ if (__glibc_likely (!skip_ifunc))
+ value = resolve_ifunc (value, map, sym_map);
+ /* Fall thru */
+ case R_PPC64_JMP_SLOT:
+#ifdef RESOLVE_CONFLICT_FIND_MAP
+ elf_machine_plt_conflict (map, sym_map, reloc, reloc_addr, value);
+#else
elf_machine_fixup_plt (map, sym_map, reloc, reloc_addr, value);
+#endif
+ return;
+
+ case R_PPC64_DTPMOD64:
+#ifdef RTLD_BOOTSTRAP
+ /* During startup the dynamic linker is always index 1. */
+ *reloc_addr = 1;
+#else
+ /* Get the information from the link map returned by the
+ resolve function. */
+ if (sym_map != NULL)
+ *reloc_addr = sym_map->l_tls_modid;
+#endif
+ return;
+
+ case R_PPC64_DTPREL64:
+ /* During relocation all TLS symbols are defined and used.
+ Therefore the offset is already correct. */
+#ifndef RTLD_BOOTSTRAP
+ if (sym_map != NULL)
+ *reloc_addr = TLS_DTPREL_VALUE (sym, reloc);
+#endif
+ return;
+
+ case R_PPC64_TPREL64:
+ *reloc_addr = elf_machine_tprel (map, sym_map, sym, reloc);
return;
+ case R_PPC64_TPREL16_LO_DS:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ if (dont_expect ((value & 3) != 0))
+ _dl_reloc_overflow (map, "R_PPC64_TPREL16_LO_DS", reloc_addr, refsym);
+ BIT_INSERT (*(Elf64_Half *) reloc_addr, value, 0xfffc);
+ break;
+
+ case R_PPC64_TPREL16_DS:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
+ _dl_reloc_overflow (map, "R_PPC64_TPREL16_DS", reloc_addr, refsym);
+ BIT_INSERT (*(Elf64_Half *) reloc_addr, value, 0xfffc);
+ break;
+
+ case R_PPC64_TPREL16:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ if (dont_expect ((value + 0x8000) >= 0x10000))
+ _dl_reloc_overflow (map, "R_PPC64_TPREL16", reloc_addr, refsym);
+ *(Elf64_Half *) reloc_addr = PPC_LO (value);
+ break;
+
+ case R_PPC64_TPREL16_LO:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ *(Elf64_Half *) reloc_addr = PPC_LO (value);
+ break;
+
+ case R_PPC64_TPREL16_HI:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ if (dont_expect (value + 0x80000000 >= 0x100000000LL))
+ _dl_reloc_overflow (map, "R_PPC64_TPREL16_HI", reloc_addr, refsym);
+ *(Elf64_Half *) reloc_addr = PPC_HI (value);
+ break;
+
+ case R_PPC64_TPREL16_HIGH:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ *(Elf64_Half *) reloc_addr = PPC_HI (value);
+ break;
+
+ case R_PPC64_TPREL16_HA:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ if (dont_expect (value + 0x80008000 >= 0x100000000LL))
+ _dl_reloc_overflow (map, "R_PPC64_TPREL16_HA", reloc_addr, refsym);
+ *(Elf64_Half *) reloc_addr = PPC_HA (value);
+ break;
+
+ case R_PPC64_TPREL16_HIGHA:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ *(Elf64_Half *) reloc_addr = PPC_HA (value);
+ break;
+
+ case R_PPC64_TPREL16_HIGHER:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ *(Elf64_Half *) reloc_addr = PPC_HIGHER (value);
+ break;
+
+ case R_PPC64_TPREL16_HIGHEST:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ *(Elf64_Half *) reloc_addr = PPC_HIGHEST (value);
+ break;
+
+ case R_PPC64_TPREL16_HIGHERA:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ *(Elf64_Half *) reloc_addr = PPC_HIGHERA (value);
+ break;
+
+ case R_PPC64_TPREL16_HIGHESTA:
+ value = elf_machine_tprel (map, sym_map, sym, reloc);
+ *(Elf64_Half *) reloc_addr = PPC_HIGHESTA (value);
+ break;
+
#ifndef RTLD_BOOTSTRAP /* None of the following appear in ld.so */
case R_PPC64_ADDR16_LO_DS:
if (dont_expect ((value & 3) != 0))
- _dl_reloc_overflow (map, "R_PPC64_ADDR16_LO_DS",
- reloc_addr, sym, refsym);
- *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
- value, 0xfffc);
+ _dl_reloc_overflow (map, "R_PPC64_ADDR16_LO_DS", reloc_addr, refsym);
+ BIT_INSERT (*(Elf64_Half *) reloc_addr, value, 0xfffc);
break;
case R_PPC64_ADDR16_LO:
break;
case R_PPC64_ADDR16_HI:
+ if (dont_expect (value + 0x80000000 >= 0x100000000LL))
+ _dl_reloc_overflow (map, "R_PPC64_ADDR16_HI", reloc_addr, refsym);
+ case R_PPC64_ADDR16_HIGH:
*(Elf64_Half *) reloc_addr = PPC_HI (value);
break;
case R_PPC64_ADDR16_HA:
+ if (dont_expect (value + 0x80008000 >= 0x100000000LL))
+ _dl_reloc_overflow (map, "R_PPC64_ADDR16_HA", reloc_addr, refsym);
+ case R_PPC64_ADDR16_HIGHA:
*(Elf64_Half *) reloc_addr = PPC_HA (value);
break;
- case R_PPC64_REL24:
+ case R_PPC64_ADDR30:
{
- Elf64_Addr delta = value - (Elf64_Xword) reloc_addr;
- if (dont_expect ((delta + 0x2000000) >= 0x4000000 || (delta & 3) != 0))
- _dl_reloc_overflow (map, "R_PPC64_REL24", reloc_addr, sym, refsym);
- *(Elf64_Word *) reloc_addr = BIT_INSERT (*(Elf64_Word *) reloc_addr,
- delta, 0x3fffffc);
+ Elf64_Addr delta = value - (Elf64_Xword) reloc_addr;
+ if (dont_expect ((delta + 0x80000000) >= 0x100000000LL
+ || (delta & 3) != 0))
+ _dl_reloc_overflow (map, "R_PPC64_ADDR30", reloc_addr, refsym);
+ BIT_INSERT (*(Elf64_Word *) reloc_addr, delta, 0xfffffffc);
}
break;
case R_PPC64_COPY:
if (dont_expect (sym == NULL))
- /* This can happen in trace mode when an object could not be found. */
- return;
+ /* This can happen in trace mode when an object could not be found. */
+ return;
if (dont_expect (sym->st_size > refsym->st_size
- || (GL(dl_verbose) && sym->st_size < refsym->st_size)))
- {
- const char *strtab;
-
- strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
- _dl_error_printf ("%s: Symbol `%s' has different size" \
- " in shared object," \
- " consider re-linking\n",
- _dl_argv[0] ?: "<program name unknown>",
- strtab + refsym->st_name);
- }
- memcpy (reloc_addr, (char *) value, MIN (sym->st_size, refsym->st_size));
+ || (GLRO(dl_verbose)
+ && sym->st_size < refsym->st_size)))
+ {
+ const char *strtab;
+
+ strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
+ _dl_error_printf ("%s: Symbol `%s' has different size" \
+ " in shared object," \
+ " consider re-linking\n",
+ RTLD_PROGNAME, strtab + refsym->st_name);
+ }
+ memcpy (reloc_addr_arg, (char *) value,
+ MIN (sym->st_size, refsym->st_size));
return;
case R_PPC64_UADDR64:
- /* We are big-endian. */
- ((char *) reloc_addr)[0] = (value >> 56) & 0xff;
- ((char *) reloc_addr)[1] = (value >> 48) & 0xff;
- ((char *) reloc_addr)[2] = (value >> 40) & 0xff;
- ((char *) reloc_addr)[3] = (value >> 32) & 0xff;
- ((char *) reloc_addr)[4] = (value >> 24) & 0xff;
- ((char *) reloc_addr)[5] = (value >> 16) & 0xff;
- ((char *) reloc_addr)[6] = (value >> 8) & 0xff;
- ((char *) reloc_addr)[7] = (value >> 0) & 0xff;
+ ((union unaligned *) reloc_addr)->u8 = value;
return;
case R_PPC64_UADDR32:
- /* We are big-endian. */
- ((char *) reloc_addr)[0] = (value >> 24) & 0xff;
- ((char *) reloc_addr)[1] = (value >> 16) & 0xff;
- ((char *) reloc_addr)[2] = (value >> 8) & 0xff;
- ((char *) reloc_addr)[3] = (value >> 0) & 0xff;
+ ((union unaligned *) reloc_addr)->u4 = value;
+ return;
+
+ case R_PPC64_ADDR32:
+ if (dont_expect ((value + 0x80000000) >= 0x100000000LL))
+ _dl_reloc_overflow (map, "R_PPC64_ADDR32", reloc_addr, refsym);
+ *(Elf64_Word *) reloc_addr = value;
return;
case R_PPC64_ADDR24:
if (dont_expect ((value + 0x2000000) >= 0x4000000 || (value & 3) != 0))
- _dl_reloc_overflow (map, "R_PPC64_ADDR24", reloc_addr, sym, refsym);
- *(Elf64_Word *) reloc_addr = BIT_INSERT (*(Elf64_Word *) reloc_addr,
- value, 0x3fffffc);
+ _dl_reloc_overflow (map, "R_PPC64_ADDR24", reloc_addr, refsym);
+ BIT_INSERT (*(Elf64_Word *) reloc_addr, value, 0x3fffffc);
break;
case R_PPC64_ADDR16:
if (dont_expect ((value + 0x8000) >= 0x10000))
- _dl_reloc_overflow (map, "R_PPC64_ADDR16", reloc_addr, sym, refsym);
+ _dl_reloc_overflow (map, "R_PPC64_ADDR16", reloc_addr, refsym);
*(Elf64_Half *) reloc_addr = value;
break;
case R_PPC64_UADDR16:
if (dont_expect ((value + 0x8000) >= 0x10000))
- _dl_reloc_overflow (map, "R_PPC64_UADDR16", reloc_addr, sym, refsym);
- /* We are big-endian. */
- ((char *) reloc_addr)[0] = (value >> 8) & 0xff;
- ((char *) reloc_addr)[1] = (value >> 0) & 0xff;
- break;
+ _dl_reloc_overflow (map, "R_PPC64_UADDR16", reloc_addr, refsym);
+ ((union unaligned *) reloc_addr)->u2 = value;
+ return;
case R_PPC64_ADDR16_DS:
if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
- _dl_reloc_overflow (map, "R_PPC64_ADDR16_DS", reloc_addr, sym, refsym);
- *(Elf64_Half *) reloc_addr = BIT_INSERT (*(Elf64_Half *) reloc_addr,
- value, 0xfffc);
+ _dl_reloc_overflow (map, "R_PPC64_ADDR16_DS", reloc_addr, refsym);
+ BIT_INSERT (*(Elf64_Half *) reloc_addr, value, 0xfffc);
break;
case R_PPC64_ADDR16_HIGHER:
case R_PPC64_ADDR14_BRTAKEN:
case R_PPC64_ADDR14_BRNTAKEN:
{
- Elf64_Word insn;
- if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
- _dl_reloc_overflow (map, "R_PPC64_ADDR14", reloc_addr, sym, refsym);
- insn = BIT_INSERT (*(Elf64_Word *) reloc_addr, value, 0xfffc);
- if (r_type != R_PPC64_ADDR14)
- {
- insn &= ~(1 << 21);
- if (r_type == R_PPC64_ADDR14_BRTAKEN)
- insn |= 1 << 21;
- if ((insn & (0x14 << 21)) == (0x04 << 21))
- insn |= 0x02 << 21;
- else if ((insn & (0x14 << 21)) == (0x10 << 21))
- insn |= 0x08 << 21;
- }
- *(Elf64_Word *) reloc_addr = insn;
+ if (dont_expect ((value + 0x8000) >= 0x10000 || (value & 3) != 0))
+ _dl_reloc_overflow (map, "R_PPC64_ADDR14", reloc_addr, refsym);
+ Elf64_Word insn = *(Elf64_Word *) reloc_addr;
+ BIT_INSERT (insn, value, 0xfffc);
+ if (r_type != R_PPC64_ADDR14)
+ {
+ insn &= ~(1 << 21);
+ if (r_type == R_PPC64_ADDR14_BRTAKEN)
+ insn |= 1 << 21;
+ if ((insn & (0x14 << 21)) == (0x04 << 21))
+ insn |= 0x02 << 21;
+ else if ((insn & (0x14 << 21)) == (0x10 << 21))
+ insn |= 0x08 << 21;
+ }
+ *(Elf64_Word *) reloc_addr = insn;
}
break;
case R_PPC64_REL32:
- *(Elf64_Word *) reloc_addr = value - (Elf64_Xword) reloc_addr;
+ *(Elf64_Word *) reloc_addr = value - (Elf64_Addr) reloc_addr;
+ return;
+
+ case R_PPC64_REL64:
+ *reloc_addr = value - (Elf64_Addr) reloc_addr;
return;
#endif /* !RTLD_BOOTSTRAP */
MODIFIED_CODE_NOQUEUE (reloc_addr);
}
-static inline void
+auto inline void __attribute__ ((always_inline))
elf_machine_lazy_rel (struct link_map *map,
- Elf64_Addr l_addr, const Elf64_Rela *reloc)
+ Elf64_Addr l_addr, const Elf64_Rela *reloc,
+ int skip_ifunc)
{
/* elf_machine_runtime_setup handles this. */
}
+
#endif /* RESOLVE */