rtld support for PowerPC. Mostly obtained from NetBSD, with mods
for binutils 2.13 Reviewed by: benno Approved by: re (blanket)
This commit is contained in:
parent
8238b87b55
commit
b9dea67fa8
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=107572
1
libexec/rtld-elf/powerpc/Makefile.inc
Normal file
1
libexec/rtld-elf/powerpc/Makefile.inc
Normal file
@ -0,0 +1 @@
|
||||
# $FreeBSD$
|
169
libexec/rtld-elf/powerpc/lockdflt.c
Normal file
169
libexec/rtld-elf/powerpc/lockdflt.c
Normal file
@ -0,0 +1,169 @@
|
||||
/*-
|
||||
* Copyright 1999, 2000 John D. Polstra.
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* from: FreeBSD: src/libexec/rtld-elf/alpha/lockdflt.c,v 1.6 2000/07/17
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Thread locking implementation for the dynamic linker.
|
||||
*
|
||||
* We use the "simple, non-scalable reader-preference lock" from:
|
||||
*
|
||||
* J. M. Mellor-Crummey and M. L. Scott. "Scalable Reader-Writer
|
||||
* Synchronization for Shared-Memory Multiprocessors." 3rd ACM Symp. on
|
||||
* Principles and Practice of Parallel Programming, April 1991.
|
||||
*
|
||||
* In this algorithm the lock is a single word. Its low-order bit is
|
||||
* set when a writer holds the lock. The remaining high-order bits
|
||||
* contain a count of readers desiring the lock. The algorithm requires
|
||||
* atomic "compare_and_store" and "add" operations, which we implement
|
||||
* using assembly language sequences in "rtld_start.S".
|
||||
*/
|
||||
|
||||
#include <signal.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
|
||||
#include <machine/atomic.h>
|
||||
|
||||
#include "debug.h"
|
||||
#include "rtld.h"
|
||||
#include "rtld_machdep.h"
|
||||
|
||||
#define WAFLAG 0x1 /* A writer holds the lock */
|
||||
#define RC_INCR 0x2 /* Adjusts count of readers desiring lock */
|
||||
|
||||
typedef struct Struct_Lock {
|
||||
volatile int lock;
|
||||
void *base;
|
||||
} Lock;
|
||||
|
||||
static sigset_t fullsigmask, oldsigmask;
|
||||
|
||||
static void *
|
||||
lock_create(void *context)
|
||||
{
|
||||
void *base;
|
||||
char *p;
|
||||
uintptr_t r;
|
||||
Lock *l;
|
||||
|
||||
/*
|
||||
* Arrange for the lock to occupy its own cache line. First, we
|
||||
* optimistically allocate just a cache line, hoping that malloc
|
||||
* will give us a well-aligned block of memory. If that doesn't
|
||||
* work, we allocate a larger block and take a well-aligned cache
|
||||
* line from it.
|
||||
*/
|
||||
base = xmalloc(CACHE_LINE_SIZE);
|
||||
p = (char *)base;
|
||||
if ((uintptr_t)p % CACHE_LINE_SIZE != 0) {
|
||||
free(base);
|
||||
base = xmalloc(2 * CACHE_LINE_SIZE);
|
||||
p = (char *)base;
|
||||
if ((r = (uintptr_t)p % CACHE_LINE_SIZE) != 0)
|
||||
p += CACHE_LINE_SIZE - r;
|
||||
}
|
||||
l = (Lock *)p;
|
||||
l->base = base;
|
||||
l->lock = 0;
|
||||
return l;
|
||||
}
|
||||
|
||||
static void
|
||||
lock_destroy(void *lock)
|
||||
{
|
||||
Lock *l = (Lock *)lock;
|
||||
|
||||
free(l->base);
|
||||
}
|
||||
|
||||
static void
|
||||
rlock_acquire(void *lock)
|
||||
{
|
||||
Lock *l = (Lock *)lock;
|
||||
|
||||
atomic_add_acq_int(&l->lock, RC_INCR);
|
||||
while (l->lock & WAFLAG)
|
||||
; /* Spin */
|
||||
}
|
||||
|
||||
static void
|
||||
wlock_acquire(void *lock)
|
||||
{
|
||||
Lock *l = (Lock *)lock;
|
||||
sigset_t tmp_oldsigmask;
|
||||
|
||||
for ( ; ; ) {
|
||||
sigprocmask(SIG_BLOCK, &fullsigmask, &tmp_oldsigmask);
|
||||
if (atomic_cmpset_acq_int(&l->lock, 0, WAFLAG))
|
||||
break;
|
||||
sigprocmask(SIG_SETMASK, &tmp_oldsigmask, NULL);
|
||||
}
|
||||
oldsigmask = tmp_oldsigmask;
|
||||
}
|
||||
|
||||
static void
|
||||
rlock_release(void *lock)
|
||||
{
|
||||
Lock *l = (Lock *)lock;
|
||||
|
||||
atomic_add_rel_int(&l->lock, -RC_INCR);
|
||||
}
|
||||
|
||||
static void
|
||||
wlock_release(void *lock)
|
||||
{
|
||||
Lock *l = (Lock *)lock;
|
||||
|
||||
atomic_add_rel_int(&l->lock, -WAFLAG);
|
||||
sigprocmask(SIG_SETMASK, &oldsigmask, NULL);
|
||||
}
|
||||
|
||||
void
|
||||
lockdflt_init(LockInfo *li)
|
||||
{
|
||||
li->context = NULL;
|
||||
li->lock_create = lock_create;
|
||||
li->rlock_acquire = rlock_acquire;
|
||||
li->wlock_acquire = wlock_acquire;
|
||||
li->rlock_release = rlock_release;
|
||||
li->wlock_release = wlock_release;
|
||||
li->lock_destroy = lock_destroy;
|
||||
li->context_destroy = NULL;
|
||||
/*
|
||||
* Construct a mask to block all signals except traps which might
|
||||
* conceivably be generated within the dynamic linker itself.
|
||||
*/
|
||||
sigfillset(&fullsigmask);
|
||||
sigdelset(&fullsigmask, SIGILL);
|
||||
sigdelset(&fullsigmask, SIGTRAP);
|
||||
sigdelset(&fullsigmask, SIGABRT);
|
||||
sigdelset(&fullsigmask, SIGEMT);
|
||||
sigdelset(&fullsigmask, SIGFPE);
|
||||
sigdelset(&fullsigmask, SIGBUS);
|
||||
sigdelset(&fullsigmask, SIGSEGV);
|
||||
sigdelset(&fullsigmask, SIGSYS);
|
||||
}
|
495
libexec/rtld-elf/powerpc/reloc.c
Normal file
495
libexec/rtld-elf/powerpc/reloc.c
Normal file
@ -0,0 +1,495 @@
|
||||
/* $NetBSD: ppc_reloc.c,v 1.10 2001/09/10 06:09:41 mycroft Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (C) 1998 Tsubai Masanari
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the author may not be used to endorse or promote products
|
||||
* derived from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <machine/cpu.h>
|
||||
|
||||
#include "debug.h"
|
||||
#include "rtld.h"
|
||||
|
||||
#define _ppc_ha(x) ((((u_int32_t)(x) & 0x8000) ? \
|
||||
((u_int32_t)(x) + 0x10000) : (u_int32_t)(x)) >> 16)
|
||||
#define _ppc_la(x) ((u_int32_t)(x) & 0xffff)
|
||||
|
||||
/*
|
||||
* Process the R_PPC_COPY relocations
|
||||
*/
|
||||
int
|
||||
do_copy_relocations(Obj_Entry *dstobj)
|
||||
{
|
||||
const Elf_Rela *relalim;
|
||||
const Elf_Rela *rela;
|
||||
|
||||
/*
|
||||
* COPY relocs are invalid outside of the main program
|
||||
*/
|
||||
assert(dstobj->mainprog);
|
||||
|
||||
relalim = (const Elf_Rela *) ((caddr_t) dstobj->rela +
|
||||
dstobj->relasize);
|
||||
for (rela = dstobj->rela; rela < relalim; rela++) {
|
||||
void *dstaddr;
|
||||
const Elf_Sym *dstsym;
|
||||
const char *name;
|
||||
unsigned long hash;
|
||||
size_t size;
|
||||
const void *srcaddr;
|
||||
const Elf_Sym *srcsym = NULL;
|
||||
Obj_Entry *srcobj;
|
||||
|
||||
if (ELF_R_TYPE(rela->r_info) != R_PPC_COPY) {
|
||||
continue;
|
||||
}
|
||||
|
||||
dstaddr = (void *) (dstobj->relocbase + rela->r_offset);
|
||||
dstsym = dstobj->symtab + ELF_R_SYM(rela->r_info);
|
||||
name = dstobj->strtab + dstsym->st_name;
|
||||
hash = elf_hash(name);
|
||||
size = dstsym->st_size;
|
||||
|
||||
for (srcobj = dstobj->next; srcobj != NULL;
|
||||
srcobj = srcobj->next) {
|
||||
if ((srcsym = symlook_obj(name, hash, srcobj, false))
|
||||
!= NULL) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (srcobj == NULL) {
|
||||
_rtld_error("Undefined symbol \"%s\" "
|
||||
" referenced from COPY"
|
||||
" relocation in %s", name, dstobj->path);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
srcaddr = (const void *) (srcobj->relocbase+srcsym->st_value);
|
||||
memcpy(dstaddr, srcaddr, size);
|
||||
dbg("copy_reloc: src=%p,dst=%p,size=%d\n",srcaddr,dstaddr,size);
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Perform early relocation of the run-time linker image
|
||||
*/
|
||||
void
|
||||
reloc_non_plt_self(Elf_Dyn *dynp, Elf_Addr relocbase)
|
||||
{
|
||||
const Elf_Rela *rela = 0, *relalim;
|
||||
Elf_Addr relasz = 0;
|
||||
Elf_Addr *where;
|
||||
|
||||
/*
|
||||
* Extract the rela/relasz values from the dynamic section
|
||||
*/
|
||||
for (; dynp->d_tag != DT_NULL; dynp++) {
|
||||
switch (dynp->d_tag) {
|
||||
case DT_RELA:
|
||||
rela = (const Elf_Rela *)(relocbase+dynp->d_un.d_ptr);
|
||||
break;
|
||||
case DT_RELASZ:
|
||||
relasz = dynp->d_un.d_val;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Relocate these values
|
||||
*/
|
||||
relalim = (const Elf_Rela *)((caddr_t)rela + relasz);
|
||||
for (; rela < relalim; rela++) {
|
||||
where = (Elf_Addr *)(relocbase + rela->r_offset);
|
||||
*where = (Elf_Addr)(relocbase + rela->r_addend);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Relocate a non-PLT object with addend.
|
||||
*/
|
||||
static int
|
||||
reloc_nonplt_object(Obj_Entry *obj_rtld, Obj_Entry *obj, const Elf_Rela *rela,
|
||||
SymCache *cache)
|
||||
{
|
||||
Elf_Addr *where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
|
||||
const Elf_Sym *def;
|
||||
const Obj_Entry *defobj;
|
||||
Elf_Addr tmp;
|
||||
|
||||
switch (ELF_R_TYPE(rela->r_info)) {
|
||||
|
||||
case R_PPC_NONE:
|
||||
break;
|
||||
|
||||
case R_PPC_ADDR32: /* word32 S + A */
|
||||
case R_PPC_GLOB_DAT: /* word32 S + A */
|
||||
def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
|
||||
false, cache);
|
||||
if (def == NULL) {
|
||||
return (-1);
|
||||
}
|
||||
|
||||
tmp = (Elf_Addr)(defobj->relocbase + def->st_value +
|
||||
rela->r_addend);
|
||||
|
||||
/* Don't issue write if unnecessary; avoid COW page fault */
|
||||
if (*where != tmp) {
|
||||
*where = tmp;
|
||||
}
|
||||
break;
|
||||
|
||||
case R_PPC_RELATIVE: /* word32 B + A */
|
||||
tmp = (Elf_Addr)(obj->relocbase + rela->r_addend);
|
||||
|
||||
/* As above, don't issue write unnecessarily */
|
||||
if (*where != tmp) {
|
||||
*where = tmp;
|
||||
}
|
||||
break;
|
||||
|
||||
case R_PPC_COPY:
|
||||
/*
|
||||
* These are deferred until all other relocations
|
||||
* have been done. All we do here is make sure
|
||||
* that the COPY relocation is not in a shared
|
||||
* library. They are allowed only in executable
|
||||
* files.
|
||||
*/
|
||||
if (!obj->mainprog) {
|
||||
_rtld_error("%s: Unexpected R_COPY "
|
||||
" relocation in shared library",
|
||||
obj->path);
|
||||
return (-1);
|
||||
}
|
||||
break;
|
||||
|
||||
case R_PPC_JMP_SLOT:
|
||||
/*
|
||||
* These will be handled by the plt/jmpslot routines
|
||||
*/
|
||||
break;
|
||||
|
||||
default:
|
||||
_rtld_error("%s: Unsupported relocation type %d"
|
||||
" in non-PLT relocations\n", obj->path,
|
||||
ELF_R_TYPE(rela->r_info));
|
||||
return (-1);
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Process non-PLT relocations
|
||||
*/
|
||||
int
|
||||
reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
|
||||
{
|
||||
const Elf_Rela *relalim;
|
||||
const Elf_Rela *rela;
|
||||
SymCache *cache;
|
||||
int bytes = obj->nchains * sizeof(SymCache);
|
||||
int r = -1;
|
||||
|
||||
/*
|
||||
* The dynamic loader may be called from a thread, we have
|
||||
* limited amounts of stack available so we cannot use alloca().
|
||||
*/
|
||||
cache = mmap(NULL, bytes, PROT_READ|PROT_WRITE, MAP_ANON, -1, 0);
|
||||
if (cache == MAP_FAILED) {
|
||||
cache = NULL;
|
||||
}
|
||||
if (cache != NULL) {
|
||||
memset(cache, 0, obj->nchains * sizeof(SymCache));
|
||||
}
|
||||
|
||||
/*
|
||||
* From the SVR4 PPC ABI:
|
||||
* "The PowerPC family uses only the Elf32_Rela relocation
|
||||
* entries with explicit addends."
|
||||
*/
|
||||
relalim = (const Elf_Rela *)((caddr_t)obj->rela + obj->relasize);
|
||||
for (rela = obj->rela; rela < relalim; rela++) {
|
||||
if (reloc_nonplt_object(obj_rtld, obj, rela, cache) < 0)
|
||||
goto done;
|
||||
}
|
||||
r = 0;
|
||||
done:
|
||||
if (cache) {
|
||||
munmap(cache, bytes);
|
||||
}
|
||||
return (r);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Initialise a PLT slot to the resolving trampoline
|
||||
*/
|
||||
static int
|
||||
reloc_plt_object(Obj_Entry *obj, const Elf_Rela *rela)
|
||||
{
|
||||
Elf_Word *where = (Elf_Word *)(obj->relocbase + rela->r_offset);
|
||||
Elf_Addr *pltresolve;
|
||||
Elf_Addr distance;
|
||||
int reloff;
|
||||
|
||||
reloff = rela - obj->pltrela;
|
||||
|
||||
if ((reloff < 0) || (reloff >= 0x8000)) {
|
||||
return (-1);
|
||||
}
|
||||
|
||||
pltresolve = obj->pltgot + 8;
|
||||
|
||||
distance = (Elf_Addr)pltresolve - (Elf_Addr)(where + 1);
|
||||
|
||||
dbg(" reloc_plt_object: where=%p,pltres=%p,reloff=%x,distance=%x",
|
||||
(void *)where, (void *)pltresolve, reloff, distance);
|
||||
|
||||
/* li r11,reloff */
|
||||
/* b pltresolve */
|
||||
where[0] = 0x39600000 | reloff;
|
||||
where[1] = 0x48000000 | (distance & 0x03fffffc);
|
||||
|
||||
/*
|
||||
* The icache will be sync'd in init_pltgot, which is called
|
||||
* after all the slots have been updated
|
||||
*/
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Process the PLT relocations.
|
||||
*/
|
||||
int
|
||||
reloc_plt(Obj_Entry *obj)
|
||||
{
|
||||
const Elf_Rela *relalim;
|
||||
const Elf_Rela *rela;
|
||||
|
||||
if (obj->pltrelasize != 0) {
|
||||
|
||||
relalim = (const Elf_Rela *)((char *)obj->pltrela +
|
||||
obj->pltrelasize);
|
||||
for (rela = obj->pltrela; rela < relalim; rela++) {
|
||||
assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT);
|
||||
|
||||
if (reloc_plt_object(obj, rela) < 0) {
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* LD_BIND_NOW was set - force relocation for all jump slots
|
||||
*/
|
||||
int
|
||||
reloc_jmpslots(Obj_Entry *obj)
|
||||
{
|
||||
const Obj_Entry *defobj;
|
||||
const Elf_Rela *relalim;
|
||||
const Elf_Rela *rela;
|
||||
const Elf_Sym *def;
|
||||
Elf_Addr *where;
|
||||
Elf_Addr target;
|
||||
|
||||
relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
|
||||
for (rela = obj->pltrela; rela < relalim; rela++) {
|
||||
assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT);
|
||||
where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
|
||||
def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
|
||||
true, NULL);
|
||||
if (def == NULL) {
|
||||
dbg("reloc_jmpslots: sym not found");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
target = (Elf_Addr)(defobj->relocbase + def->st_value);
|
||||
|
||||
#if 0
|
||||
/* PG XXX */
|
||||
dbg("\"%s\" in \"%s\" --> %p in \"%s\"",
|
||||
defobj->strtab + def->st_name, basename(obj->path),
|
||||
(void *)target, basename(defobj->path));
|
||||
#endif
|
||||
|
||||
reloc_jmpslot(where, target, defobj, obj,
|
||||
(const Elf_Rel *) rela);
|
||||
}
|
||||
|
||||
obj->jmpslots_done = true;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Update the value of a PLT jump slot. Branch directly to the target if
|
||||
* it is within +/- 32Mb, otherwise go indirectly via the pltcall
|
||||
* trampoline call and jump table.
|
||||
*/
|
||||
Elf_Addr
|
||||
reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target, const Obj_Entry *defobj,
|
||||
const Obj_Entry *obj, const Elf_Rel *rel)
|
||||
{
|
||||
Elf_Addr offset;
|
||||
const Elf_Rela *rela = (const Elf_Rela *) rel;
|
||||
|
||||
dbg(" reloc_jmpslot: where=%p, target=%p",
|
||||
(void *)wherep, (void *)target);
|
||||
|
||||
/*
|
||||
* At the PLT entry pointed at by `wherep', construct
|
||||
* a direct transfer to the now fully resolved function
|
||||
* address.
|
||||
*/
|
||||
offset = target - (Elf_Addr)wherep;
|
||||
|
||||
if (abs(offset) < 32*1024*1024) { /* inside 32MB? */
|
||||
/* b value # branch directly */
|
||||
*wherep = 0x48000000 | (offset & 0x03fffffc);
|
||||
__syncicache(wherep, 4);
|
||||
} else {
|
||||
Elf_Addr *pltcall, *jmptab;
|
||||
int distance;
|
||||
int N = obj->pltrelasize / sizeof(Elf_Rela);
|
||||
int reloff = rela - obj->pltrela;
|
||||
|
||||
if ((reloff < 0) || (reloff >= 0x8000)) {
|
||||
return (-1);
|
||||
}
|
||||
|
||||
pltcall = obj->pltgot;
|
||||
|
||||
dbg(" reloc_jmpslot: indir, reloff=%d, N=%d\n",
|
||||
reloff, N);
|
||||
|
||||
jmptab = obj->pltgot + 18 + N * 2;
|
||||
jmptab[reloff] = target;
|
||||
|
||||
distance = (Elf_Addr)pltcall - (Elf_Addr)(wherep + 1);
|
||||
|
||||
/* li r11,reloff */
|
||||
/* b pltcall # use indirect pltcall routine */
|
||||
wherep[0] = 0x39600000 | reloff;
|
||||
wherep[1] = 0x48000000 | (distance & 0x03fffffc);
|
||||
__syncicache(wherep, 8);
|
||||
}
|
||||
|
||||
return (target);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Setup the plt glue routines.
|
||||
*/
|
||||
#define PLTCALL_SIZE 20
|
||||
#define PLTRESOLVE_SIZE 24
|
||||
|
||||
void
|
||||
init_pltgot(Obj_Entry *obj)
|
||||
{
|
||||
Elf_Word *pltcall, *pltresolve;
|
||||
Elf_Word *jmptab;
|
||||
int N = obj->pltrelasize / sizeof(Elf_Rela);
|
||||
|
||||
pltcall = obj->pltgot;
|
||||
|
||||
if (pltcall == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* From the SVR4 PPC ABI:
|
||||
*
|
||||
* 'The first 18 words (72 bytes) of the PLT are reserved for
|
||||
* use by the dynamic linker.
|
||||
* ...
|
||||
* 'If the executable or shared object requires N procedure
|
||||
* linkage table entries, the link editor shall reserve 3*N
|
||||
* words (12*N bytes) following the 18 reserved words. The
|
||||
* first 2*N of these words are the procedure linkage table
|
||||
* entries themselves. The static linker directs calls to bytes
|
||||
* (72 + (i-1)*8), for i between 1 and N inclusive. The remaining
|
||||
* N words (4*N bytes) are reserved for use by the dynamic linker.'
|
||||
*/
|
||||
|
||||
/*
|
||||
* Copy the absolute-call assembler stub into the first part of
|
||||
* the reserved PLT area.
|
||||
*/
|
||||
memcpy(pltcall, _rtld_powerpc_pltcall, PLTCALL_SIZE);
|
||||
|
||||
/*
|
||||
* Determine the address of the jumptable, which is the dyn-linker
|
||||
* reserved area after the call cells. Write the absolute address
|
||||
* of the jumptable into the absolute-call assembler code so it
|
||||
* can determine this address.
|
||||
*/
|
||||
jmptab = pltcall + 18 + N * 2;
|
||||
pltcall[1] |= _ppc_ha(jmptab); /* addis 11,11,jmptab@ha */
|
||||
pltcall[2] |= _ppc_la(jmptab); /* lwz 11,jmptab@l(11) */
|
||||
|
||||
/*
|
||||
* Skip down 32 bytes into the initial reserved area and copy
|
||||
* in the standard resolving assembler call. Into this assembler,
|
||||
* insert the absolute address of the _rtld_bind_start routine
|
||||
* and the address of the relocation object.
|
||||
*/
|
||||
pltresolve = obj->pltgot + 8;
|
||||
|
||||
memcpy(pltresolve, _rtld_powerpc_pltresolve, PLTRESOLVE_SIZE);
|
||||
pltresolve[0] |= _ppc_ha(_rtld_bind_start);
|
||||
pltresolve[1] |= _ppc_la(_rtld_bind_start);
|
||||
pltresolve[3] |= _ppc_ha(obj);
|
||||
pltresolve[4] |= _ppc_la(obj);
|
||||
|
||||
/*
|
||||
* Sync the icache for the byte range represented by the
|
||||
* trampoline routines and call slots.
|
||||
*/
|
||||
__syncicache(pltcall, 72 + N * 8);
|
||||
}
|
67
libexec/rtld-elf/powerpc/rtld_machdep.h
Normal file
67
libexec/rtld-elf/powerpc/rtld_machdep.h
Normal file
@ -0,0 +1,67 @@
|
||||
/*-
|
||||
* Copyright (c) 1999, 2000 John D. Polstra.
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#ifndef RTLD_MACHDEP_H
|
||||
#define RTLD_MACHDEP_H 1
|
||||
|
||||
#include <machine/atomic.h>
|
||||
|
||||
#define atomic_incr_int(p) atomic_add_int((p), 1)
|
||||
#define atomic_decr_int(p) atomic_subtract_int((p), 1)
|
||||
|
||||
#define CACHE_LINE_SIZE 32
|
||||
|
||||
struct Struct_Obj_Entry;
|
||||
|
||||
/* Return the address of the .dynamic section in the dynamic linker. */
|
||||
#define rtld_dynamic(obj) (&_DYNAMIC)
|
||||
|
||||
Elf_Addr reloc_jmpslot(Elf_Addr *where, Elf_Addr target,
|
||||
const struct Struct_Obj_Entry *defobj,
|
||||
const struct Struct_Obj_Entry *obj,
|
||||
const Elf_Rel *rel);
|
||||
|
||||
#define make_function_pointer(def, defobj) \
|
||||
((defobj)->relocbase + (def)->st_value)
|
||||
|
||||
#define call_initfini_pointer(obj, target) \
|
||||
(((InitFunc)(target))())
|
||||
|
||||
/*
|
||||
* Lazy binding entry point, called via PLT.
|
||||
*/
|
||||
void _rtld_bind_start(void);
|
||||
|
||||
/*
|
||||
* PLT functions. Not really correct prototypes, but the
|
||||
* symbol values are needed.
|
||||
*/
|
||||
void _rtld_powerpc_pltresolve(void);
|
||||
void _rtld_powerpc_pltcall(void);
|
||||
|
||||
#endif
|
194
libexec/rtld-elf/powerpc/rtld_start.S
Normal file
194
libexec/rtld-elf/powerpc/rtld_start.S
Normal file
@ -0,0 +1,194 @@
|
||||
/* $NetBSD: rtld_start.S,v 1.4 2001/09/26 04:06:43 mycroft Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (C) 1998 Tsubai Masanari
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the author may not be used to endorse or promote products
|
||||
* derived from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* $FreeBSD$
|
||||
*/
|
||||
|
||||
#include <machine/asm.h>
|
||||
|
||||
.extern _GLOBAL_OFFSET_TABLE_
|
||||
.extern _DYNAMIC
|
||||
|
||||
_ENTRY(.rtld_start)
|
||||
stwu %r1,-48(%r1) /* 16-byte aligned stack for reg saves +
|
||||
exit_proc & obj _rtld args +
|
||||
backchain & lrsave stack frame */
|
||||
stw %r3,16(%r1) /* argc */
|
||||
stw %r4,20(%r1) /* argv */
|
||||
stw %r5,24(%r1) /* envp */
|
||||
/* stw %r6,28(%r1) *//* obj (always 0) */
|
||||
/* stw %r7,32(%r1) *//* cleanup (always 0) */
|
||||
stw %r8,36(%r1) /* ps_strings */
|
||||
|
||||
/*
|
||||
* Perform initial relocation of ld-elf.so. Not as easy as it
|
||||
* sounds.
|
||||
* - perform small forward branch to put PC into link reg
|
||||
* - use link-time constants to determine offset to the
|
||||
* _DYNAMIC section and the GOT. Add these to the PC to
|
||||
* convert to absolute addresses.
|
||||
* - sync icache to allow execution of the SVR4 ABI-specified
|
||||
* blrl instruction preceding the GOT
|
||||
* - Use this instruction to determine the GOT absolute address
|
||||
* - read GOT[0], which is the SVR4 ABI-specified link-time
|
||||
* value of _DYNAMIC. Subtract this value from the absolute
|
||||
* value to determine the load address
|
||||
* - call reloc_non_plt_self() to fix up ld-elf.so's relocations
|
||||
*/
|
||||
bl 1f
|
||||
.long _DYNAMIC-.
|
||||
.long _GLOBAL_OFFSET_TABLE_-. /* branch lr + 4 */
|
||||
1:
|
||||
mflr %r3 /* PC value at .long */
|
||||
lwz %r4,4(%r3)
|
||||
add %r4,%r4,%r3 /* &_GLOBAL_OFFSET_TABLE-4, blrl insn. */
|
||||
dcbst %r0,%r4 /* sync i-cache with d-cache */
|
||||
sync
|
||||
icbi %r0,%r4
|
||||
isync
|
||||
|
||||
lwz %r4,0(%r3) /* offset to _DYNAMIC */
|
||||
add %r3,%r4,%r3 /* r3 = &_DYNAMIC, absolute value */
|
||||
|
||||
bl _GLOBAL_OFFSET_TABLE_@local-4
|
||||
mflr %r4 /* &_GLOBAL_OFFSET_TABLE_, absolute value */
|
||||
lwz %r4,0(%r4) /* linker &_DYNAMIC, from got[0] */
|
||||
subf %r4,%r4,%r3 /* subtract to calculate relocbase */
|
||||
|
||||
bl reloc_non_plt_self@plt /* reloc_non_plt_self(&_DYNAMIC,base) */
|
||||
|
||||
/*
|
||||
* The _rtld() function likes to see a stack layout containing
|
||||
* { argc, argv[0], argv[1] ... argv[N], 0, env[0], ... , env[N] }
|
||||
* Since the PowerPC stack was 16-byte aligned at exec time, the
|
||||
* original stack layout has to be found by moving back a word
|
||||
* from the argv pointer.
|
||||
*/
|
||||
lwz %r4,20(%r1) /* restore argv */
|
||||
addi %r3,%r4,-4 /* locate argc ptr, &argv[-1] */
|
||||
|
||||
addi %r4,%r1,8 /* &exit_proc on stack */
|
||||
addi %r5,%r1,12 /* &obj_main on stack */
|
||||
|
||||
bl _rtld@plt /* &_start = _rtld(sp, &exit_proc, &obj_main)*/
|
||||
mtlr %r3
|
||||
|
||||
/*
|
||||
* Restore args, with new obj/exit proc
|
||||
*/
|
||||
lwz %r3,16(%r1) /* argc */
|
||||
lwz %r4,20(%r1) /* argv */
|
||||
lwz %r5,24(%r1) /* envp */
|
||||
lwz %r6,12(%r1) /* obj */
|
||||
lwz %r7,8(%r1) /* exit proc */
|
||||
lwz %r8,36(%r1) /* ps_strings */
|
||||
addi %r1,%r1,48 /* restore original stackptr */
|
||||
|
||||
blrl /* _start(argc, argv, envp, obj, cleanup, ps_strings) */
|
||||
|
||||
li %r0,1 /* _exit() */
|
||||
sc
|
||||
|
||||
/*
|
||||
* _rtld_bind_start()
|
||||
*
|
||||
* Call into the MI binder. This routine is reached via the PLT call cell,
|
||||
* and then _rtld_powerpc_pltresolve().
|
||||
* On entry, %r11 contains the index of the PLT cell, and %r12 contains
|
||||
* a pointer to the ELF object for the file.
|
||||
* Save all registers, call into the binder to resolve and fixup the external
|
||||
* routine, and then transfer to the external routine on return.
|
||||
*/
|
||||
.globl _rtld_bind
|
||||
|
||||
_ENTRY(_rtld_bind_start)
|
||||
stwu %r1,-160(%r1) # stack space for 29 regs + r0/lr/cr
|
||||
stw %r0,20(%r1) # save r0
|
||||
mflr %r0
|
||||
stw %r0,16(%r1) # save lr
|
||||
mfcr %r0
|
||||
stw %r0,12(%r1) # save cr
|
||||
stmw %r3,24(%r1) # save r3-r31
|
||||
|
||||
mr %r3,%r12 # obj
|
||||
mulli %r4,%r11,12 # rela index * sizeof(Elf_Rela)
|
||||
bl _rtld_bind@PLT # target addr = _rtld_bind(obj, reloff)
|
||||
mtctr %r3 # move absolute target addr into ctr
|
||||
|
||||
lmw %r3,24(%r1) # restore r3-r31
|
||||
lwz %r0,12(%r1) # restore cr
|
||||
mtcr %r0
|
||||
lwz %r0,16(%r1) # restore lr
|
||||
mtlr %r0
|
||||
lwz %r0,20(%r1) # restore r0
|
||||
|
||||
addi %r1,%r1,160 # restore stack
|
||||
bctr # jump to target
|
||||
|
||||
|
||||
/*
|
||||
* _rtld_powerpc_pltresolve()
|
||||
*
|
||||
* This routine is copied into the latter part of the 72-byte reserved
|
||||
* area at the start of the PLT. The absolute address of the _rtld_bind_start
|
||||
* routine, and the ELF object for the loaded file, are inserted into
|
||||
* the code by the reloc.c:init_pltgot() routine.
|
||||
* The first time an external routine is called, the PLT slot will
|
||||
* set up %r11 to the offset of the slot, and will jump to this routine.
|
||||
* The ELF object is shifted into %r11, and _rtld_bind_start is called
|
||||
* to complete the binding.
|
||||
*/
|
||||
_ENTRY(_rtld_powerpc_pltresolve)
|
||||
lis %r12,0 # lis 12,_rtld_bind_start@ha
|
||||
addi %r12,%r12,0 # addi 12,12,_rtld_bind_start@l
|
||||
mtctr %r12
|
||||
lis %r12,0 # lis 12,obj@ha
|
||||
addi %r12,%r12,0 # addi 12,12,obj@l
|
||||
bctr
|
||||
|
||||
/*
|
||||
* _rtld_powerpc_pltcall()
|
||||
*
|
||||
* This routine is copied into the 72-byte reserved area at the
|
||||
* start of the PLT. The reloc.c:init_pltgot() routine inserts
|
||||
* the absolute address of the jumptable.
|
||||
* Control is transferred to this routine when the binder has
|
||||
* located the external routine, but determined that it is > 32Mb
|
||||
* from the PLT slot. Code is inserted into the PLT slot to set up
|
||||
* %r11 with the jumptable index, and jump to here, where the
|
||||
* absolute address of the external routine is loaded from the
|
||||
* jumptable and transferred to
|
||||
*/
|
||||
_ENTRY(_rtld_powerpc_pltcall)
|
||||
slwi %r11,%r11,2 # jmptab offset = index * 4
|
||||
addis %r11,%r11,0 # addis 11,11,jmptab@ha
|
||||
lwz %r11,0(%r11) # lwz 11,jmptab@l(11)
|
||||
mtctr %r11
|
||||
bctr # (*jmptab[index])()
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user