Tue Jul 16 00:31:31 1996 Richard Henderson <rth@tamu.edu>
authorroland <roland>
Tue, 16 Jul 1996 06:12:11 +0000 (06:12 +0000)
committerroland <roland>
Tue, 16 Jul 1996 06:12:11 +0000 (06:12 +0000)
* sysdeps/alpha/dl-machine.h: Mirror Roland's changes to
i386/dl-machine.h of 960713.

sysdeps/alpha/dl-machine.h

index 8986ed7..b900b76 100644 (file)
@@ -18,14 +18,16 @@ License along with the GNU C Library; see the file COPYING.LIB.  If
 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
 Cambridge, MA 02139, USA.  */
 
-/* This was written in the absense of an ABI -- don't expect
+/* This was written in the absence of an ABI -- don't expect
    it to remain unchanged.  */
 
+#ifndef dl_machine_h
+#define dl_machine_h 1
+
 #define ELF_MACHINE_NAME "alpha"
 
 #include <assert.h>
 #include <string.h>
-#include <link.h>
 
 
 /* Return nonzero iff E_MACHINE is compatible with the running host.  */
@@ -35,7 +37,6 @@ elf_machine_matches_host (Elf64_Word e_machine)
   return e_machine == EM_ALPHA;
 }
 
-
 /* Return the run-time address of the _GLOBAL_OFFSET_TABLE_.
    Must be inlined in a function which uses global data.  */
 static inline Elf64_Addr *
@@ -45,7 +46,6 @@ elf_machine_got (void)
   return (Elf64_Addr *)(gp - 0x8000);
 }
 
-
 /* Return the run-time load address of the shared object.  */
 static inline Elf64_Addr
 elf_machine_load_address (void)
@@ -78,6 +78,164 @@ elf_machine_load_address (void)
   return dot + 4 + zero_disp;
 }
 
+/* Set up the loaded object described by L so its unrelocated PLT
+   entries will jump to the on-demand fixup code in dl-runtime.c.  */
+
+static inline void
+elf_machine_runtime_setup (struct link_map *l, int lazy)
+{
+  Elf64_Addr plt;
+  extern void _dl_runtime_resolve (void);
+
+  if (l->l_info[DT_JMPREL] && lazy)
+    {
+      /* The GOT entries for the functions in the PLT have not been
+        filled in yet.  Their initial contents are directed to the
+        PLT which arranges for the dynamic linker to be called.  */
+      plt = l->l_addr + l->l_info[DT_PLTGOT]->d_un.d_ptr;
+
+      /* This function will be called to perform the relocation.  */
+      *(Elf64_Addr *)(plt + 16) = (Elf64_Addr) &_dl_runtime_resolve;
+
+      /* Identify this shared object */
+      *(Elf64_Addr *)(plt + 24) = (Elf64_Addr) l;
+    }
+}
+
+/* This code is used in dl-runtime.c to call the `fixup' function
+   and then redirect to the address it returns.  */
+#define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ( \
+"/* Trampoline for _dl_runtime_resolver */
+       .globl _dl_runtime_resolve
+       .ent _dl_runtime_resolve
+_dl_runtime_resolve:
+       lda     $sp, -168($sp)
+       .frame  $sp, 168, $26
+       /* Preserve all registers that C normally doesn't.  */
+       stq     $26, 0($sp)
+       stq     $0, 8($sp)
+       stq     $1, 16($sp)
+       stq     $2, 24($sp)
+       stq     $3, 32($sp)
+       stq     $4, 40($sp)
+       stq     $5, 48($sp)
+       stq     $6, 56($sp)
+       stq     $7, 64($sp)
+       stq     $8, 72($sp)
+       stq     $16, 80($sp)
+       stq     $17, 88($sp)
+       stq     $18, 96($sp)
+       stq     $19, 104($sp)
+       stq     $20, 112($sp)
+       stq     $21, 120($sp)
+       stq     $22, 128($sp)
+       stq     $23, 136($sp)
+       stq     $24, 144($sp)
+       stq     $25, 152($sp)
+       stq     $29, 160($sp)
+       .mask   0x27ff01ff, -168
+       /* Set up our $gp */
+       br      $gp, .+4
+       ldgp    $gp, 0($gp)
+       .prologue 1
+       /* Set up the arguments for _dl_runtime_resolve. */
+       /* $16 = link_map out of plt0 */
+       ldq     $16, 8($27)
+       /* $17 = offset of reloc entry */
+       mov     $28, $17
+       /* Do the fixup */
+       bsr     $26, fixup..ng
+       /* Move the destination address to a safe place.  */
+       mov     $0, $27
+       /* Restore program registers.  */
+       ldq     $26, 0($sp)
+       ldq     $0, 8($sp)
+       ldq     $1, 16($sp)
+       ldq     $2, 24($sp)
+       ldq     $3, 32($sp)
+       ldq     $4, 40($sp)
+       ldq     $5, 48($sp)
+       ldq     $6, 56($sp)
+       ldq     $7, 64($sp)
+       ldq     $8, 72($sp)
+       ldq     $16, 80($sp)
+       ldq     $17, 88($sp)
+       ldq     $18, 96($sp)
+       ldq     $19, 104($sp)
+       ldq     $20, 112($sp)
+       ldq     $21, 120($sp)
+       ldq     $22, 128($sp)
+       ldq     $23, 136($sp)
+       ldq     $24, 144($sp)
+       ldq     $25, 152($sp)
+       ldq     $29, 160($sp)
+       /* Clean up and turn control to the destination */
+       lda     $sp, 168($sp)
+       jmp     $31, ($27)
+       .end _dl_runtime_resolve");
+
+/* The PLT uses Elf_Rel relocs.  */
+#define elf_machine_relplt elf_machine_rela
+
+/* Mask identifying addresses reserved for the user program,
+   where the dynamic linker should not map anything.  */
+/* FIXME */
+#define ELF_MACHINE_USER_ADDRESS_MASK  (~0x1FFFFFFFFUL)
+
+/* Initial entry point code for the dynamic linker.
+   The C function `_dl_start' is the real entry point;
+   its return value is the user program's entry point.  */
+
+#define RTLD_START asm ("\
+.text
+       .globl _start
+       .globl _dl_start_user
+_start:
+       br      $gp,.+4
+       ldgp    $gp, 0($gp)
+       /* Pass pointer to argument block to _dl_start.  */
+       mov     $sp, $16
+       bsr     $26, _dl_start..ng
+_dl_start_user:
+       /* Save the user entry point address in s0.  */
+       mov     $0, $9
+       /* See if we were run as a command with the executable file
+          name as an extra leading argument.  If so, adjust the stack
+          pointer to skip _dl_skip_args words.  */
+       ldl     $1, _dl_skip_args
+       beq     $1, 0f
+       ldq     $2, 0($sp)
+       subq    $2, $1, $2
+       s8addq  $1, $sp, $sp
+       stq     $2, 0($sp)
+       /* Load _dl_default_scope[2] into s1 to pass to _dl_init_next.  */
+0:     ldq     $10, _dl_default_scope+16
+       /* Call _dl_init_next to return the address of an initalizer
+          function to run.  */
+1:     mov     $10, $16
+       jsr     $26, _dl_init_next
+       ldgp    $gp, 0($26)
+       beq     $0, 2f
+       mov     $0, $27
+       jsr     $26, ($0)
+       ldgp    $gp, 0($26)
+       br      1b
+2:     /* Pass our finalizer function to the user in $0. */
+       lda     $0, _dl_fini
+       /* Jump to the user's entry point.  */
+       mov     $9, $27
+       jmp     ($9)");
+
+/* Nonzero iff TYPE describes relocation of a PLT entry, so 
+   PLT entries should not be allowed to define the value.  */
+#define elf_machine_pltrel_p(type)  ((type) == R_ALPHA_JMP_SLOT)
+
+/* The alpha never uses Elf64_Rel relocations.  */
+#define ELF_MACHINE_NO_REL 1
+
+#endif /* !dl_machine_h */
+
+#ifdef RESOLVE
 
 /* Fix up the instructions of a PLT entry to invoke the function
    rather than the dynamic linker.  */
@@ -154,13 +312,11 @@ elf_alpha_fix_plt(struct link_map *l,
 static inline void
 elf_machine_rela (struct link_map *map,
                  const Elf64_Rela *reloc,
-                 const Elf64_Sym *sym,
-                 Elf64_Addr (*resolve) (const Elf64_Sym **ref,
-                                        Elf64_Addr reloc_addr,
-                                        int noplt))
+                 const Elf64_Sym *sym)
 {
-  Elf64_Addr *const reloc_addr = (void *)(map->l_addr + reloc->r_offset);
-  unsigned long r_info = ELF64_R_TYPE (reloc->r_info);
+  Elf64_Addr * const reloc_addr = (void *)(map->l_addr + reloc->r_offset);
+  unsigned long const r_info = ELF64_R_TYPE (reloc->r_info);
+
 #ifndef RTLD_BOOTSTRAP
   /* This is defined in rtld.c, but nowhere in the static libc.a; make the
      reference weak so static programs can still link.  This declaration
@@ -175,8 +331,8 @@ elf_machine_rela (struct link_map *map,
 
   if (r_info == R_ALPHA_RELATIVE)
     {
-      /* Already done in dynamic linker.  */
 #ifndef RTLD_BOOTSTRAP
+      /* Already done in dynamic linker.  */
       if (map != &_dl_rtld_map)
 #endif
        *reloc_addr += map->l_addr;
@@ -187,12 +343,8 @@ elf_machine_rela (struct link_map *map,
     {
       Elf64_Addr loadbase, sym_value;
 
-#ifndef RTLD_BOOTSTRAP
-      loadbase = (*resolve)(&sym, (Elf64_Addr)reloc_addr,
-                           r_info == R_ALPHA_JMP_SLOT);
-#else
-      loadbase = map->l_addr;
-#endif
+      loadbase = RESOLVE (&sym, (Elf64_Addr)reloc_addr,
+                         r_info == R_ALPHA_JMP_SLOT);
       sym_value = sym ? loadbase + sym->st_value : 0;
 
       if (r_info == R_ALPHA_GLOB_DAT)
@@ -233,8 +385,8 @@ elf_machine_rela (struct link_map *map,
 static inline void
 elf_machine_lazy_rel (struct link_map *map, const Elf64_Rela *reloc)
 {
-  Elf64_Addr *const reloc_addr = (void *)(map->l_addr + reloc->r_offset);
-  unsigned long r_info = ELF64_R_TYPE (reloc->r_info);
+  Elf64_Addr * const reloc_addr = (void *)(map->l_addr + reloc->r_offset);
+  unsigned long const r_info = ELF64_R_TYPE (reloc->r_info);
 
   if (r_info == R_ALPHA_JMP_SLOT)
     {
@@ -243,159 +395,9 @@ elf_machine_lazy_rel (struct link_map *map, const Elf64_Rela *reloc)
       *reloc_addr += map->l_addr;
     }
   else if (r_info == R_ALPHA_NONE)
-    ;
+    return;
   else
     assert (! "unexpected PLT reloc type");
 }
 
-/* The alpha never uses Elf_Rel relocations.  */
-#define ELF_MACHINE_NO_REL 1
-
-
-/* Set up the loaded object described by L so its unrelocated PLT
-   entries will jump to the on-demand fixup code in dl-runtime.c.  */
-
-static inline void
-elf_machine_runtime_setup (struct link_map *l, int lazy)
-{
-  Elf64_Addr plt;
-  extern void _dl_runtime_resolve (void);
-
-  if (l->l_info[DT_JMPREL] && lazy)
-    {
-      /* The GOT entries for the functions in the PLT have not been
-        filled in yet.  Their initial contents are directed to the
-        PLT which arranges for the dynamic linker to be called.  */
-      plt = l->l_addr + l->l_info[DT_PLTGOT]->d_un.d_ptr;
-
-      /* This function will be called to perform the relocation.  */
-      *(Elf64_Addr *)(plt + 16) = (Elf64_Addr) &_dl_runtime_resolve;
-
-      /* Identify this shared object */
-      *(Elf64_Addr *)(plt + 24) = (Elf64_Addr) l;
-    }
-}
-
-/* This code is used in dl-runtime.c to call the `fixup' function
-   and then redirect to the address it returns.  */
-#define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ( \
-"/* Trampoline for _dl_runtime_resolver */
-       .globl _dl_runtime_resolve
-       .ent _dl_runtime_resolve
-_dl_runtime_resolve:
-       lda     $sp, -168($sp)
-       .frame  $sp, 168, $26
-       /* Preserve all registers that C normally doesn't.  */
-       stq     $26, 0($sp)
-       stq     $0, 8($sp)
-       stq     $1, 16($sp)
-       stq     $2, 24($sp)
-       stq     $3, 32($sp)
-       stq     $4, 40($sp)
-       stq     $5, 48($sp)
-       stq     $6, 56($sp)
-       stq     $7, 64($sp)
-       stq     $8, 72($sp)
-       stq     $16, 80($sp)
-       stq     $17, 88($sp)
-       stq     $18, 96($sp)
-       stq     $19, 104($sp)
-       stq     $20, 112($sp)
-       stq     $21, 120($sp)
-       stq     $22, 128($sp)
-       stq     $23, 136($sp)
-       stq     $24, 144($sp)
-       stq     $25, 152($sp)
-       stq     $29, 160($sp)
-       .mask   0x27ff01ff, -168
-       /* Set up our $gp */
-       br      $gp, .+4
-       ldgp    $gp, 0($gp)
-       .prologue 1
-       /* Set up the arguments for _dl_runtime_resolve. */
-       /* $16 = link_map out of plt0 */
-       ldq     $16, 8($27)
-       /* $17 = offset of reloc entry */
-       mov     $28, $17
-       /* Do the fixup */
-       bsr     $26, fixup..ng
-       /* Move the destination address to a safe place.  */
-       mov     $0, $27
-       /* Restore program registers.  */
-       ldq     $26, 0($sp)
-       ldq     $0, 8($sp)
-       ldq     $1, 16($sp)
-       ldq     $2, 24($sp)
-       ldq     $3, 32($sp)
-       ldq     $4, 40($sp)
-       ldq     $5, 48($sp)
-       ldq     $6, 56($sp)
-       ldq     $7, 64($sp)
-       ldq     $8, 72($sp)
-       ldq     $16, 80($sp)
-       ldq     $17, 88($sp)
-       ldq     $18, 96($sp)
-       ldq     $19, 104($sp)
-       ldq     $20, 112($sp)
-       ldq     $21, 120($sp)
-       ldq     $22, 128($sp)
-       ldq     $23, 136($sp)
-       ldq     $24, 144($sp)
-       ldq     $25, 152($sp)
-       ldq     $29, 160($sp)
-       /* Clean up and turn control to the destination */
-       lda     $sp, 168($sp)
-       jmp     $31, ($27)
-       .end _dl_runtime_resolve");
-
-/* The PLT uses Elf_Rel relocs.  */
-#define elf_machine_relplt elf_machine_rela
-
-/* Mask identifying addresses reserved for the user program,
-   where the dynamic linker should not map anything.  */
-/* FIXME */
-#define ELF_MACHINE_USER_ADDRESS_MASK  (~0x1FFFFFFFFUL)
-
-/* Initial entry point code for the dynamic linker.
-   The C function `_dl_start' is the real entry point;
-   its return value is the user program's entry point.  */
-
-#define RTLD_START asm ("\
-.text
-       .globl _start
-       .globl _dl_start_user
-_start:
-       br      $gp,.+4
-       ldgp    $gp, 0($gp)
-       /* Pass pointer to argument block to _dl_start.  */
-       mov     $sp, $16
-       bsr     $26, _dl_start..ng
-_dl_start_user:
-       /* Save the user entry point address in s0.  */
-       mov     $0, $9
-       /* See if we were run as a command with the executable file
-          name as an extra leading argument.  If so, adjust the stack
-          pointer to skip _dl_skip_args words.  */
-       ldl     $1, _dl_skip_args
-       beq     $1, 0f
-       ldq     $2, 0($sp)
-       subq    $2, $1, $2
-       s8addq  $1, $sp, $sp
-       stq     $2, 0($sp)
-       /* Load _dl_default_scope[2] into s1 to pass to _dl_init_next.  */
-0:     ldq     $10, _dl_default_scope+16
-       /* Call _dl_init_next to return the address of an initalizer
-          function to run.  */
-1:     mov     $10, $16
-       jsr     $26, _dl_init_next
-       ldgp    $gp, 0($26)
-       beq     $0, 2f
-       mov     $0, $27
-       jsr     $26, ($0)
-       ldgp    $gp, 0($26)
-       br      1b
-2:     /* Pass our finalizer function to the user in $0. */
-       lda     $0, _dl_fini
-       /* Jump to the user's entry point.  */
-       mov     $9, $27
-       jmp     ($9)");
+#endif /* RESOLVE */