No more Alpha support for RTLD.
authorJoerg Sonnenberger <joerg@dragonflybsd.org>
Mon, 21 Mar 2005 18:25:22 +0000 (18:25 +0000)
committerJoerg Sonnenberger <joerg@dragonflybsd.org>
Mon, 21 Mar 2005 18:25:22 +0000 (18:25 +0000)
libexec/rtld-elf/alpha/Makefile.inc [deleted file]
libexec/rtld-elf/alpha/ld.so.script [deleted file]
libexec/rtld-elf/alpha/lockdflt.c [deleted file]
libexec/rtld-elf/alpha/reloc.c [deleted file]
libexec/rtld-elf/alpha/rtld_machdep.h [deleted file]
libexec/rtld-elf/alpha/rtld_start.S [deleted file]

diff --git a/libexec/rtld-elf/alpha/Makefile.inc b/libexec/rtld-elf/alpha/Makefile.inc
deleted file mode 100644 (file)
index 35e4289..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-# $FreeBSD: src/libexec/rtld-elf/alpha/Makefile.inc,v 1.1.4.1 2002/09/02 02:10:20 obrien Exp $
-# $DragonFly: src/libexec/rtld-elf/alpha/Attic/Makefile.inc,v 1.2 2003/06/17 04:27:08 dillon Exp $
-
-CFLAGS+=       -mno-fp-regs
-LDFLAGS+=      -Wl,--script,${.CURDIR}/alpha/ld.so.script
diff --git a/libexec/rtld-elf/alpha/ld.so.script b/libexec/rtld-elf/alpha/ld.so.script
deleted file mode 100644 (file)
index dd709c1..0000000
+++ /dev/null
@@ -1,136 +0,0 @@
-/*     $NetBSD: ld.so.script,v 1.2 2001/12/13 20:31:31 thorpej Exp $   */
-/* $FreeBSD: src/libexec/rtld-elf/alpha/ld.so.script,v 1.1.2.1 2002/09/02 02:10:20 obrien Exp $ */
-/* $DragonFly: src/libexec/rtld-elf/alpha/Attic/ld.so.script,v 1.2 2003/06/17 04:27:08 dillon Exp $ */
-
-OUTPUT_FORMAT("elf64-alpha", "elf64-alpha",
-             "elf64-alpha")
-OUTPUT_ARCH(alpha)
-ENTRY(__start)
-/* SEARCH_DIR(/usr/lib); JRT */
-/* Do we need any of these for elf?
-   __DYNAMIC = 0;    */
-SECTIONS
-{
-  /* Read-only sections, merged into text segment: */
-  . = 0 + SIZEOF_HEADERS;
-  .hash          : { *(.hash)          }
-  .dynsym        : { *(.dynsym)                }
-  .dynstr        : { *(.dynstr)                }
-  .gnu.version   : { *(.gnu.version)   }
-  .gnu.version_d   : { *(.gnu.version_d)       }
-  .gnu.version_r   : { *(.gnu.version_r)       }
-  .rel.text      :
-    { *(.rel.text) *(.rel.gnu.linkonce.t*) }
-  .rela.text     :
-    { *(.rela.text) *(.rela.gnu.linkonce.t*) }
-  .rel.data      :
-    { *(.rel.data) *(.rel.gnu.linkonce.d*) }
-  .rela.data     :
-    { *(.rela.data) *(.rela.gnu.linkonce.d*) }
-  .rel.rodata    :
-    { *(.rel.rodata) *(.rel.gnu.linkonce.r*) }
-  .rela.rodata   :
-    { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
-  .rel.got       : { *(.rel.got)               }
-  .rela.got      : { *(.rela.got)              }
-  .rel.ctors     : { *(.rel.ctors)     }
-  .rela.ctors    : { *(.rela.ctors)    }
-  .rel.dtors     : { *(.rel.dtors)     }
-  .rela.dtors    : { *(.rela.dtors)    }
-  .rel.init      : { *(.rel.init)      }
-  .rela.init     : { *(.rela.init)     }
-  .rel.fini      : { *(.rel.fini)      }
-  .rela.fini     : { *(.rela.fini)     }
-  .rel.bss       : { *(.rel.bss)               }
-  .rela.bss      : { *(.rela.bss)              }
-  .rel.plt       : { *(.rel.plt)               }
-  .rela.plt      : { *(.rela.plt)              }
-  .init          : { *(.init)  } =0x47ff041f
-  .text      :
-  {
-    *(.text)
-    *(.stub)
-    /* .gnu.warning sections are handled specially by elf32.em.  */
-    *(.gnu.warning)
-    *(.gnu.linkonce.t*)
-  } =0x47ff041f
-  _etext = .;
-  PROVIDE (etext = .);
-  .fini      : { *(.fini)    } =0x47ff041f
-  .rodata    : { *(.rodata) *(.gnu.linkonce.r*) }
-  .rodata1   : { *(.rodata1) }
-  .reginfo : { *(.reginfo) }
-  /* Adjust the address for the data segment.  We want to adjust up to
-     the same address within the page on the next page up.  */
-  . = ALIGN(0x100000) + (. & (0x100000 - 1));
-  .data    :
-  {
-    *(.data)
-    *(.gnu.linkonce.d*)
-    CONSTRUCTORS
-  }
-  .data1   : { *(.data1) }
-  .ctors         :
-  {
-    *(.ctors)
-  }
-  .dtors         :
-  {
-    *(.dtors)
-  }
-  .plt      : { *(.plt)        }
-  .got           : { *(.got.plt) *(.got) }
-  PROVIDE (_GOT_END_ = .);
-  .dynamic       : { *(.dynamic) }
-  /* We want the small data sections together, so single-instruction offsets
-     can access them all, and initialized data all before uninitialized, so
-     we can shorten the on-disk segment size.  */
-  .sdata     : { *(.sdata) }
-  _edata  =  .;
-  PROVIDE (edata = .);
-  __bss_start = .;
-  .sbss      : { *(.sbss) *(.scommon) }
-  .bss       :
-  {
-   *(.dynbss)
-   *(.bss)
-   *(COMMON)
-  }
-  . = ALIGN(64 / 8);
-  _end = . ;
-  PROVIDE (end = .);
-  /* Stabs debugging sections.  */
-  .stab 0 : { *(.stab) }
-  .stabstr 0 : { *(.stabstr) }
-  .stab.excl 0 : { *(.stab.excl) }
-  .stab.exclstr 0 : { *(.stab.exclstr) }
-  .stab.index 0 : { *(.stab.index) }
-  .stab.indexstr 0 : { *(.stab.indexstr) }
-  .comment 0 : { *(.comment) }
-  /* DWARF debug sections.
-     Symbols in the DWARF debugging sections are relative to the beginning
-     of the section so we begin them at 0.  */
-  /* DWARF 1 */
-  .debug          0 : { *(.debug) }
-  .line           0 : { *(.line) }
-  /* GNU DWARF 1 extensions */
-  .debug_srcinfo  0 : { *(.debug_srcinfo) }
-  .debug_sfnames  0 : { *(.debug_sfnames) }
-  /* DWARF 1.1 and DWARF 2 */
-  .debug_aranges  0 : { *(.debug_aranges) }
-  .debug_pubnames 0 : { *(.debug_pubnames) }
-  /* DWARF 2 */
-  .debug_info     0 : { *(.debug_info) }
-  .debug_abbrev   0 : { *(.debug_abbrev) }
-  .debug_line     0 : { *(.debug_line) }
-  .debug_frame    0 : { *(.debug_frame) }
-  .debug_str      0 : { *(.debug_str) }
-  .debug_loc      0 : { *(.debug_loc) }
-  .debug_macinfo  0 : { *(.debug_macinfo) }
-  /* SGI/MIPS DWARF 2 extensions */
-  .debug_weaknames 0 : { *(.debug_weaknames) }
-  .debug_funcnames 0 : { *(.debug_funcnames) }
-  .debug_typenames 0 : { *(.debug_typenames) }
-  .debug_varnames  0 : { *(.debug_varnames) }
-  /* These must appear regardless of  .  */
-}
diff --git a/libexec/rtld-elf/alpha/lockdflt.c b/libexec/rtld-elf/alpha/lockdflt.c
deleted file mode 100644 (file)
index 821495f..0000000
+++ /dev/null
@@ -1,175 +0,0 @@
-/*-
- * 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.
- *
- * $FreeBSD: src/libexec/rtld-elf/alpha/lockdflt.c,v 1.5.2.3 2002/07/11 23:52:27 jdp Exp $
- * $DragonFly: src/libexec/rtld-elf/alpha/Attic/lockdflt.c,v 1.2 2003/06/17 04:27:08 dillon Exp $
- */
-
-/*
- * 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 "debug.h"
-#include "rtld.h"
-
-/*
- * This value of CACHE_LINE_SIZE is conservative.  The actual size
- * is 32 on the  21064, 21064A, 21066, 21066A, and 21164.  It is 64
- * on the 21264.  Compaq recommends sequestering each lock in its own
- * 128-byte block to allow for future implementations with larger
- * cache lines.
- */
-#define CACHE_LINE_SIZE                128
-
-#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_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 (cmp0_and_store_int(&l->lock, WAFLAG) == 0)
-           break;
-       sigprocmask(SIG_SETMASK, &tmp_oldsigmask, NULL);
-    }
-    oldsigmask = tmp_oldsigmask;
-}
-
-static void
-rlock_release(void *lock)
-{
-    Lock *l = (Lock *)lock;
-
-    atomic_add_int(&l->lock, -RC_INCR);
-}
-
-static void
-wlock_release(void *lock)
-{
-    Lock *l = (Lock *)lock;
-
-    atomic_add_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/alpha/reloc.c b/libexec/rtld-elf/alpha/reloc.c
deleted file mode 100644 (file)
index a866ab6..0000000
+++ /dev/null
@@ -1,505 +0,0 @@
-/*-
- * Copyright 1996, 1997, 1998, 1999 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.
- *
- * $FreeBSD: src/libexec/rtld-elf/alpha/reloc.c,v 1.10.2.5 2002/09/02 02:10:20 obrien Exp $
- * $DragonFly: src/libexec/rtld-elf/alpha/Attic/reloc.c,v 1.2 2003/06/17 04:27:08 dillon 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"
-
-extern Elf_Dyn _GOT_END_;
-
-/*
- * Macros for loading/storing unaligned 64-bit values.  These are
- * needed because relocations can point to unaligned data.  This
- * occurs in the DWARF2 exception frame tables generated by the
- * compiler, for instance.
- *
- * We don't use these when relocating jump slots and GOT entries,
- * since they are guaranteed to be aligned.
- */
-#define load64(p) ({                                           \
-       Elf_Addr __res;                                         \
-       __asm__("ldq_u %0,%1" : "=r"(__res) : "m"(*(p)));       \
-       __res; })
-
-#define store64(p, v)                                          \
-       __asm__("stq_u %1,%0" : "=m"(*(p)) : "r"(v))
-
-/* Relocate a non-PLT object with addend. */
-static int
-reloc_non_plt_obj(Obj_Entry *obj_rtld, Obj_Entry *obj, const Elf_Rela *rela,
-       SymCache *cache)
-{
-       Elf_Addr *where = (Elf_Addr *) (obj->relocbase + rela->r_offset);
-
-       switch (ELF_R_TYPE(rela->r_info)) {
-
-               case R_ALPHA_NONE:
-                       break;
-
-               case R_ALPHA_REFQUAD: {
-                       const Elf_Sym *def;
-                       const Obj_Entry *defobj;
-
-                       def = find_symdef(ELF_R_SYM(rela->r_info), obj,
-                           &defobj, false, cache);
-                       if (def == NULL)
-                               return -1;
-                       store64(where,
-                           (Elf_Addr) (defobj->relocbase + def->st_value) +
-                           load64(where) + rela->r_addend);
-               }
-               break;
-
-               case R_ALPHA_GLOB_DAT: {
-                       const Elf_Sym *def;
-                       const Obj_Entry *defobj;
-                       Elf_Addr val;
-
-                       def = find_symdef(ELF_R_SYM(rela->r_info), obj,
-                           &defobj, false, cache);
-                       if (def == NULL)
-                               return -1;
-                       val = (Elf_Addr) (defobj->relocbase + def->st_value +
-                           rela->r_addend);
-                       if (load64(where) != val)
-                               store64(where, val);
-               }
-               break;
-
-               case R_ALPHA_RELATIVE: {
-                       if (obj != obj_rtld ||
-                           (caddr_t)where < (caddr_t)_GLOBAL_OFFSET_TABLE_ ||
-                           (caddr_t)where >= (caddr_t)&_GOT_END_)
-                               store64(where,
-                                   load64(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;
-       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, bytes);
-
-       /* 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, cache))
-                       goto done;
-       }
-
-       /* 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, cache))
-                       goto done;
-       }
-       r = 0;
-done:
-       if (cache)
-           munmap(cache, bytes);
-       return(r);
-}
-
-/* Process the PLT relocations. */
-int
-reloc_plt(Obj_Entry *obj)
-{
-    /* All PLT relocations are the same kind: either Elf_Rel or Elf_Rela. */
-    if (obj->pltrelsize != 0) {
-       const Elf_Rel *rellim;
-       const Elf_Rel *rel;
-
-       rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
-       for (rel = obj->pltrel;  rel < rellim;  rel++) {
-           Elf_Addr *where;
-
-           assert(ELF_R_TYPE(rel->r_info) == R_ALPHA_JMP_SLOT);
-
-           /* Relocate the GOT slot pointing into the PLT. */
-           where = (Elf_Addr *)(obj->relocbase + rel->r_offset);
-           *where += (Elf_Addr)obj->relocbase;
-       }
-    } else {
-       const Elf_Rela *relalim;
-       const Elf_Rela *rela;
-
-       relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
-       for (rela = obj->pltrela;  rela < relalim;  rela++) {
-           Elf_Addr *where;
-
-           assert(ELF_R_TYPE(rela->r_info) == R_ALPHA_JMP_SLOT);
-
-           /* Relocate the GOT slot pointing into the PLT. */
-           where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
-           *where += (Elf_Addr)obj->relocbase;
-       }
-    }
-    return 0;
-}
-
-/* Relocate the jump slots in an object. */
-int
-reloc_jmpslots(Obj_Entry *obj)
-{
-    if (obj->jmpslots_done)
-       return 0;
-    /* All PLT relocations are the same kind: either Elf_Rel or Elf_Rela. */
-    if (obj->pltrelsize != 0) {
-       const Elf_Rel *rellim;
-       const Elf_Rel *rel;
-
-       rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
-       for (rel = obj->pltrel;  rel < rellim;  rel++) {
-           Elf_Addr *where;
-           const Elf_Sym *def;
-           const Obj_Entry *defobj;
-
-           assert(ELF_R_TYPE(rel->r_info) == R_ALPHA_JMP_SLOT);
-           where = (Elf_Addr *)(obj->relocbase + rel->r_offset);
-           def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj, true,
-               NULL);
-           if (def == NULL)
-               return -1;
-           reloc_jmpslot(where,
-             (Elf_Addr)(defobj->relocbase + def->st_value));
-       }
-    } else {
-       const Elf_Rela *relalim;
-       const Elf_Rela *rela;
-
-       relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
-       for (rela = obj->pltrela;  rela < relalim;  rela++) {
-           Elf_Addr *where;
-           const Elf_Sym *def;
-           const Obj_Entry *defobj;
-
-           assert(ELF_R_TYPE(rela->r_info) == R_ALPHA_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)
-               return -1;
-           reloc_jmpslot(where,
-             (Elf_Addr)(defobj->relocbase + def->st_value));
-       }
-    }
-    obj->jmpslots_done = true;
-    return 0;
-}
-
-/* Fixup the jump slot at "where" to transfer control to "target". */
-void
-reloc_jmpslot(Elf_Addr *where, Elf_Addr target)
-{
-    Elf_Addr stubaddr;
-
-    dbg(" reloc_jmpslot: where=%p, target=%p", (void *)where, (void *)target);
-    stubaddr = *where;
-    if (stubaddr != target) {
-       int64_t delta;
-       u_int32_t inst[3];
-       int instct;
-       Elf_Addr pc;
-       int64_t idisp;
-       u_int32_t *stubptr;
-
-       /* Point this GOT entry directly at the target. */
-       *where = target;
-
-       /*
-        * There may be multiple GOT tables, each with an entry
-        * pointing to the stub in the PLT.  But we can only find and
-        * fix up the first GOT entry.  So we must rewrite the stub as
-        * well, to perform a call to the target if it is executed.
-        *
-        * When the stub gets control, register pv ($27) contains its
-        * address.  We adjust its value so that it points to the
-        * target, and then jump indirect through it.
-        *
-        * Each PLT entry has room for 3 instructions.  If the
-        * adjustment amount fits in a signed 32-bit integer, we can
-        * simply add it to register pv.  Otherwise we must load the
-        * GOT entry itself into the pv register.
-        */
-       delta = target - stubaddr;
-       dbg("  stubaddr=%p, where-stubaddr=%ld, delta=%ld", (void *)stubaddr,
-         (long)where - (long)stubaddr, (long)delta);
-       instct = 0;
-       if ((int32_t)delta == delta) {
-           /*
-            * We can adjust pv with a LDA, LDAH sequence.
-            *
-            * First build an LDA instruction to adjust the low 16 bits.
-            */
-           inst[instct++] = 0x08 << 26 | 27 << 21 | 27 << 16 |
-             (delta & 0xffff);
-           dbg("  LDA  $27,%d($27)", (int16_t)delta);
-           /*
-            * Adjust the delta to account for the effects of the LDA,
-            * including sign-extension.
-            */
-           delta -= (int16_t)delta;
-           if (delta != 0) {
-               /* Build an LDAH instruction to adjust the high 16 bits. */
-               inst[instct++] = 0x09 << 26 | 27 << 21 | 27 << 16 |
-                 (delta >> 16 & 0xffff);
-               dbg("  LDAH $27,%d($27)", (int16_t)(delta >> 16));
-           }
-       } else {
-           int64_t dhigh;
-
-           /* We must load the GOT entry from memory. */
-           delta = (Elf_Addr)where - stubaddr;
-           /*
-            * If the GOT entry is too far away from the PLT entry,
-            * then punt. This PLT entry will have to be looked up
-            * manually for all GOT entries except the first one.
-            * The program will still run, albeit very slowly.  It's
-            * extremely unlikely that this case could ever arise in
-            * practice, but we might as well handle it correctly if
-            * it does.
-            */
-           if ((int32_t)delta != delta) {
-               dbg("  PLT stub too far from GOT to relocate");
-               return;
-           }
-           dhigh = delta - (int16_t)delta;
-           if (dhigh != 0) {
-               /* Build an LDAH instruction to adjust the high 16 bits. */
-               inst[instct++] = 0x09 << 26 | 27 << 21 | 27 << 16 |
-                 (dhigh >> 16 & 0xffff);
-               dbg("  LDAH $27,%d($27)", (int16_t)(dhigh >> 16));
-           }
-           /* Build an LDQ to load the GOT entry. */
-           inst[instct++] = 0x29 << 26 | 27 << 21 | 27 << 16 |
-             (delta & 0xffff);
-           dbg("  LDQ  $27,%d($27)", (int16_t)delta);
-       }
-
-       /*
-        * Build a JMP or BR instruction to jump to the target.  If
-        * the instruction displacement fits in a sign-extended 21-bit
-        * field, we can use the more efficient BR instruction.
-        * Otherwise we have to jump indirect through the pv register.
-        */
-       pc = stubaddr + 4 * (instct + 1);
-       idisp = (int64_t)(target - pc) >> 2;
-       if (-0x100000 <= idisp && idisp < 0x100000) {
-           inst[instct++] = 0x30 << 26 | 31 << 21 | (idisp & 0x1fffff);
-           dbg("  BR   $31,%p", (void *)target);
-       } else {
-           inst[instct++] = 0x1a << 26 | 31 << 21 | 27 << 16 |
-             (idisp & 0x3fff);
-           dbg("  JMP  $31,($27),%d", (int)(idisp & 0x3fff));
-       }
-
-       /*
-        * Fill in the tail of the PLT entry first for reentrancy.
-        * Until we have overwritten the first instruction (an
-        * unconditional branch), the remaining instructions have no
-        * effect.
-        */
-       stubptr = (u_int32_t *)stubaddr;
-       while (instct > 1) {
-           instct--;
-           stubptr[instct] = inst[instct];
-       }
-       /*
-        * Commit the tail of the instruction sequence to memory
-        * before overwriting the first instruction.
-        */
-       __asm__ __volatile__("wmb" : : : "memory");
-       stubptr[0] = inst[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;
-}
-
-/* Initialize the special PLT entries. */
-void
-init_pltgot(Obj_Entry *obj)
-{
-       u_int32_t *pltgot;
-
-       if (obj->pltgot != NULL &&
-           (obj->pltrelsize != 0 || obj->pltrelasize != 0)) {
-               /*
-                * This function will be called to perform the relocation.
-                * Look for the ldah instruction from the old PLT format since
-                * that will tell us what format we are trying to relocate.
-                */
-               pltgot = (u_int32_t *) obj->pltgot;
-               if ((pltgot[8] & 0xffff0000) == 0x279f0000)
-                       obj->pltgot[2] = (Elf_Addr) &_rtld_bind_start_old;
-               else
-                       obj->pltgot[2] = (Elf_Addr) &_rtld_bind_start;
-               /* Identify this shared object */
-               obj->pltgot[3] = (Elf_Addr) obj;
-       }
-}
diff --git a/libexec/rtld-elf/alpha/rtld_machdep.h b/libexec/rtld-elf/alpha/rtld_machdep.h
deleted file mode 100644 (file)
index 473b3b9..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-/*-
- * 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: src/libexec/rtld-elf/alpha/rtld_machdep.h,v 1.3.2.2 2002/09/02 02:10:20 obrien Exp $
- * $DragonFly: src/libexec/rtld-elf/alpha/Attic/rtld_machdep.h,v 1.3 2003/09/18 21:22:58 dillon Exp $
- */
-
-#ifndef RTLD_MACHDEP_H
-#define RTLD_MACHDEP_H 1
-
-/* Return the address of the .dynamic section in the dynamic linker. */
-#define rtld_dynamic(obj)      (&_DYNAMIC)
-
-void reloc_jmpslot(Elf_Addr *, Elf_Addr);
-
-/* Lazy binding entry point, called via PLT. */
-void _rtld_bind_start_old(void);
-
-/* Atomic operations. */
-int cmp0_and_store_int(volatile int *, int);
-void atomic_add_int(volatile int *, int);
-void atomic_incr_int(volatile int *);
-void atomic_decr_int(volatile int *);
-
-static inline u_int32_t
-uniqid_hash_block(u_int32_t hash, u_int32_t key, u_int32_t block)
-{
-    return ((u_int64_t)hash * key + block) % 0xfffffffb;
-}
-
-#endif
diff --git a/libexec/rtld-elf/alpha/rtld_start.S b/libexec/rtld-elf/alpha/rtld_start.S
deleted file mode 100644 (file)
index d4fdad7..0000000
+++ /dev/null
@@ -1,261 +0,0 @@
-/* $FreeBSD: src/libexec/rtld-elf/alpha/rtld_start.S,v 1.3.2.2 2002/09/02 02:10:20 obrien Exp $        */
-/* $DragonFly: src/libexec/rtld-elf/alpha/Attic/rtld_start.S,v 1.2 2003/06/17 04:27:08 dillon Exp $    */
-/*     From: NetBSD: rtld_start.S,v 1.1 1996/12/16 20:38:09 cgd Exp    */
-
-/*
- * Copyright 1996 Matt Thomas <matt@3am-software.com>
- * Copyright 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.
- * 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_
-.extern        _GOT_END_
-
-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, _GOT_END_
-       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, pv
-       jsr     ra, (v0), 0     /* (*_start)(sp, cleanup, obj); */
-       ldgp    gp, 0(ra)
-
-       CALL(exit)
-       halt
-END(_rtld_start)
-
-#define        RTLD_BIND_START_PROLOGUE                                        \
-       /* at_reg already used by PLT code. */                          \
-       .set    noat                                            ;       \
-                                                                       \
-       /*                                                              \
-        * Allocate stack frame and preserve all registers that the     \
-        * caller would have normally saved themselves.                 \
-        */                                                             \
-       lda     sp, -168(sp)                                    ;       \
-       stq     ra, 0(sp)                                       ;       \
-       stq     v0, 8(sp)                                       ;       \
-       stq     t0, 16(sp)                                      ;       \
-       stq     t1, 24(sp)                                      ;       \
-       stq     t2, 32(sp)                                      ;       \
-       stq     t3, 40(sp)                                      ;       \
-       stq     t4, 48(sp)                                      ;       \
-       stq     t5, 56(sp)                                      ;       \
-       stq     t6, 64(sp)                                      ;       \
-       stq     t7, 72(sp)                                      ;       \
-       stq     a0, 80(sp)                                      ;       \
-       stq     a1, 88(sp)                                      ;       \
-       stq     a2, 96(sp)                                      ;       \
-       stq     a3, 104(sp)                                     ;       \
-       stq     a4, 112(sp)                                     ;       \
-       stq     a5, 120(sp)                                     ;       \
-       stq     t8, 128(sp)                                     ;       \
-       stq     t9, 136(sp)                                     ;       \
-       stq     t10, 144(sp)                                    ;       \
-       stq     t11, 152(sp)                                    ;       \
-       stq     gp, 160(sp)                                     ;       \
-                                                                       \
-       /*                                                              \
-        * Load our global pointer.  Note, can't use pv, since it is    \
-        * already used by the PLT code.                                \
-        */                                                             \
-       br      t0, 1f                                          ;       \
-1:     LDGP(t0)
-
-#define        RTLD_BIND_START_EPILOGUE                                        \
-       /* Move the destination address into position. */               \
-       mov     v0, pv                                          ;       \
-                                                                       \
-       /* Restore program registers. */                                \
-       ldq     ra, 0(sp)                                       ;       \
-       ldq     v0, 8(sp)                                       ;       \
-       ldq     t0, 16(sp)                                      ;       \
-       ldq     t1, 24(sp)                                      ;       \
-       ldq     t2, 32(sp)                                      ;       \
-       ldq     t3, 40(sp)                                      ;       \
-       ldq     t4, 48(sp)                                      ;       \
-       ldq     t5, 56(sp)                                      ;       \
-       ldq     t6, 64(sp)                                      ;       \
-       ldq     t7, 72(sp)                                      ;       \
-       ldq     a0, 80(sp)                                      ;       \
-       ldq     a1, 88(sp)                                      ;       \
-       ldq     a2, 96(sp)                                      ;       \
-       ldq     a3, 104(sp)                                     ;       \
-       ldq     a4, 112(sp)                                     ;       \
-       ldq     a5, 120(sp)                                     ;       \
-       ldq     t8, 128(sp)                                     ;       \
-       ldq     t9, 136(sp)                                     ;       \
-       ldq     t10, 144(sp)                                    ;       \
-       ldq     t11, 152(sp)                                    ;       \
-       ldq     gp, 160(sp)                                     ;       \
-       /* XXX LDGP? */                                                 \
-                                                                       \
-       /*                                                              \
-        * We've patched the PLT; sync the I-stream.                    \
-        */                                                             \
-       imb                                                     ;       \
-                                                                       \
-       /* Pop the stack frame and turn control to the destination. */  \
-       lda     sp, 168(sp)                                     ;       \
-       jmp     zero, (pv)
-
-
-/*
- * Lazy binding entry point, called via PLT.
- */
-NESTED_NOPROFILE(_rtld_bind_start, 0, 168, ra, 0, 0)
-
-       RTLD_BIND_START_PROLOGUE
-
-       /* Set up the arguments for _rtld_bind. */
-       subq    at_reg, pv, a1          /* calculate reloc offset */
-       ldq     a0, 8(pv)               /* object structure */
-       subq    a1, 20, a1              /* = (at - t11 - 20) / 12 * 24 */
-       addq    a1, a1, a1
-
-       CALL(_rtld_bind)
-
-       RTLD_BIND_START_EPILOGUE
-
-END(_rtld_bind_start)
-
-/*
- * Lazy binding entry point, called via PLT.  This version is for the
- * old PLT entry format.
- */
-NESTED_NOPROFILE(_rtld_bind_start_old, 0, 168, ra, 0, 0)
-
-       RTLD_BIND_START_PROLOGUE
-
-       /* Set up the arguments for _rtld_bind. */
-       ldq     a0, 8(pv)               /* object structure */
-       mov     at_reg, a1              /* offset of reloc entry */
-
-       CALL(_rtld_bind)
-
-       RTLD_BIND_START_EPILOGUE
-
-END(_rtld_bind_start_old)
-
-/*
- * int cmp0_and_store_int(volatile int *p, int newval);
- *
- * If an int holds 0, store newval into it; else do nothing.  Returns
- * the previous value.
- */
-LEAF(cmp0_and_store_int, 2)
-1:     mov     a1, t0
-       ldl_l   v0, 0(a0)
-       bne     v0, 3f
-       stl_c   t0, 0(a0)
-       beq     t0, 2f
-       mb
-       RET
-2:     br      1b
-3:     RET
-END(cmp0_and_store_int)
-
-LEAF(atomic_add_int, 2)
-0:     ldl_l   t0, 0(a0)
-       addq    t0, a1, t0
-       stl_c   t0, 0(a0)
-       beq     t0, 1f
-       mb
-       RET
-1:     br      0b
-END(atomic_add_int)
-/* Atomically increment an int. */
-LEAF(atomic_incr_int, 1)
-0:     ldl_l   t0, 0(a0)
-       addq    t0, 1, t0
-       stl_c   t0, 0(a0)
-       beq     t0, 1f
-       mb
-       RET
-1:     br      0b
-END(atomic_incr_int)
-
-/* Atomically decrement an int. */
-LEAF(atomic_decr_int, 1)
-0:     ldl_l   t0, 0(a0)
-       subq    t0, 1, t0
-       stl_c   t0, 0(a0)
-       beq     t0, 1f
-       mb
-       RET
-1:     br      0b
-END(atomic_decr_int)