summaryrefslogtreecommitdiff
path: root/sysdeps/powerpc/dl-machine.h
diff options
context:
space:
mode:
Diffstat (limited to 'sysdeps/powerpc/dl-machine.h')
-rw-r--r--sysdeps/powerpc/dl-machine.h529
1 files changed, 529 insertions, 0 deletions
diff --git a/sysdeps/powerpc/dl-machine.h b/sysdeps/powerpc/dl-machine.h
new file mode 100644
index 0000000000..a60a29723d
--- /dev/null
+++ b/sysdeps/powerpc/dl-machine.h
@@ -0,0 +1,529 @@
+/* Machine-dependent ELF dynamic relocation inline functions. PowerPC version.
+ Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#define ELF_MACHINE_NAME "powerpc"
+
+#include <assert.h>
+#include <string.h>
+#include <link.h>
+
+/* stuff for the PLT */
+#define PLT_INITIAL_ENTRY_WORDS 18
+#define PLT_LONGBRANCH_ENTRY_WORDS 10
+#define OPCODE_ADDI(rd,ra,simm) \
+ (0x38000000 | (rd) << 21 | (ra) << 16 | (simm) & 0xffff)
+#define OPCODE_ADDIS(rd,ra,simm) \
+ (0x3c000000 | (rd) << 21 | (ra) << 16 | (simm) & 0xffff)
+#define OPCODE_ADD(rd,ra,rb) \
+ (0x7c000214 | (rd) << 21 | (ra) << 16 | (rb) << 11)
+#define OPCODE_B(target) (0x48000000 | (target) & 0x03fffffc)
+#define OPCODE_BA(target) (0x48000002 | (target) & 0x03fffffc)
+#define OPCODE_BCTR() 0x4e800420
+#define OPCODE_LWZ(rd,d,ra) \
+ (0x80000000 | (rd) << 21 | (ra) << 16 | (d) & 0xffff)
+#define OPCODE_MTCTR(rd) (0x7C0903A6 | (rd) << 21)
+#define OPCODE_RLWINM(ra,rs,sh,mb,me) \
+ (0x54000000 | (rs) << 21 | (ra) << 16 | (sh) << 11 | (mb) << 6 | (me) << 1)
+
+#define OPCODE_LI(rd,simm) OPCODE_ADDI(rd,0,simm)
+#define OPCODE_SLWI(ra,rs,sh) OPCODE_RLWINM(ra,rs,sh,0,31-sh)
+
+
+/* Return nonzero iff E_MACHINE is compatible with the running host. */
+static inline int
+elf_machine_matches_host (Elf32_Half e_machine)
+{
+ return e_machine == EM_PPC;
+}
+
+
+/* Return the link-time address of _DYNAMIC, the first value in the GOT. */
+static inline Elf32_Addr
+elf_machine_dynamic (void)
+{
+ Elf32_Addr *got;
+ asm (" bl _GLOBAL_OFFSET_TABLE_-4@local"
+ : "=l"(got));
+ return *got;
+}
+
+/* Return the run-time load address of the shared object. */
+static inline Elf32_Addr
+elf_machine_load_address (void)
+{
+ unsigned *got;
+ unsigned *branchaddr;
+
+ /* This is much harder than you'd expect. Possibly I'm missing something.
+ The 'obvious' way:
+
+ Apparently, "bcl 20,31,$+4" is what should be used to load LR
+ with the address of the next instruction.
+ I think this is so that machines that do bl/blr pairing don't
+ get confused.
+
+ asm ("bcl 20,31,0f ;"
+ "0: mflr 0 ;"
+ "lis %0,0b@ha;"
+ "addi %0,%0,0b@l;"
+ "subf %0,%0,0"
+ : "=b" (addr) : : "r0", "lr");
+
+ doesn't work, because the linker doesn't have to (and in fact doesn't)
+ update the @ha and @l references; the loader (which runs after this
+ code) will do that.
+
+ Instead, we use the following trick:
+
+ The linker puts the _link-time_ address of _DYNAMIC at the first
+ word in the GOT. We could branch to that address, if we wanted,
+ by using an @local reloc; the linker works this out, so it's safe
+ to use now. We can't, of course, actually branch there, because
+ we'd cause an illegal instruction exception; so we need to compute
+ the address ourselves. That gives us the following code: */
+
+ /* Get address of the 'b _DYNAMIC@local'... */
+ asm ("bl 0f ;"
+ "b _DYNAMIC@local;"
+ "0:"
+ : "=l"(branchaddr));
+
+ /* ... and the address of the GOT. */
+ asm (" bl _GLOBAL_OFFSET_TABLE_-4@local"
+ : "=l"(got));
+
+ /* So now work out the difference between where the branch actually points,
+ and the offset of that location in memory from the start of the file. */
+ return (Elf32_Addr)branchaddr - *got +
+ (*branchaddr & 0x3fffffc |
+ (int)(*branchaddr << 6 & 0x80000000) >> 6);
+}
+
+#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
+
+/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
+ LOADADDR is the load address of the object; INFO is an array indexed
+ by DT_* of the .dynamic section info. */
+
+#ifdef RESOLVE
+
+static inline void
+elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
+ const Elf32_Sym *sym, const struct r_found_version *version)
+{
+ Elf32_Addr *const reloc_addr = (Elf32_Addr *)(map->l_addr + reloc->r_offset);
+ Elf32_Word loadbase, finaladdr;
+ const int rinfo = ELF32_R_TYPE (reloc->r_info);
+
+ if (rinfo == R_PPC_NONE)
+ return;
+
+ if (sym && ELF32_ST_TYPE (sym->st_info) == STT_SECTION ||
+ rinfo == R_PPC_RELATIVE)
+ {
+ /* Has already been relocated. */
+ loadbase = map->l_addr;
+ finaladdr = loadbase + reloc->r_addend;
+ }
+ else
+ {
+ assert (sym != NULL);
+ if (rinfo == R_PPC_JMP_SLOT)
+ loadbase = (Elf32_Word) (char *) RESOLVE (&sym,
+ version, DL_LOOKUP_NOPLT);
+ else
+ loadbase = (Elf32_Word) (char *) RESOLVE (&sym, version, 0);
+ if (sym == NULL)
+ {
+ /* Weak symbol that wasn't actually defined anywhere. */
+ assert (loadbase == 0);
+ finaladdr = reloc->r_addend;
+ }
+ else
+ finaladdr = (loadbase + (Elf32_Word)(char *)sym->st_value
+ + reloc->r_addend);
+ }
+
+ switch (rinfo)
+ {
+ case R_PPC_UADDR16:
+ case R_PPC_ADDR16_LO:
+ case R_PPC_ADDR16:
+ *(Elf32_Half*) reloc_addr = finaladdr;
+ break;
+
+ case R_PPC_ADDR16_HI:
+ *(Elf32_Half*) reloc_addr = finaladdr >> 16;
+ break;
+
+ case R_PPC_ADDR16_HA:
+ *(Elf32_Half*) reloc_addr = finaladdr + 0x8000 >> 16;
+ break;
+
+ case R_PPC_REL24:
+ {
+ Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
+ assert (delta << 6 >> 6 == delta);
+ *reloc_addr = *reloc_addr & 0xfc000003 | delta & 0x3fffffc;
+ }
+ break;
+
+ case R_PPC_UADDR32:
+ case R_PPC_GLOB_DAT:
+ case R_PPC_ADDR32:
+ case R_PPC_RELATIVE:
+ *reloc_addr = finaladdr;
+ break;
+
+ case R_PPC_ADDR24:
+ *reloc_addr = *reloc_addr & 0xfc000003 | finaladdr & 0x3fffffc;
+ break;
+
+ case R_PPC_REL14_BRTAKEN:
+ case R_PPC_REL14_BRNTAKEN:
+ case R_PPC_REL14:
+ {
+ Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
+ *reloc_addr = *reloc_addr & 0xffdf0003 | delta & 0xfffc;
+ if (rinfo == R_PPC_REL14_BRTAKEN && delta >= 0 ||
+ rinfo == R_PPC_REL14_BRNTAKEN && delta < 0)
+ *reloc_addr |= 0x00200000;
+ }
+ break;
+
+ case R_PPC_COPY:
+ {
+ /* Can't use memcpy (because we can't call any functions here). */
+ int i;
+ for (i = 0; i < sym->st_size; ++i)
+ ((unsigned char *) reloc_addr)[i] =
+ ((unsigned char *)finaladdr)[i];
+ }
+ break;
+
+ case R_PPC_REL32:
+ *reloc_addr = finaladdr - (Elf32_Word) (char *) reloc_addr;
+ break;
+
+ case R_PPC_JMP_SLOT:
+ if (finaladdr <= 0x01fffffc || finaladdr >= 0xfe000000)
+ *reloc_addr = OPCODE_BA (finaladdr);
+ else
+ {
+ Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
+ if (delta <= 0x01fffffc && delta >= 0xfe000000)
+ *reloc_addr = OPCODE_B (delta);
+ else
+ {
+ Elf32_Word *plt =
+ (Elf32_Word *) ((char *) map->l_addr
+ + map->l_info[DT_PLTGOT]->d_un.d_val);
+ Elf32_Word index =((reloc_addr - plt - PLT_INITIAL_ENTRY_WORDS)
+ / 2);
+ int num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
+ / sizeof (Elf32_Rela));
+ int rel_offset_words = (PLT_INITIAL_ENTRY_WORDS
+ + num_plt_entries * 2);
+
+ if (index >= (1 << 13))
+ {
+ /* Indexes greater than or equal to 2^13 have 4
+ words available instead of two. */
+ plt[index * 2 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_LI (11, finaladdr);
+ plt[index * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_ADDIS (11, 11, finaladdr + 0x8000 >> 16);
+ plt[index * 2 + 2 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_MTCTR (11);
+ plt[index * 2 + 2 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_BCTR ();
+ }
+ else
+ {
+ plt[index * 2 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_LI (11, index * 4);
+ plt[index * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_B(-(4 * (index * 2 + 1 + PLT_INITIAL_ENTRY_WORDS
+ + PLT_LONGBRANCH_ENTRY_WORDS)));
+ plt[index + rel_offset_words] = finaladdr;
+ }
+ }
+ }
+ break;
+
+ default:
+ assert (! "unexpected dynamic reloc type");
+ }
+}
+
+#define ELF_MACHINE_NO_REL 1
+
+#endif
+
+/* 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_PPC_JMP_SLOT)
+
+/* 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. */
+
+/* This code does not presently work if there are more than 2^13 PLT
+ entries. */
+static inline void
+elf_machine_runtime_setup (struct link_map *map, int lazy)
+{
+ Elf32_Word *plt;
+ int i;
+ Elf32_Word num_plt_entries;
+ Elf32_Word rel_offset_words;
+ extern void _dl_runtime_resolve (void);
+
+ if (map->l_info[DT_JMPREL])
+ {
+ /* Fill in the PLT. Its initial contents are directed to a
+ function earlier in the PLT which arranges for the dynamic
+ linker to be called back. */
+ plt = (Elf32_Word *) ((char *) map->l_addr +
+ map->l_info[DT_PLTGOT]->d_un.d_val);
+ num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
+ / sizeof (Elf32_Rela));
+ rel_offset_words = PLT_INITIAL_ENTRY_WORDS + num_plt_entries * 2;
+
+ if (lazy)
+ for (i = 0; i < num_plt_entries; i++)
+ if (i >= (1 << 13))
+ {
+ plt[i * 2 + (i - (1 << 13)) * 2 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_LI (11, i * 4);
+ plt[i * 2 + (i - (1 << 13)) * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_ADDIS (11, 11, i * 4 + 0x8000 >> 16);
+ plt[i * 2 + (i - (1 << 13)) * 2 + 2 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_B (-(4 * ( i * 2 + 1 + PLT_INITIAL_ENTRY_WORDS)));
+ }
+ else
+ {
+ plt[i * 2 + PLT_INITIAL_ENTRY_WORDS] = OPCODE_LI (11, i * 4);
+ plt[i * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+ OPCODE_B (-(4 * (i * 2 + 1 + PLT_INITIAL_ENTRY_WORDS)));
+ }
+
+ /* Multiply index of entry, by 0xC. */
+ plt[0] = OPCODE_SLWI (12, 11, 1);
+ plt[1] = OPCODE_ADD (11, 12, 11);
+ if ((Elf32_Word) (char *) _dl_runtime_resolve <= 0x01fffffc ||
+ (Elf32_Word) (char *) _dl_runtime_resolve >= 0xfe000000)
+ {
+ plt[2] = OPCODE_LI (12, (Elf32_Word) (char *) map);
+ plt[3] = OPCODE_ADDIS (12, 12,
+ (Elf32_Word) (char *) map + 0x8000 >> 16);
+ plt[4] = OPCODE_BA ((Elf32_Word) (char *) _dl_runtime_resolve);
+ }
+ else
+ {
+ plt[2] = OPCODE_LI (12, (Elf32_Word) (char *) _dl_runtime_resolve);
+ plt[3] = OPCODE_ADDIS (12, 12, 0x8000 +
+ ((Elf32_Word) (char *) _dl_runtime_resolve
+ >> 16));
+ plt[4] = OPCODE_MTCTR (12);
+ plt[5] = OPCODE_LI (12, (Elf32_Word) (char *) map);
+ plt[6] = OPCODE_ADDIS (12, 12, ((Elf32_Word) (char *) map
+ + 0x8000 >> 16));
+ plt[7] = OPCODE_BCTR ();
+ }
+ plt[PLT_LONGBRANCH_ENTRY_WORDS] =
+ OPCODE_ADDIS (11, 11, ((Elf32_Word) (char*) (plt+rel_offset_words)
+ + 0x8000 >> 16));
+ plt[PLT_LONGBRANCH_ENTRY_WORDS+1] =
+ OPCODE_LWZ (11, (Elf32_Word) (char*) (plt + rel_offset_words), 11);
+ plt[PLT_LONGBRANCH_ENTRY_WORDS+2] = OPCODE_MTCTR (11);
+ plt[PLT_LONGBRANCH_ENTRY_WORDS+3] = OPCODE_BCTR ();
+ }
+}
+
+static inline void
+elf_machine_lazy_rel (struct link_map *map, const Elf32_Rela *reloc)
+{
+ if (ELF32_R_TYPE (reloc->r_info) != R_PPC_JMP_SLOT)
+ assert (! "unexpected PLT reloc type");
+
+ /* elf_machine_runtime_setup handles this. */
+}
+
+/* The PLT uses Elf32_Rela relocs. */
+#define elf_machine_relplt elf_machine_rela
+
+ /* 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 ("\
+ .section \".text\"
+ .globl _dl_runtime_resolve
+_dl_runtime_resolve:
+ stwu 1,-48(1)
+ mflr 0
+ stw 3,16(1)
+ stw 4,20(1)
+ stw 0,52(1)
+ stw 5,24(1)
+ mfcr 0
+ stw 6,28(1)
+ stw 7,32(1)
+ stw 8,36(1)
+ stw 9,40(1)
+ stw 10,44(1)
+ stw 0,12(1)
+ mr 3,12
+ mr 4,11
+ bl fixup
+ mtctr 3
+ lwz 0,52(1)
+ lwz 10,44(1)
+ lwz 9,40(1)
+ mtlr 0
+ lwz 0,12(1)
+ lwz 8,36(1)
+ lwz 7,32(1)
+ lwz 6,28(1)
+ mtcrf 0xFF,0
+ lwz 5,24(1)
+ lwz 4,20(1)
+ lwz 3,16(1)
+ addi 1,1,48
+ bctr
+");
+
+/* 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. */
+
+/* FIXME! We don't make provision for calling _dl_fini,
+ because Linux/PPC is somewhat broken. */
+#define RTLD_START \
+asm ("\
+ .text
+ .align 2
+ .globl _start
+ .type _start,@function
+_start:
+ # We start with the following on the stack, from top:
+ # argc (4 bytes)
+ # arguments for program (terminated by NULL)
+ # environment variables (terminated by NULL)
+ # arguments for the program loader
+
+ # Call _dl_start with one parameter pointing at argc
+ mr 3,1
+ # (we have to frob the stack pointer a bit to allow room for
+ # _dl_start to save the link register)
+ li 4,0
+ addi 1,1,-16
+ stw 4,0(1)
+ bl _dl_start@local
+
+ # Now, we do our main work of calling initialisation procedures.
+ # The ELF ABI doesn't say anything about parameters for these,
+ # so we just pass argc, argv, and the environment.
+ # Changing these is strongly discouraged (not least because argc is
+ # passed by value!).
+
+ # put our GOT pointer in r31
+ bl _GLOBAL_OFFSET_TABLE_-4@local
+ mflr 31
+ # the address of _start in r30
+ mr 30,3
+ # &_dl_argc in 29, &_dl_argv in 27, and _dl_default_scope in 28
+ lwz 28,_dl_default_scope@got(31)
+ lwz 29,_dl_argc@got(31)
+ lwz 27,_dl_argv@got(31)
+0:
+ # call initfunc = _dl_init_next(_dl_default_scope[2])
+ lwz 3,8(28)
+ bl _dl_init_next@plt
+ # if initfunc is NULL, we exit the loop
+ mr. 0,3
+ beq 1f
+ # call initfunc(_dl_argc, _dl_argv, _dl_argv+_dl_argc+1)
+ mtlr 0
+ lwz 3,0(29)
+ lwz 4,0(27)
+ slwi 5,3,2
+ add 5,4,5
+ addi 5,5,4
+ blrl
+ # and loop.
+ b 0b
+1:
+ # Now, to conform to the ELF ABI, we have to:
+ # pass argv (actually _dl_argv) in r4
+ lwz 4,0(27)
+ # pass argc (actually _dl_argc) in r3
+ lwz 3,0(29)
+ # pass envp (actually _dl_argv+_dl_argc+1) in r5
+ slwi 5,3,2
+ add 5,4,5
+ addi 5,5,4
+ # pass the auxilary vector in r6. This is passed just after _envp.
+ addi 6,5,-4
+2: lwzu 0,4(6)
+ cmpwi 1,0,0
+ bne 2b
+ addi 6,6,4
+ # pass a termination function pointer (in this case _dl_fini) in r7
+ lwz 7,_dl_fini@got(31)
+ # now, call the start function in r30...
+ mtctr 30
+ # pass the stack pointer in r1 (so far so good), pointing to a NULL value
+ # (this lets our startup code distinguish between a program linked statically,
+ # which linux will call with argc on top of the stack which will hopefully
+ # never be zero, and a dynamically linked program which will always have
+ # a NULL on the top of the stack).
+ # Take the opportunity to clear LR, so anyone who accidentally returns
+ # from _start gets SEGV.
+ li 0,0
+ stw 0,0(1)
+ mtlr 0
+ # and also clear _dl_starting_up
+ lwz 26,_dl_starting_up@got(31)
+ stw 0,0(3)
+ # go do it!
+ bctr
+");
+
+#define ELF_PREFERRED_ADDRESS_DATA static ElfW(Addr) _dl_preferred_address = 0;
+#define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) \
+( { \
+ ElfW(Addr) prefd; \
+ if (mapstartpref != 0 && _dl_preferred_address == 0) \
+ _dl_preferred_address = mapstartpref; \
+ if (mapstartpref != 0) \
+ prefd = mapstartpref; \
+ else if (_dl_preferred_address < maplength + 0x50000) \
+ prefd = 0; \
+ else \
+ prefd = _dl_preferred_address = \
+ (_dl_preferred_address - maplength - 0x10000) & \
+ ~(_dl_pagesize - 1); \
+ prefd; \
+} )
+#define ELF_FIXED_ADDRESS(loader, mapstart) \
+( { \
+ if (mapstart != 0 && _dl_preferred_address == 0) \
+ _dl_preferred_address = mapstart; \
+} )
+
+#define ELF_FIXUP_RETURNS_ADDRESS 1
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-26 22:05:50 +0000