rtld support for PowerPC. Mostly obtained from NetBSD, with mods

for binutils 2.13

Reviewed by:  benno

Approved by:  re (blanket)

5 files changed, 926 insertions, 0 deletions

diff --git a/libexec/rtld-elf/powerpc/Makefile.inc b/libexec/rtld-elf/powerpc/Makefile.inc
new file mode 100644
index 0000000..e8c0da7
--- /dev/null
+++ b/libexec/rtld-elf/powerpc/Makefile.inc
@@ -0,0 +1 @@
+# $FreeBSD$
diff --git a/libexec/rtld-elf/powerpc/lockdflt.c b/libexec/rtld-elf/powerpc/lockdflt.c
new file mode 100644
index 0000000..70dc733
--- /dev/null
+++ b/libexec/rtld-elf/powerpc/lockdflt.c
@@ -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);
+}
diff --git a/libexec/rtld-elf/powerpc/reloc.c b/libexec/rtld-elf/powerpc/reloc.c
new file mode 100644
index 0000000..22613a0
--- /dev/null
+++ b/libexec/rtld-elf/powerpc/reloc.c
@@ -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);
+}
diff --git a/libexec/rtld-elf/powerpc/rtld_machdep.h b/libexec/rtld-elf/powerpc/rtld_machdep.h
new file mode 100644
index 0000000..7e5e719
--- /dev/null
+++ b/libexec/rtld-elf/powerpc/rtld_machdep.h
@@ -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
diff --git a/libexec/rtld-elf/powerpc/rtld_start.S b/libexec/rtld-elf/powerpc/rtld_start.S
new file mode 100644
index 0000000..040b663
--- /dev/null
+++ b/libexec/rtld-elf/powerpc/rtld_start.S
@@ -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])()
+	
+