sysdeps/m68k/dl-machine.h

   1 /* Machine-dependent ELF dynamic relocation inline functions.  m68k version.
   2    Copyright (C) 1996 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If
  17    not, write to the Free Software Foundation, Inc.,
  18    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #ifndef dl_machine_h
  21 #define dl_machine_h
  22
  23 #define ELF_MACHINE_NAME "m68k"
  24
  25 #include <assert.h>
  26
  27 /* Return nonzero iff E_MACHINE is compatible with the running host.  */
  28 static inline int
  29 elf_machine_matches_host (Elf32_Half e_machine)
  30 {
  31   switch (e_machine)
  32     {
  33     case EM_68K:
  34       return 1;
  35     default:
  36       return 0;
  37     }
  38 }
  39
  40
  41 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
  42    first element of the GOT.  This must be inlined in a function which
  43    uses global data.  */
  44 static inline Elf32_Addr
  45 elf_machine_dynamic (void)
  46 {
  47   register Elf32_Addr *got asm ("%a5");
  48   return *got;
  49 }
  50
  51
  52 /* Return the run-time load address of the shared object.  */
  53 static inline Elf32_Addr
  54 elf_machine_load_address (void)
  55 {
  56   Elf32_Addr addr;
  57   asm ("here:   lea here(%%pc), %0\n"
  58        "        sub.l %#here, %0"
  59        : "=a" (addr));
  60   return addr;
  61 }
  62
  63 /* The `subl' insn above will contain an R_68K_RELATIVE relocation
  64    entry intended to insert the run-time address of the label `here'.
  65    This will be the first relocation in the text of the dynamic
  66    linker; we skip it to avoid trying to modify read-only text in this
  67    early stage.  */
  68 #define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) \
  69   ((dynamic_info)[DT_RELA]->d_un.d_ptr += sizeof (Elf32_Rela), \
  70    (dynamic_info)[DT_RELASZ]->d_un.d_val -= sizeof (Elf32_Rela))
  71
  72
  73 /* Set up the loaded object described by L so its unrelocated PLT
  74    entries will jump to the on-demand fixup code in dl-runtime.c.  */
  75
  76 static inline void
  77 elf_machine_runtime_setup (struct link_map *l, int lazy)
  78 {
  79   Elf32_Addr *got;
  80   extern void _dl_runtime_resolve (Elf32_Word);
  81
  82   if (l->l_info[DT_JMPREL] && lazy)
  83     {
  84       /* The GOT entries for functions in the PLT have not yet been
  85          filled in.  Their initial contents will arrange when called
  86          to push an offset into the .rela.plt section, push
  87          _GLOBAL_OFFSET_TABLE_[1], and then jump to
  88          _GLOBAL_OFFSET_TABLE_[2].  */
  89       got = (Elf32_Addr *) (l->l_addr + l->l_info[DT_PLTGOT]->d_un.d_ptr);
  90       got[1] = (Elf32_Addr) l;  /* Identify this shared object.  */
  91       /* This function will get called to fix up the GOT entry
  92          indicated by the offset on the stack, and then jump to the
  93          resolved address.  */
  94       got[2] = (Elf32_Addr) &_dl_runtime_resolve;
  95     }
  96
  97   /* This code is used in dl-runtime.c to call the `fixup' function
  98      and then redirect to the address it returns.  */
  99 #define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\
 100 | Trampoline for _dl_runtime_resolver
 101         .globl _dl_runtime_resolve
 102         .type _dl_runtime_resolve, @function
 103 _dl_runtime_resolve:
 104         | Save %a0 (struct return address) and %a1.
 105         move.l %a0, -(%sp)
 106         move.l %a1, -(%sp)
 107         | Call the real address resolver.
 108         jbsr fixup
 109         | Restore register %a0 and %a1.
 110         move.l (%sp)+, %a1
 111         move.l (%sp)+, %a0
 112         | Pop parameters
 113         addq.l #8, %sp
 114         | Call real function.
 115         jmp (%d0)
 116         .size _dl_runtime_resolve, . - _dl_runtime_resolve
 117 ");
 118 #define ELF_MACHINE_RUNTIME_FIXUP_ARGS long int save_a0, long int save_a1
 119 /* The PLT uses Elf32_Rela relocs.  */
 120 #define elf_machine_relplt elf_machine_rela
 121 }
 122
 123
 124 /* Mask identifying addresses reserved for the user program,
 125    where the dynamic linker should not map anything.  */
 126 #define ELF_MACHINE_USER_ADDRESS_MASK   0x80000000UL
 127
 128 /* Initial entry point code for the dynamic linker.
 129    The C function `_dl_start' is the real entry point;
 130    its return value is the user program's entry point.  */
 131
 132 #define RTLD_START asm ("\
 133 .text
 134 .globl _start
 135 .globl _dl_start_user
 136 _start:
 137         move.l %sp, -(%sp)
 138         jbsr _dl_start
 139         addq.l #4, %sp
 140 _dl_start_user:
 141         | Save the user entry point address in %a4.
 142         move.l %d0, %a4
 143         | Point %a5 at the GOT.
 144         lea _GLOBAL_OFFSET_TABLE_@GOTPC(%pc), %a5
 145         | See if we were run as a command with the executable file
 146         | name as an extra leading argument.
 147         move.l ([_dl_skip_args@GOT, %a5]), %d0
 148         jeq 0f
 149         | Pop the original argument count
 150         move.l (%sp)+, %d1
 151         | Subtract _dl_skip_args from it.
 152         sub.l %d0, %d1
 153         | Adjust the stack pointer to skip _dl_skip_args words.
 154         lea (%sp, %d0*4), %sp
 155         | Push back the modified argument count.
 156         move.l %d1, -(%sp)
 157 0:      | Push _dl_default_scope[2] as argument in _dl_init_next call below.
 158         move.l ([_dl_default_scope@GOT, %a5], 8), %d2
 159 0:      move.l %d2, -(%sp)
 160         | Call _dl_init_next to return the address of an initializer
 161         | function to run.
 162         bsr.l _dl_init_next@PLTPC
 163         add.l #4, %sp | Pop argument.
 164         | Check for zero return, when out of initializers.
 165         tst.l %d0
 166         jeq 1f
 167         | Call the shared object initializer function.
 168         | NOTE: We depend only on the registers (%d2, %a4 and %a5)
 169         | and the return address pushed by this call;
 170         | the initializer is called with the stack just
 171         | as it appears on entry, and it is free to move
 172         | the stack around, as long as it winds up jumping to
 173         | the return address on the top of the stack.
 174         move.l %d0, %a0
 175         jsr (%a0)
 176         | Loop to call _dl_init_next for the next initializer.
 177         jra 0b
 178 1:      | Clear the startup flag.
 179         clr.l _dl_starting_up@GOT(%a5)
 180         | Pass our finalizer function to the user in %a1.
 181         move.l _dl_fini@GOT(%a5), %a1
 182         | Initialize %fp with the stack pointer.
 183         move.l %sp, %fp
 184         | Jump to the user's entry point.
 185         jmp (%a4)");
 186
 187 /* Nonzero iff TYPE describes relocation of a PLT entry, so
 188    PLT entries should not be allowed to define the value.  */
 189 #define elf_machine_pltrel_p(type) ((type) == R_68K_JMP_SLOT)
 190
 191 /* The m68k never uses Elf32_Rel relocations.  */
 192 #define ELF_MACHINE_NO_REL 1
 193
 194 #endif /* !dl_machine_h */
 195
 196 #ifdef RESOLVE
 197
 198 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 199    MAP is the object containing the reloc.  */
 200
 201 static inline void
 202 elf_machine_rela (struct link_map *map,
 203                   const Elf32_Rela *reloc, const Elf32_Sym *sym)
 204 {
 205   Elf32_Addr *const reloc_addr = (void *) (map->l_addr + reloc->r_offset);
 206   Elf32_Addr loadbase;
 207
 208   switch (ELF32_R_TYPE (reloc->r_info))
 209     {
 210     case R_68K_COPY:
 211       loadbase = RESOLVE (&sym, DL_LOOKUP_NOEXEC);
 212       memcpy (reloc_addr, (void *) (loadbase + sym->st_value), sym->st_size);
 213       break;
 214     case R_68K_GLOB_DAT:
 215       loadbase = RESOLVE (&sym, 0);
 216       *reloc_addr = sym ? (loadbase + sym->st_value) : 0;
 217       break;
 218     case R_68K_JMP_SLOT:
 219       loadbase = RESOLVE (&sym, DL_LOOKUP_NOPLT);
 220       *reloc_addr = sym ? (loadbase + sym->st_value) : 0;
 221       break;
 222     case R_68K_8:
 223       loadbase = RESOLVE (&sym, 0);
 224       *(char *) reloc_addr = ((sym ? (loadbase + sym->st_value) : 0)
 225                               + reloc->r_addend);
 226       break;
 227     case R_68K_16:
 228       loadbase = RESOLVE (&sym, 0);
 229       *(short *) reloc_addr = ((sym ? (loadbase + sym->st_value) : 0)
 230                                + reloc->r_addend);
 231       break;
 232     case R_68K_32:
 233       loadbase = RESOLVE (&sym, 0);
 234       *reloc_addr = ((sym ? (loadbase + sym->st_value) : 0)
 235                      + reloc->r_addend);
 236       break;
 237     case R_68K_RELATIVE:
 238       *reloc_addr = map->l_addr + reloc->r_addend;
 239       break;
 240     case R_68K_PC8:
 241       loadbase = RESOLVE (&sym, 0);
 242       *(char *) reloc_addr = ((sym ? (loadbase + sym->st_value) : 0)
 243                               + reloc->r_addend - (Elf32_Addr) reloc_addr);
 244       break;
 245     case R_68K_PC16:
 246       loadbase = RESOLVE (&sym, 0);
 247       *(short *) reloc_addr = ((sym ? (loadbase + sym->st_value) : 0)
 248                                + reloc->r_addend - (Elf32_Addr) reloc_addr);
 249       break;
 250     case R_68K_PC32:
 251       loadbase = RESOLVE (&sym, 0);
 252       *reloc_addr = ((sym ? (loadbase + sym->st_value) : 0)
 253                      + reloc->r_addend - (Elf32_Addr) reloc_addr);
 254       break;
 255     case R_68K_NONE:            /* Alright, Wilbur.  */
 256       break;
 257     default:
 258       assert (! "unexpected dynamic reloc type");
 259       break;
 260     }
 261 }
 262
 263 static inline void
 264 elf_machine_lazy_rel (struct link_map *map, const Elf32_Rela *reloc)
 265 {
 266   Elf32_Addr *const reloc_addr = (void *) (map->l_addr + reloc->r_offset);
 267   switch (ELF32_R_TYPE (reloc->r_info))
 268     {
 269     case R_68K_JMP_SLOT:
 270       *reloc_addr += map->l_addr;
 271       break;
 272     default:
 273       assert (! "unexpected PLT reloc type");
 274       break;
 275     }
 276 }
 277
 278 #endif /* RESOLVE */