sysdeps/arm/dl-machine.h

   1 /* Machine-dependent ELF dynamic relocation inline functions.  ARM version.
   2    Copyright (C) 1995, 1996, 1997, 1998, 1999 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 not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #ifndef dl_machine_h
  21 #define dl_machine_h
  22
  23 #define ELF_MACHINE_NAME "ARM"
  24
  25 #include <sys/param.h>
  26
  27 #define VALID_ELF_ABIVERSION(ver)       (ver == 0)
  28 #define VALID_ELF_OSABI(osabi) \
  29   (osabi == ELFOSABI_SYSV || osabi == ELFOSABI_ARM)
  30 #define VALID_ELF_HEADER(hdr,exp,size) \
  31   memcmp (hdr,exp,size-2) == 0 \
  32   && VALID_ELF_OSABI (hdr[EI_OSABI]) \
  33   && VALID_ELF_ABIVERSION (hdr[EI_ABIVERSION])
  34
  35 /* Return nonzero iff E_MACHINE is compatible with the running host.  */
  36 static inline int __attribute__ ((unused))
  37 elf_machine_matches_host (Elf32_Half e_machine)
  38 {
  39   switch (e_machine)
  40     {
  41     case EM_ARM:
  42       return 1;
  43     default:
  44       return 0;
  45     }
  46 }
  47
  48
  49 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
  50    first element of the GOT.  This must be inlined in a function which
  51    uses global data.  */
  52 static inline Elf32_Addr __attribute__ ((unused))
  53 elf_machine_dynamic (void)
  54 {
  55   register Elf32_Addr *got asm ("r10");
  56   return *got;
  57 }
  58
  59
  60 /* Return the run-time load address of the shared object.  */
  61 static inline Elf32_Addr __attribute__ ((unused))
  62 elf_machine_load_address (void)
  63 {
  64   extern void __dl_start asm ("_dl_start");
  65   Elf32_Addr got_addr = (Elf32_Addr) &__dl_start;
  66   Elf32_Addr pcrel_addr;
  67   asm ("adr %0, _dl_start" : "=r" (pcrel_addr));
  68   return pcrel_addr - got_addr;
  69 }
  70
  71
  72 /* Set up the loaded object described by L so its unrelocated PLT
  73    entries will jump to the on-demand fixup code in dl-runtime.c.  */
  74
  75 static inline int __attribute__ ((unused))
  76 elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
  77 {
  78   Elf32_Addr *got;
  79   extern void _dl_runtime_resolve (Elf32_Word);
  80   extern void _dl_runtime_profile (Elf32_Word);
  81
  82   if (l->l_info[DT_JMPREL] && lazy)
  83     {
  84       /* patb: this is different than i386 */
  85       /* The GOT entries for functions in the PLT have not yet been filled
  86          in.  Their initial contents will arrange when called to push an
  87          index into the .got section, load ip with &_GLOBAL_OFFSET_TABLE_[3],
  88          and then jump to _GLOBAL_OFFSET_TABLE[2].  */
  89       got = (Elf32_Addr *) l->l_info[DT_PLTGOT]->d_un.d_ptr;
  90       got[1] = (Elf32_Addr) l;  /* Identify this shared object.  */
  91
  92       /* The got[2] entry contains the address of a function which gets
  93          called to get the address of a so far unresolved function and
  94          jump to it.  The profiling extension of the dynamic linker allows
  95          to intercept the calls to collect information.  In this case we
  96          don't store the address in the GOT so that all future calls also
  97          end in this function.  */
  98       if (profile)
  99         {
 100           got[2] = (Elf32_Addr) &_dl_runtime_profile;
 101           /* Say that we really want profiling and the timers are started.  */
 102           _dl_profile_map = l;
 103         }
 104       else
 105         /* This function will get called to fix up the GOT entry indicated by
 106            the offset on the stack, and then jump to the resolved address.  */
 107         got[2] = (Elf32_Addr) &_dl_runtime_resolve;
 108     }
 109   return lazy;
 110 }
 111
 112 /* This code is used in dl-runtime.c to call the `fixup' function
 113    and then redirect to the address it returns.  */
 114    // macro for handling PIC situation....
 115 #ifdef PIC
 116 #define CALL_ROUTINE(x) " ldr sl,0f
 117         add     sl, pc, sl
 118 1:      ldr     r2, 2f
 119         mov     lr, pc
 120         add     pc, sl, r2
 121         b       3f
 122 0:      .word   _GLOBAL_OFFSET_TABLE_ - 1b - 4
 123 2:      .word " #x "(GOTOFF)
 124 3:      "
 125 #else
 126 #define CALL_ROUTINE(x) " bl " #x
 127 #endif
 128
 129 #ifndef PROF
 130 # define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\
 131         .text
 132         .globl _dl_runtime_resolve
 133         .type _dl_runtime_resolve, #function
 134         .align 2
 135 _dl_runtime_resolve:
 136         @ we get called with
 137         @       stack[0] contains the return address from this call
 138         @       ip contains &GOT[n+3] (pointer to function)
 139         @       lr points to &GOT[2]
 140
 141         @ save almost everything; lr is already on the stack
 142         stmdb   sp!,{r0-r3,sl,fp}
 143
 144         @ prepare to call fixup()
 145         @ change &GOT[n+3] into 8*n        NOTE: reloc are 8 bytes each
 146         sub     r1, ip, lr
 147         sub     r1, r1, #4
 148         add     r1, r1, r1
 149
 150         @ get pointer to linker struct
 151         ldr     r0, [lr, #-4]
 152
 153         @ call fixup routine
 154         " CALL_ROUTINE(fixup) "
 155
 156         @ save the return
 157         mov     ip, r0
 158
 159         @ restore the stack
 160         ldmia   sp!,{r0-r3,sl,fp,lr}
 161
 162         @ jump to the newly found address
 163         mov     pc, ip
 164
 165         .size _dl_runtime_resolve, .-_dl_runtime_resolve
 166
 167         .globl _dl_runtime_profile
 168         .type _dl_runtime_profile, #function
 169         .align 2
 170 _dl_runtime_profile:
 171         @ save almost everything; lr is already on the stack
 172         stmdb   sp!,{r0-r3,sl,fp}
 173
 174         @ prepare to call fixup()
 175         @ change &GOT[n+3] into 8*n        NOTE: reloc are 8 bytes each
 176         sub     r1, ip, lr
 177         sub     r1, r1, #4
 178         add     r1, r1, r1
 179
 180         @ get pointer to linker struct
 181         ldr     r0, [lr, #-4]
 182
 183         @ call profiling fixup routine
 184         " CALL_ROUTINE(profile_fixup) "
 185
 186         @ save the return
 187         mov     ip, r0
 188
 189         @ restore the stack
 190         ldmia   sp!,{r0-r3,sl,fp,lr}
 191
 192         @ jump to the newly found address
 193         mov     pc, ip
 194
 195         .size _dl_runtime_resolve, .-_dl_runtime_resolve
 196         .previous
 197 ");
 198 #else // PROF
 199 # define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\
 200         .text
 201         .globl _dl_runtime_resolve
 202         .globl _dl_runtime_profile
 203         .type _dl_runtime_resolve, #function
 204         .type _dl_runtime_profile, #function
 205         .align 2
 206 _dl_runtime_resolve:
 207 _dl_runtime_profile:
 208         @ we get called with
 209         @       stack[0] contains the return address from this call
 210         @       ip contains &GOT[n+3] (pointer to function)
 211         @       lr points to &GOT[2]
 212
 213         @ save almost everything; return add is already on the stack
 214         stmdb   sp!,{r0-r3,sl,fp}
 215
 216         @ prepare to call fixup()
 217         @ change &GOT[n+3] into 8*n        NOTE: reloc are 8 bytes each
 218         sub     r1, ip, lr
 219         sub     r1, r1, #4
 220         add     r1, r1, r1
 221
 222         @ get pointer to linker struct
 223         ldr     r0, [lr, #-4]
 224
 225         @ call profiling fixup routine
 226         " CALL_ROUTINE(fixup) "
 227
 228         @ save the return
 229         mov     ip, r0
 230
 231         @ restore the stack
 232         ldmia   sp!,{r0-r3,sl,fp,lr}
 233
 234         @ jump to the newly found address
 235         mov     pc, ip
 236
 237         .size _dl_runtime_profile, .-_dl_runtime_profile
 238         .previous
 239 ");
 240 #endif //PROF
 241
 242 /* Mask identifying addresses reserved for the user program,
 243    where the dynamic linker should not map anything.  */
 244 #define ELF_MACHINE_USER_ADDRESS_MASK   0xf8000000UL
 245
 246 /* Initial entry point code for the dynamic linker.
 247    The C function `_dl_start' is the real entry point;
 248    its return value is the user program's entry point.  */
 249
 250 #define RTLD_START asm ("\
 251 .text
 252 .globl _start
 253 .globl _dl_start_user
 254 _start:
 255         @ at start time, all the args are on the stack
 256         mov     r0, sp
 257         bl      _dl_start
 258         @ returns user entry point in r0
 259 _dl_start_user:
 260         mov     r6, r0
 261         @ we are PIC code, so get global offset table
 262         ldr     sl, .L_GET_GOT
 263         add     sl, pc, sl
 264 .L_GOT_GOT:
 265         @ Store the highest stack address
 266         ldr     r1, .L_STACK_END
 267         ldr     r1, [sl, r1]
 268         str     sp, [r1]
 269         @ See if we were run as a command with the executable file
 270         @ name as an extra leading argument.
 271         ldr     r1, .L_SKIP_ARGS
 272         ldr     r1, [sl, r1]
 273         @ get the original arg count
 274         ldr     r0, [sp]
 275         @ subtract _dl_skip_args from it
 276         sub     r0, r0, r1
 277         @ adjust the stack pointer to skip them
 278         add     sp, sp, r1, lsl #2
 279         @ store the new argc in the new stack location
 280         str     r0, [sp]
 281
 282         @ now we enter a _dl_init_next loop
 283         ldr     r4, .L_MAIN_SEARCHLIST
 284         ldr     r4, [sl, r4]
 285         ldr     r4, [r4]
 286         @ call _dl_init_next to get the address of an initalizer
 287 0:      mov     r0, r4
 288         bl      _dl_init_next(PLT)
 289         cmp     r0, #0
 290         beq     1f
 291         @ call the shared-object initializer
 292         @ during this call, the stack may get moved around
 293         mov     lr, pc
 294         mov     pc, r0
 295         @ go back and look for another initializer
 296         b       0b
 297 1:      @ clear the startup flag
 298         ldr     r2, .L_STARTUP_FLAG
 299         ldr     r1, [sl, r2]
 300         @ we know r0==0 at this point
 301         str     r0, [r1]
 302         @ load the finalizer function
 303         ldr     r0, .L_FINI_PROC
 304         ldr     r0, [sl, r0]
 305         @ jump to the user_s entry point
 306         mov     pc, r6
 307 .L_GET_GOT:
 308         .word   _GLOBAL_OFFSET_TABLE_ - .L_GOT_GOT - 4  \n\
 309 .L_SKIP_ARGS:                                   \n\
 310         .word   _dl_skip_args(GOTOFF)           \n\
 311 .L_STARTUP_FLAG:
 312         .word   _dl_starting_up(GOT)
 313 .L_FINI_PROC:
 314         .word   _dl_fini(GOT)
 315 .L_STACK_END:
 316         .word   __libc_stack_end(GOT)
 317 .L_MAIN_SEARCHLIST:
 318         .word   _dl_main_searchlist(GOT)
 319 .previous\n\
 320 ");
 321
 322 /* Nonzero iff TYPE should not be allowed to resolve to one of
 323    the main executable's symbols, as for a COPY reloc.  */
 324 #define elf_machine_lookup_noexec_p(type) ((type) == R_ARM_COPY)
 325
 326 /* Nonzero iff TYPE describes relocation of a PLT entry, so
 327    PLT entries should not be allowed to define the value.  */
 328 #define elf_machine_lookup_noplt_p(type) ((type) == R_ARM_JUMP_SLOT)
 329
 330 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
 331 #define ELF_MACHINE_JMP_SLOT    R_ARM_JUMP_SLOT
 332
 333 /* The ARM never uses Elf32_Rela relocations.  */
 334 #define ELF_MACHINE_NO_RELA 1
 335
 336 /* We define an initialization functions.  This is called very early in
 337    _dl_sysdep_start.  */
 338 #define DL_PLATFORM_INIT dl_platform_init ()
 339
 340 extern const char *_dl_platform;
 341
 342 static inline void __attribute__ ((unused))
 343 dl_platform_init (void)
 344 {
 345   if (_dl_platform == NULL)
 346     /* We default to ARM
 347     This is where processors could be distinguished arm2, arm6, sa110, etc */
 348     _dl_platform = "ARM";
 349 }
 350
 351 static inline void
 352 elf_machine_fixup_plt (struct link_map *map, const Elf32_Rel *reloc,
 353                        Elf32_Addr *reloc_addr, Elf32_Addr value)
 354 {
 355   *reloc_addr = value;
 356 }
 357
 358 /* Return the final value of a plt relocation.  */
 359 static inline Elf32_Addr
 360 elf_machine_plt_value (struct link_map *map, const Elf32_Rel *reloc,
 361                        Elf32_Addr value)
 362 {
 363   return value;
 364 }
 365
 366 #endif /* !dl_machine_h */
 367
 368 #ifdef RESOLVE
 369
 370 extern char **_dl_argv;
 371
 372 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
 373    MAP is the object containing the reloc.  */
 374
 375 static inline void
 376 elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc,
 377                  const Elf32_Sym *sym, const struct r_found_version *version,
 378                  Elf32_Addr *const reloc_addr)
 379 {
 380   if (ELF32_R_TYPE (reloc->r_info) == R_ARM_RELATIVE)
 381     {
 382 #ifndef RTLD_BOOTSTRAP
 383       if (map != &_dl_rtld_map) /* Already done in rtld itself.  */
 384 #endif
 385         *reloc_addr += map->l_addr;
 386     }
 387   else if (ELF32_R_TYPE (reloc->r_info) != R_ARM_NONE)
 388     {
 389       const Elf32_Sym *const refsym = sym;
 390       Elf32_Addr value = RESOLVE (&sym, version, ELF32_R_TYPE (reloc->r_info));
 391       if (sym)
 392         value += sym->st_value;
 393
 394       switch (ELF32_R_TYPE (reloc->r_info))
 395         {
 396         case R_ARM_COPY:
 397           if (sym == NULL)
 398             /* This can happen in trace mode if an object could not be
 399                found.  */
 400             break;
 401           if (sym->st_size > refsym->st_size
 402               || (_dl_verbose && sym->st_size < refsym->st_size))
 403             {
 404               const char *strtab;
 405
 406               strtab = (const void *) map->l_info[DT_STRTAB]->d_un.d_ptr;
 407               _dl_sysdep_error (_dl_argv[0] ?: "<program name unknown>",
 408                                 ": Symbol `", strtab + refsym->st_name,
 409                                 "' has different size in shared object, "
 410                                 "consider re-linking\n", NULL);
 411             }
 412           memcpy (reloc_addr, (void *) value, MIN (sym->st_size,
 413                                                    refsym->st_size));
 414           break;
 415         case R_ARM_GLOB_DAT:
 416         case R_ARM_JUMP_SLOT:
 417 #ifdef RTLD_BOOTSTRAP
 418           /* Fix weak undefined references.  */
 419           if (sym != NULL && sym->st_value == 0)
 420             *reloc_addr = 0;
 421           else
 422 #endif
 423             *reloc_addr = value;
 424           break;
 425         case R_ARM_ABS32:
 426           {
 427 #ifndef RTLD_BOOTSTRAP
 428            /* This is defined in rtld.c, but nowhere in the static
 429               libc.a; make the reference weak so static programs can
 430               still link.  This declaration cannot be done when
 431               compiling rtld.c (i.e.  #ifdef RTLD_BOOTSTRAP) because
 432               rtld.c contains the common defn for _dl_rtld_map, which
 433               is incompatible with a weak decl in the same file.  */
 434             weak_extern (_dl_rtld_map);
 435             if (map == &_dl_rtld_map)
 436               /* Undo the relocation done here during bootstrapping.
 437                  Now we will relocate it anew, possibly using a
 438                  binding found in the user program or a loaded library
 439                  rather than the dynamic linker's built-in definitions
 440                  used while loading those libraries.  */
 441               value -= map->l_addr + refsym->st_value;
 442 #endif
 443             *reloc_addr += value;
 444             break;
 445           }
 446         case R_ARM_PC24:
 447           {
 448              signed int addend;
 449
 450              addend = *reloc_addr & 0x00ffffff;
 451              if (addend & 0x00800000) addend |= 0xff000000;
 452
 453              value = value - (unsigned int)reloc_addr + (addend << 2);
 454              if (value & 0xfc000003)
 455                _dl_signal_error (0, map->l_name,
 456                           "R_ARM_PC24 relocation out of range");
 457
 458              value = value >> 2;
 459              value = (*reloc_addr & 0xff000000) | (value & 0x00ffffff);
 460              *reloc_addr = value;
 461           }
 462         break;
 463         default:
 464           _dl_reloc_bad_type (map, ELF32_R_TYPE (reloc->r_info), 0);
 465           break;
 466         }
 467     }
 468 }
 469
 470 static inline void
 471 elf_machine_lazy_rel (struct link_map *map,
 472                       Elf32_Addr l_addr, const Elf32_Rel *reloc)
 473 {
 474   Elf32_Addr *const reloc_addr = (void *) (l_addr + reloc->r_offset);
 475   /* Check for unexpected PLT reloc type.  */
 476   if (ELF32_R_TYPE (reloc->r_info) == R_ARM_JUMP_SLOT)
 477     *reloc_addr += l_addr;
 478   else
 479     _dl_reloc_bad_type (map, ELF32_R_TYPE (reloc->r_info), 1);
 480 }
 481
 482 #endif /* RESOLVE */