mirror of
git://sourceware.org/git/glibc.git
synced 2024-12-21 04:31:04 +08:00
374 lines
11 KiB
C
374 lines
11 KiB
C
/* Machine-dependent ELF dynamic relocation inline functions. Alpha version.
|
|
Copyright (C) 1996 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by Richard Henderson <rht@tamu.edu>.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
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., 675 Mass Ave,
|
|
Cambridge, MA 02139, USA. */
|
|
|
|
/* This was written in the absense of an ABI -- don't expect
|
|
it to remain unchanged. */
|
|
|
|
#define ELF_MACHINE_NAME "alpha"
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <link.h>
|
|
|
|
|
|
/* Return nonzero iff E_MACHINE is compatible with the running host. */
|
|
static inline int
|
|
elf_machine_matches_host (Elf64_Word e_machine)
|
|
{
|
|
return e_machine == EM_ALPHA;
|
|
}
|
|
|
|
|
|
/* Return the run-time address of the _GLOBAL_OFFSET_TABLE_.
|
|
Must be inlined in a function which uses global data. */
|
|
static inline Elf64_Addr *
|
|
elf_machine_got (void)
|
|
{
|
|
register Elf64_Addr gp __asm__("$29");
|
|
return (Elf64_Addr *)(gp - 0x8000);
|
|
}
|
|
|
|
|
|
/* Return the run-time load address of the shared object. */
|
|
static inline Elf64_Addr
|
|
elf_machine_load_address (void)
|
|
{
|
|
/* NOTE: While it is generally unfriendly to put data in the text
|
|
segment, it is only slightly less so when the "data" is an
|
|
instruction. While we don't have to worry about GLD just yet, an
|
|
optimizing linker might decide that our "data" is an unreachable
|
|
instruction and throw it away -- with the right switches, DEC's
|
|
linker will do this. What ought to happen is we should add
|
|
something to GAS to allow us access to the new GPREL_HI32/LO32
|
|
relocation types stolen from OSF/1 3.0. */
|
|
/* This code relies on the fact that BRADDR relocations do not
|
|
appear in dynamic relocation tables. Not that that would be very
|
|
useful anyway -- br/bsr has a 4MB range and the shared libraries
|
|
are usually many many terabytes away. */
|
|
|
|
Elf64_Addr dot;
|
|
long zero_disp;
|
|
|
|
asm("br %0, 1f\n\t"
|
|
".weak __load_address_undefined\n\t"
|
|
"br $0, __load_address_undefined\n"
|
|
"1:"
|
|
: "=r"(dot));
|
|
|
|
zero_disp = *(int *)dot;
|
|
zero_disp = (zero_disp << 43) >> 41;
|
|
|
|
return dot + 4 + zero_disp;
|
|
}
|
|
|
|
|
|
/* Fix up the instructions of a PLT entry to invoke the function
|
|
rather than the dynamic linker. */
|
|
static inline void
|
|
elf_alpha_fix_plt(struct link_map *l,
|
|
const Elf64_Rela *reloc,
|
|
Elf64_Addr value)
|
|
{
|
|
const Elf64_Rela *rela_plt;
|
|
Elf64_Word *plte;
|
|
long disp;
|
|
|
|
/* Recover the PLT entry address by calculating reloc's index into the
|
|
.rela.plt, and finding that entry in the .plt. */
|
|
|
|
rela_plt = (void *)(l->l_addr + l->l_info[DT_JMPREL]->d_un.d_ptr);
|
|
|
|
plte = (void *)(l->l_addr + l->l_info[DT_PLTGOT]->d_un.d_ptr);
|
|
plte += 2*(reloc - rela_plt) + 8;
|
|
|
|
/* Find the displacement from the plt entry to the function. */
|
|
|
|
disp = value - (Elf64_Addr)&plte[2];
|
|
|
|
/* Change "lda $27, ofs($31)" to "ldq $27, ofs($gp)" */
|
|
plte[0] = 0xa77d0000 | (plte[0] & 0xffff);
|
|
|
|
if (disp >= -0x100000 && disp < 0x100000)
|
|
{
|
|
/* If we are in range, use br to perfect branch prediction and
|
|
elide the dependancy on the address load. This case happens,
|
|
e.g., when a shared library call is resolved to the same library. */
|
|
/* Change "br $0, plt0" to "br $31,function" */
|
|
plte[1] = 0xc3e00000 | (disp & 0x1fffff);
|
|
}
|
|
else
|
|
{
|
|
/* Don't bother with the hint since we already know the hint is
|
|
wrong. Eliding it prevents the wrong page from getting pulled
|
|
into the cache. */
|
|
/* Change "br $0, plt0" to "jmp $31,($27)" */
|
|
plte[1] = 0x6bfb0000;
|
|
}
|
|
|
|
/* Flush the instruction cache now that we've diddled. Tag it as
|
|
modifying memory to checkpoint memory writes during optimization. */
|
|
asm volatile("call_pal 0x86" : : : "memory");
|
|
}
|
|
|
|
/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
|
|
MAP is the object containing the reloc. */
|
|
static inline void
|
|
elf_machine_rela (struct link_map *map,
|
|
const Elf64_Rela *reloc,
|
|
const Elf64_Sym *sym,
|
|
Elf64_Addr (*resolve) (const Elf64_Sym **ref,
|
|
Elf64_Addr reloc_addr,
|
|
int noplt))
|
|
{
|
|
Elf64_Addr *const reloc_addr = (void *)(map->l_addr + reloc->r_offset);
|
|
unsigned long r_info = ELF64_R_TYPE (reloc->r_info);
|
|
|
|
/* We cannot use a switch here because we cannot locate the switch
|
|
jump table until we've self-relocated. */
|
|
|
|
if (r_info == R_ALPHA_RELATIVE)
|
|
{
|
|
/* Already done in dynamic linker. */
|
|
if (!resolve || map != &_dl_rtld_map)
|
|
*reloc_addr += map->l_addr;
|
|
}
|
|
else if (r_info == R_ALPHA_NONE)
|
|
;
|
|
else
|
|
{
|
|
Elf64_Addr loadbase, sym_value;
|
|
|
|
if (resolve)
|
|
{
|
|
loadbase = (*resolve)(&sym, (Elf64_Addr)reloc_addr,
|
|
r_info == R_ALPHA_JMP_SLOT);
|
|
}
|
|
else
|
|
loadbase = map->l_addr;
|
|
|
|
sym_value = sym ? loadbase + sym->st_value : 0;
|
|
|
|
if (r_info == R_ALPHA_GLOB_DAT)
|
|
{
|
|
*reloc_addr = sym_value;
|
|
}
|
|
else if (r_info == R_ALPHA_JMP_SLOT)
|
|
{
|
|
*reloc_addr = sym_value;
|
|
elf_alpha_fix_plt(map, reloc, sym_value);
|
|
}
|
|
else if (r_info == R_ALPHA_REFQUAD)
|
|
{
|
|
sym_value += *reloc_addr;
|
|
if (resolve && map == &_dl_rtld_map)
|
|
{
|
|
/* Undo the relocation done here during bootstrapping.
|
|
Now we will relocate anew, possibly using a binding
|
|
found in the user program or a loaded library rather
|
|
than the dynamic linker's built-in definitions used
|
|
while loading those libraries. */
|
|
const Elf64_Sym *const dlsymtab
|
|
= (void *)(map->l_addr + map->l_info[DT_SYMTAB]->d_un.d_ptr);
|
|
sym_value -= map->l_addr;
|
|
sym_value -= dlsymtab[ELF64_R_SYM(reloc->r_info)].st_value;
|
|
}
|
|
else
|
|
sym_value += reloc->r_addend;
|
|
*reloc_addr = sym_value;
|
|
}
|
|
else if (r_info == R_ALPHA_COPY)
|
|
memcpy (reloc_addr, (void *) sym_value, sym->st_size);
|
|
else
|
|
assert (! "unexpected dynamic reloc type");
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
elf_machine_lazy_rel (struct link_map *map, const Elf64_Rela *reloc)
|
|
{
|
|
Elf64_Addr *const reloc_addr = (void *)(map->l_addr + reloc->r_offset);
|
|
unsigned long r_info = ELF64_R_TYPE (reloc->r_info);
|
|
|
|
if (r_info == R_ALPHA_JMP_SLOT)
|
|
{
|
|
/* Perform a RELATIVE reloc on the .got entry that transfers
|
|
to the .plt. */
|
|
*reloc_addr += map->l_addr;
|
|
}
|
|
else if (r_info == R_ALPHA_NONE)
|
|
;
|
|
else
|
|
assert (! "unexpected PLT reloc type");
|
|
}
|
|
|
|
/* The alpha never uses Elf_Rel relocations. */
|
|
#define ELF_MACHINE_NO_REL 1
|
|
|
|
|
|
/* Set up the loaded object described by L so its unrelocated PLT
|
|
entries will jump to the on-demand fixup code in dl-runtime.c. */
|
|
|
|
static inline void
|
|
elf_machine_runtime_setup (struct link_map *l, int lazy)
|
|
{
|
|
Elf64_Addr plt;
|
|
extern void _dl_runtime_resolve (void);
|
|
|
|
if (l->l_info[DT_JMPREL] && lazy)
|
|
{
|
|
/* The GOT entries for the functions in the PLT have not been
|
|
filled in yet. Their initial contents are directed to the
|
|
PLT which arranges for the dynamic linker to be called. */
|
|
plt = l->l_addr + l->l_info[DT_PLTGOT]->d_un.d_ptr;
|
|
|
|
/* This function will be called to perform the relocation. */
|
|
*(Elf64_Addr *)(plt + 16) = (Elf64_Addr) &_dl_runtime_resolve;
|
|
|
|
/* Identify this shared object */
|
|
*(Elf64_Addr *)(plt + 24) = (Elf64_Addr) l;
|
|
}
|
|
}
|
|
|
|
/* This code is used in dl-runtime.c to call the `fixup' function
|
|
and then redirect to the address it returns. */
|
|
#define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ( \
|
|
"/* Trampoline for _dl_runtime_resolver */
|
|
.globl _dl_runtime_resolve
|
|
.ent _dl_runtime_resolve
|
|
_dl_runtime_resolve:
|
|
lda $sp, -168($sp)
|
|
.frame $sp, 168, $26
|
|
/* Preserve all registers that C normally doesn't. */
|
|
stq $26, 0($sp)
|
|
stq $0, 8($sp)
|
|
stq $1, 16($sp)
|
|
stq $2, 24($sp)
|
|
stq $3, 32($sp)
|
|
stq $4, 40($sp)
|
|
stq $5, 48($sp)
|
|
stq $6, 56($sp)
|
|
stq $7, 64($sp)
|
|
stq $8, 72($sp)
|
|
stq $16, 80($sp)
|
|
stq $17, 88($sp)
|
|
stq $18, 96($sp)
|
|
stq $19, 104($sp)
|
|
stq $20, 112($sp)
|
|
stq $21, 120($sp)
|
|
stq $22, 128($sp)
|
|
stq $23, 136($sp)
|
|
stq $24, 144($sp)
|
|
stq $25, 152($sp)
|
|
stq $29, 160($sp)
|
|
.mask 0x27ff01ff, -168
|
|
/* Set up our $gp */
|
|
br $gp, .+4
|
|
ldgp $gp, 0($gp)
|
|
.prologue 1
|
|
/* Set up the arguments for _dl_runtime_resolve. */
|
|
/* $16 = link_map out of plt0 */
|
|
ldq $16, 8($27)
|
|
/* $17 = (($0 - 8) - ($1 + 16)) / 8 * sizeof(Elf_Rela) */
|
|
subq $28, $27, $28
|
|
subq $28, 24, $28
|
|
addq $28, $28, $17
|
|
addq $28, $17, $17
|
|
/* Do the fixup */
|
|
bsr $26, fixup..ng
|
|
/* Move the destination address to a safe place. */
|
|
mov $0, $27
|
|
/* Restore program registers. */
|
|
ldq $26, 0($sp)
|
|
ldq $0, 8($sp)
|
|
ldq $1, 16($sp)
|
|
ldq $2, 24($sp)
|
|
ldq $3, 32($sp)
|
|
ldq $4, 40($sp)
|
|
ldq $5, 48($sp)
|
|
ldq $6, 56($sp)
|
|
ldq $7, 64($sp)
|
|
ldq $8, 72($sp)
|
|
ldq $16, 80($sp)
|
|
ldq $17, 88($sp)
|
|
ldq $18, 96($sp)
|
|
ldq $19, 104($sp)
|
|
ldq $20, 112($sp)
|
|
ldq $21, 120($sp)
|
|
ldq $22, 128($sp)
|
|
ldq $23, 136($sp)
|
|
ldq $24, 144($sp)
|
|
ldq $25, 152($sp)
|
|
ldq $29, 160($sp)
|
|
/* Clean up and turn control to the destination */
|
|
lda $sp, 168($sp)
|
|
jmp $31, ($27)
|
|
.end _dl_runtime_resolve");
|
|
|
|
/* The PLT uses Elf_Rel relocs. */
|
|
#define elf_machine_relplt elf_machine_rela
|
|
|
|
/* Mask identifying addresses reserved for the user program,
|
|
where the dynamic linker should not map anything. */
|
|
/* FIXME */
|
|
#define ELF_MACHINE_USER_ADDRESS_MASK (~0x1FFFFFFFFUL)
|
|
|
|
/* Initial entry point code for the dynamic linker.
|
|
The C function `_dl_start' is the real entry point;
|
|
its return value is the user program's entry point. */
|
|
|
|
#define RTLD_START asm ("\
|
|
.text
|
|
.globl _start
|
|
.globl _dl_start_user
|
|
_start:
|
|
br $gp,.+4
|
|
ldgp $gp, 0($gp)
|
|
/* Pass pointer to argument block to _dl_start. */
|
|
mov $sp, $16
|
|
bsr $26, _dl_start..ng
|
|
_dl_start_user:
|
|
/* Save the user entry point address in s0. */
|
|
mov $0, $9
|
|
/* See if we were run as a command with the executable file
|
|
name as an extra leading argument. If so, adjust the stack
|
|
pointer to skip _dl_skip_args words. */
|
|
ldl $1, _dl_skip_args
|
|
beq $1, 0f
|
|
ldq $2, 0($sp)
|
|
subq $2, $1, $2
|
|
s8addq $1, $sp, $sp
|
|
stq $2, 0($sp)
|
|
/* Load _dl_default_scope[2] into s1 to pass to _dl_init_next. */
|
|
0: ldq $10, _dl_default_scope+16
|
|
/* Call _dl_init_next to return the address of an initalizer
|
|
function to run. */
|
|
1: mov $10, $16
|
|
jsr $26, _dl_init_next
|
|
ldgp $gp, 0($26)
|
|
beq $0, 2f
|
|
mov $0, $27
|
|
jsr $26, ($0)
|
|
ldgp $gp, 0($26)
|
|
br 1b
|
|
2: /* Pass our finalizer function to the user in $0. */
|
|
lda $0, _dl_fini
|
|
/* Jump to the user's entry point. */
|
|
jmp ($9)");
|