Add alpha support.

Submitted by: John Birrell <jb@cimlogic.com.au> (with extra hacks by me)
Obtained from: Probably NetBSD

2 files changed, 478 insertions, 0 deletions

diff --git a/libexec/rtld-elf/alpha/reloc.c b/libexec/rtld-elf/alpha/reloc.c
new file mode 100644
index 0000000..e43b12a
--- /dev/null
+++ b/libexec/rtld-elf/alpha/reloc.c
@@ -0,0 +1,309 @@
+/*-
+ * Copyright 1996-1998 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.
+ *
+ *      $Id: rtld.c,v 1.3 1998/05/01 08:39:27 dfr Exp $
+ */
+
+/*
+ * Dynamic linker for ELF.
+ *
+ * John Polstra <jdp@polstra.com>.
+ */
+
+#include <sys/param.h>
+#include <sys/mman.h>
+
+#include <dlfcn.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "debug.h"
+#include "rtld.h"
+
+/*
+ * Debugging support.
+ */
+
+#define assert(cond)	((cond) ? (void) 0 :\
+    (msg("oops: " __XSTRING(__LINE__) "\n"), abort()))
+#define msg(s)		(write(1, s, strlen(s)))
+#define trace()		msg("trace: " __XSTRING(__LINE__) "\n");
+
+extern Elf_Dyn _DYNAMIC;
+
+/* Relocate a non-PLT object with addend. */
+static int
+reloc_non_plt_obj(Obj_Entry *obj_rtld, const Obj_Entry *obj,
+    const Elf_Rela *rela)
+{
+	Elf_Addr *where = (Elf_Addr *) (obj->relocbase + rela->r_offset);
+
+	switch (ELF_R_TYPE(rela->r_info)) {
+
+		case R_ALPHA_REFQUAD: {
+			const Elf_Sym *def;
+			const Obj_Entry *defobj;
+			Elf_Addr tmp_value;
+
+			def = find_symdef(ELF_R_SYM(rela->r_info), obj,
+			    &defobj, false);
+			if (def == NULL)
+				return -1;
+
+			tmp_value = (Elf_Addr) (defobj->relocbase +
+			    def->st_value) + *where + rela->r_addend;
+			if (*where != tmp_value)
+				*where = tmp_value;
+		}
+		break;
+
+		case R_ALPHA_GLOB_DAT: {
+			const Elf_Sym *def;
+			const Obj_Entry *defobj;
+
+			def = find_symdef(ELF_R_SYM(rela->r_info), obj,
+			    &defobj, false);
+			if (def == NULL)
+				return -1;
+
+			if (*where != (Elf_Addr) (defobj->relocbase +
+			    def->st_value))
+				*where = (Elf_Addr) (defobj->relocbase +
+				    def->st_value);
+		}
+		break;
+
+		case R_ALPHA_RELATIVE: {
+			if (obj != obj_rtld ||
+			    (caddr_t)where < (caddr_t)_GLOBAL_OFFSET_TABLE_ ||
+			    (caddr_t)where >= (caddr_t)&_DYNAMIC)
+				*where += (Elf_Addr) obj->relocbase;
+		}
+		break;
+
+		case R_ALPHA_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;
+
+		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 the non-PLT relocations. */
+int
+reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
+{
+	const Elf_Rel *rellim;
+	const Elf_Rel *rel;
+	const Elf_Rela *relalim;
+	const Elf_Rela *rela;
+
+	/* Perform relocations without addend if there are any: */
+	rellim = (const Elf_Rel *) ((caddr_t) obj->rel + obj->relsize);
+	for (rel = obj->rel;  obj->rel != NULL && rel < rellim;  rel++) {
+		Elf_Rela locrela;
+
+		locrela.r_info = rel->r_info;
+		locrela.r_offset = rel->r_offset;
+		locrela.r_addend = 0;
+		if (reloc_non_plt_obj(obj_rtld, obj, &locrela))
+			return -1;
+	}
+
+	/* Perform relocations with addend if there are any: */
+	relalim = (const Elf_Rela *) ((caddr_t) obj->rela + obj->relasize);
+	for (rela = obj->rela;  obj->rela != NULL && rela < relalim;  rela++) {
+		if (reloc_non_plt_obj(obj_rtld, obj, rela))
+			return -1;
+	}
+    return 0;
+}
+
+/* Process the PLT relocations. */
+int
+reloc_plt(Obj_Entry *obj, bool bind_now)
+{
+	const Elf_Rel *rellim;
+	const Elf_Rel *rel;
+	const Elf_Rela *relalim;
+	const Elf_Rela *rela;
+
+	/* Process the PLT relocations without addend if there are any. */
+	rellim = (const Elf_Rel *) ((caddr_t) obj->pltrel + obj->pltrelsize);
+	if (bind_now) {
+	    /* Fully resolve procedure addresses now */
+	    for (rel = obj->pltrel;  obj->pltrel != NULL && rel < rellim;
+		    rel++) {
+		Elf_Addr *where = (Elf_Addr *) (obj->relocbase + rel->r_offset);
+		const Elf_Sym *def;
+		const Obj_Entry *defobj;
+
+		assert(ELF_R_TYPE(rel->r_info) == R_ALPHA_JMP_SLOT);
+
+		def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj, true);
+		if (def == NULL)
+			return -1;
+
+		*where = (Elf_Addr) (defobj->relocbase + def->st_value);
+	    }
+	} else {	/* Just relocate the GOT slots pointing into the PLT */
+	    for (rel = obj->pltrel; obj->pltrel != NULL && rel < rellim;
+		rel++) {
+		Elf_Addr *where = (Elf_Addr *)
+		  (obj->relocbase + rel->r_offset);
+		*where += (Elf_Addr) obj->relocbase;
+	    }
+	}
+
+	/* Process the PLT relocations with addend if there are any. */
+	relalim = (const Elf_Rela *) ((caddr_t) obj->pltrela +
+	    obj->pltrelasize);
+	if (bind_now) {
+	    /* Fully resolve procedure addresses now */
+	    for (rela = obj->pltrela;  obj->pltrela != NULL && rela < relalim;
+		rel++) {
+		Elf_Addr *where = (Elf_Addr *) (obj->relocbase +
+		    rela->r_offset);
+		const Elf_Sym *def;
+		const Obj_Entry *defobj;
+
+		assert(ELF_R_TYPE(rela->r_info) == R_ALPHA_JMP_SLOT);
+
+		def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj, true);
+		if (def == NULL)
+			return -1;
+
+		*where = (Elf_Addr) (defobj->relocbase + def->st_value);
+	    }
+	} else {	/* Just relocate the GOT slots pointing into the PLT */
+	    for (rela = obj->pltrela;  obj->pltrela != NULL && rela < relalim;
+		rela++) {
+		Elf_Addr *where = (Elf_Addr *)
+		  (obj->relocbase + rela->r_offset);
+		*where += (Elf_Addr) obj->relocbase;
+	    }
+	}
+    return 0;
+}
+
+/* Process an R_ALPHA_COPY relocation. */
+static int
+do_copy_relocation(Obj_Entry *dstobj, const Elf_Rela *rela)
+{
+	void *dstaddr;
+	const Elf_Sym *dstsym;
+	const char *name;
+	unsigned long hash;
+	size_t size;
+	const void *srcaddr;
+	const Elf_Sym *srcsym;
+	Obj_Entry *srcobj;
+
+	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);
+	return 0;
+}
+
+/*
+ * Process the special R_ALPHA_COPY relocations in the main program.  These
+ * copy data from a shared object into a region in the main program's BSS
+ * segment.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+int
+do_copy_relocations(Obj_Entry *dstobj)
+{
+	const Elf_Rel *rellim;
+	const Elf_Rel *rel;
+	const Elf_Rela *relalim;
+	const Elf_Rela *rela;
+
+	assert(dstobj->mainprog);	/* COPY relocations are invalid elsewhere */
+
+	rellim = (const Elf_Rel *) ((caddr_t) dstobj->rel + dstobj->relsize);
+	for (rel = dstobj->rel; dstobj->rel != NULL && rel < rellim;  rel++) {
+		if (ELF_R_TYPE(rel->r_info) == R_ALPHA_COPY) {
+			Elf_Rela locrela;
+
+			locrela.r_info = rel->r_info;
+			locrela.r_offset = rel->r_offset;
+			locrela.r_addend = 0;
+			if (do_copy_relocation(dstobj, &locrela))
+				return -1;
+		}
+	}
+
+	relalim = (const Elf_Rela *) ((caddr_t) dstobj->rela +
+	    dstobj->relasize);
+	for (rela = dstobj->rela; dstobj->rela != NULL && rela < relalim;
+	    rela++) {
+		if (ELF_R_TYPE(rela->r_info) == R_ALPHA_COPY) {
+			if (do_copy_relocation(dstobj, rela))
+				return -1;
+		}
+	}
+
+	return 0;
+}
diff --git a/libexec/rtld-elf/alpha/rtld_start.S b/libexec/rtld-elf/alpha/rtld_start.S
new file mode 100644
index 0000000..e93829f
--- /dev/null
+++ b/libexec/rtld-elf/alpha/rtld_start.S
@@ -0,0 +1,169 @@
+/*	$Id$	*/
+/*	From: NetBSD: rtld_start.S,v 1.1 1996/12/16 20:38:09 cgd Exp 	*/
+
+/*
+ * Copyright 1996 Matt Thomas <matt@3am-software.com>
+ * 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.
+ */
+
+#include <machine/asm.h>
+#include <machine/pal.h>
+
+.extern	_GLOBAL_OFFSET_TABLE_
+
+LEAF(_rtld_start, 0)		/* XXX */
+	.set	noreorder
+	br	pv, $33
+$33:	LDGP(pv)
+
+	/* save away the stack pointer */
+
+	lda	s0, 0(sp)	/* get argc from stack */
+	lda	sp, -16(sp)	/* space for arguments */
+
+	/* save ps_strings pointer */
+	mov	a3, s1
+
+	/* Step 1 -- Figure out the displacement */
+
+	br	t2, $34		/* get our PC */
+$34:	ldiq	t3, $34		/* get where the linker thought we were */
+	subq	t2, t3, t8	/* calculate the displacement */
+
+
+	/* Step 2 -- Find bounds of global offset table */
+
+	lda	t5, _GLOBAL_OFFSET_TABLE_
+	addq	t8, t5, t9	/* add the displacement */
+	lda	t4, _DYNAMIC
+	addq	t8, t4, t10	/* add the displacement */
+
+	/*
+	 * Step 3 -- Every entry in the global offset table needs to
+	 * modified for the displacement before any code will work.
+	 */
+
+$35:	ldq	t1, 0(t9)	/* load the value */
+	addq	t8, t1, t1	/* add the displacement */
+	stq	t1, 0(t9)	/* save the new value */
+	lda	t9, 8(t9)	/* point to next entry */
+	cmpult	t9, t10, t1	/* are we done? */
+	bne	t1, $35		/* no, do more */
+
+	/*
+	 *  Ya!  Things are far enough so we can do some dynamic linking!
+	 */
+
+	lda	a0, 0(s0)	/* initial sp */
+	lda	a1, -16(s0)	/* address for exit proc */
+	lda	a2, -8(s0)	/* address for obj_main */
+	CALL(_rtld)		/* v0 = _rtld(sp, &exit_proc, &obj_main); */
+
+	ldq	a1, -16(s0)	/* our atexit function */
+	ldq	a2, -8(s0)	/* obj_main entry */
+	lda	sp, 16(sp)	/* readjust our stack */
+	mov	s0, a0		/* stack pointer */
+	mov	s1, a3		/* ps_strings pointer */
+	mov	v0, t12
+	jsr	ra, (v0), 0	/* (*_start)(sp, cleanup, obj); */
+	ldgp	gp, 0(ra)
+
+	CALL(exit)
+	halt
+END(_rtld_start)
+
+	.set	noat
+	.globl	_rtld_bind_start
+	.ent	_rtld_bind_start
+_rtld_bind_start:
+
+	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, $100
+$100:	ldgp    gp, 0(gp)
+	.prologue 1
+	/* Set up the arguments for _rtld_bind. */
+	ldq     a0, 8(t12)		/* object structure */
+	mov	at_reg, a1		/* offset of reloc entry */
+	CALL(_rtld_bind)
+
+	/* Move the destination address into position.  */
+	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)
+	/* Flush the Icache after having modified the .plt code.  */
+	imb
+	/* Clean up and turn control to the destination */
+	lda     sp, 168(sp)
+	jmp     $31, ($27)
+	.end _rtld_bind_start
+ 
+
+
+