aboutsummaryrefslogtreecommitdiff
path: root/sysdeps/powerpc/dl-machine.h
diff options
context:
space:
mode:
authorUlrich Drepper <drepper@redhat.com>1998-09-01 14:31:49 +0000
committerUlrich Drepper <drepper@redhat.com>1998-09-01 14:31:49 +0000
commit052b6a6c94cc330dfbc09ff7b5f03c943deb7ca2 (patch)
tree0ef4d2730e6e20141e3b669b8a3614193200f3fc /sysdeps/powerpc/dl-machine.h
parent85c165befc61d049abe3cc443c275a210c569338 (diff)
downloadglibc-052b6a6c94cc330dfbc09ff7b5f03c943deb7ca2.tar
glibc-052b6a6c94cc330dfbc09ff7b5f03c943deb7ca2.tar.gz
glibc-052b6a6c94cc330dfbc09ff7b5f03c943deb7ca2.tar.bz2
glibc-052b6a6c94cc330dfbc09ff7b5f03c943deb7ca2.zip
Update.
1998-08-09 Geoff Keating <geoffk@ozemail.com.au> * sysdeps/powerpc/Makefile [subdir=elf]: Add new files split out of dl-machine.h. * sysdeps/powerpc/dl-machine.c: New file. * sysdeps/powerpc/dl-machine.h: Move much stuff into separate files. Revise ELF_PREFERRED_ADDRESS to take account of the new mapping information (fixes bug involving huge bloated web browser). Set ELF_MACHINE_PLTREL_OVERLAP. * sysdeps/powerpc/dl-start.S: New file. * elf/dl-load.c (_dl_map_object_from_fd): Initialise l_map_start, l_map_end. * elf/do-rel.h: Call elf_machine_rel only once (to save space). * elf/dynamic-link.h: Allow PLT relocs to be in the middle of the others. Call elf_dynamic_do_##reloc only once (to save even more space). * elf/link.h: Add new members l_map_start and l_map_end to keep track of the memory map. * elf/rtld.c (_dl_start): Initialise l_map_start for ld.so and the executable. 1998-09-01 11:53 Ulrich Drepper <drepper@cygnus.com> * debug/Makefile (catchsegv): We need not rewrite SOVER anymore. Reported by Andreas Jaeger. * posix/glob.h: Use __size_t instead of size_t in definitions and make sure this is defined. * manual/locale.texi: Almost complete rewrite. Document more functions
Diffstat (limited to 'sysdeps/powerpc/dl-machine.h')
-rw-r--r--sysdeps/powerpc/dl-machine.h528
1 files changed, 51 insertions, 477 deletions
diff --git a/sysdeps/powerpc/dl-machine.h b/sysdeps/powerpc/dl-machine.h
index ab75aa1390..bb449a9d34 100644
--- a/sysdeps/powerpc/dl-machine.h
+++ b/sysdeps/powerpc/dl-machine.h
@@ -23,57 +23,9 @@
#define ELF_MACHINE_NAME "powerpc"
#include <assert.h>
-#include <string.h>
-#include <link.h>
-#include <sys/param.h>
-
-
-/* stuff for the PLT */
-#define PLT_INITIAL_ENTRY_WORDS 18
-#define PLT_LONGBRANCH_ENTRY_WORDS 10
-#define PLT_DOUBLE_SIZE (1<<13)
-#define PLT_ENTRY_START_WORDS(entry_number) \
- (PLT_INITIAL_ENTRY_WORDS + (entry_number)*2 + \
- ((entry_number) > PLT_DOUBLE_SIZE ? \
- ((entry_number) - PLT_DOUBLE_SIZE)*2 : \
- 0))
-#define PLT_DATA_START_WORDS(num_entries) PLT_ENTRY_START_WORDS(num_entries)
-
-#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)
-
-#define PPC_DCBST(where) asm volatile ("dcbst 0,%0" : : "r"(where))
-#define PPC_SYNC asm volatile ("sync")
-#define PPC_ISYNC asm volatile ("sync; isync")
-#define PPC_ICBI(where) asm volatile ("icbi 0,%0" : : "r"(where))
-#define PPC_DIE asm volatile ("tweq 0,0")
-
-/* Use this when you've modified some code, but it won't be in the
- instruction fetch queue (or when it doesn't matter if it is). */
-#define MODIFIED_CODE_NOQUEUE(where) \
- do { PPC_DCBST(where); PPC_SYNC; PPC_ICBI(where); } while (0)
-/* Use this when it might be in the instruction queue. */
-#define MODIFIED_CODE(where) \
- do { PPC_DCBST(where); PPC_SYNC; PPC_ICBI(where); PPC_ISYNC; } while (0)
-
/* Return nonzero iff E_MACHINE is compatible with the running host. */
-static inline int
+extern inline int
elf_machine_matches_host (Elf32_Half e_machine)
{
return e_machine == EM_PPC;
@@ -82,7 +34,7 @@ elf_machine_matches_host (Elf32_Half e_machine)
/* Return the link-time address of _DYNAMIC, stored as
the first value in the GOT. */
-static inline Elf32_Addr
+extern inline Elf32_Addr
elf_machine_dynamic (void)
{
Elf32_Addr *got;
@@ -248,150 +200,16 @@ _dl_prof_resolve:
.previous
");
-/* 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 \
-static ElfW(Addr) _dl_start (void *arg) __attribute__((unused)); \
-asm ("\
- .section \".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.
- # FIXME: perhaps this should do the same trick as elf/start.c?
-
- # 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:
- # Set 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; otherwise,
- cmpwi 3,0
- beq 1f
- # call initfunc(_dl_argc, _dl_argv, _dl_argv+_dl_argc+1)
- mtlr 3
- 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 argc (actually _dl_argc) in r3;
- lwz 3,0(29)
- # pass argv (actually _dl_argv) in r4;
- lwz 4,0(27)
- # pass envp (actually _dl_argv+_dl_argc+1) in r5;
- slwi 5,3,2
- add 6,4,5
- addi 5,6,4
- # pass the auxilary vector in r6. This is passed to us just after _envp.
-2: lwzu 0,4(6)
- cmpwi 0,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
- lwz 26,_dl_starting_up@got(31)
- # 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. Also clear the next few words of the stack.
- li 31,0
- stw 31,0(1)
- mtlr 31
- stw 31,4(1)
- stw 31,8(1)
- stw 31,12(1)
- # Clear _dl_starting_up.
- stw 31,0(26)
- # Go do it!
- bctr
-0:
- .size _start,0b-_start
- # Undo '.section text'.
- .previous
-");
+/* The actual _start code is in dl-start.S. Use a really
+ ugly bit of assembler to let dl-start.o see _dl_start. */
+#define RTLD_START asm (".globl _dl_start");
-/* The idea here is that to conform to the ABI, we are supposed to try
- to load dynamic objects between 0x10000 (we actually use 0x40000 as
- the lower bound, to increase the chance of a memory reference from
- a null pointer giving a segfault) and the program's load address.
- Regrettably, in this code we can't find the program's load address,
- so we punt and choose 0x01800000, which is below the ABI's
- recommended default, and what GNU ld currently chooses. We only use
- the address as a preference for mmap, so if we get it wrong the
- worst that happens is that it gets mapped somewhere else.
-
- FIXME: Unfortunately, 'somewhere else' is probably right after the
- program's break, which causes malloc to fail. We really need more
- information here about the way memory is mapped. */
-
-#define ELF_PREFERRED_ADDRESS_DATA \
-static ElfW(Addr) _dl_preferred_address = 1
-
-#define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) \
-( { \
- ElfW(Addr) prefd; \
- if (mapstartpref != 0 && _dl_preferred_address == 1) \
- _dl_preferred_address = mapstartpref; \
- if (mapstartpref != 0) \
- prefd = mapstartpref; \
- else if (_dl_preferred_address == 1) \
- prefd = _dl_preferred_address = \
- (0x01800000 - maplength - 0x10000) & \
- ~(_dl_pagesize - 1); \
- 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 == 1) \
- _dl_preferred_address = mapstart; \
-} )
+/* Decide where a relocatable object should be loaded. */
+extern ElfW(Addr)
+__elf_preferred_address(struct link_map *loader, size_t maplength,
+ ElfW(Addr) mapstartpref);
+#define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) \
+ __elf_preferred_address (loader, maplength, mapstartpref)
/* Nonzero iff TYPE should not be allowed to resolve to one of
the main executable's symbols, as for a COPY reloc. */
@@ -417,203 +235,25 @@ static ElfW(Addr) _dl_preferred_address = 1
entries will jump to the on-demand fixup code in dl-runtime.c.
Also install a small trampoline to be used by entries that have
been relocated to an address too far away for a single branch. */
+extern int __elf_machine_runtime_setup (struct link_map *map,
+ int lazy, int profile);
+#define elf_machine_runtime_setup __elf_machine_runtime_setup
-/* A PLT entry does one of three things:
- (i) Jumps to the actual routine. Such entries are set up above, in
- elf_machine_rela.
-
- (ii) Jumps to the actual routine via glue at the start of the PLT.
- We do this by putting the address of the routine in space
- allocated at the end of the PLT, and when the PLT entry is
- called we load the offset of that word (from the start of the
- space) into r11, then call the glue, which loads the word and
- branches to that address. These entries are set up in
- elf_machine_rela, but the glue is set up here.
-
- (iii) Loads the index of this PLT entry (we count the double-size
- entries as one entry for this purpose) into r11, then
- branches to code at the start of the PLT. This code then
- calls `fixup', in dl-runtime.c, via the glue in the macro
- ELF_MACHINE_RUNTIME_TRAMPOLINE, which resets the PLT entry to
- be one of the above two types. These entries are set up here. */
-static inline int
-elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
-{
- if (map->l_info[DT_JMPREL])
- {
- Elf32_Word i;
- /* 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. */
- Elf32_Word *plt = (Elf32_Word *) ((char *) map->l_addr
- + map->l_info[DT_PLTGOT]->d_un.d_val);
- Elf32_Word num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
- / sizeof (Elf32_Rela));
- Elf32_Word rel_offset_words = PLT_DATA_START_WORDS (num_plt_entries);
- Elf32_Word size_modified;
- extern void _dl_runtime_resolve (void);
- extern void _dl_prof_resolve (void);
- Elf32_Word dlrr;
-
- dlrr = (Elf32_Word)(char *)(profile
- ? _dl_prof_resolve
- : _dl_runtime_resolve);
-
- if (lazy)
- for (i = 0; i < num_plt_entries; i++)
- {
- Elf32_Word offset = PLT_ENTRY_START_WORDS (i);
-
- if (i >= PLT_DOUBLE_SIZE)
- {
- plt[offset ] = OPCODE_LI (11, i * 4);
- plt[offset+1] = OPCODE_ADDIS (11, 11, (i * 4 + 0x8000) >> 16);
- plt[offset+2] = OPCODE_B (-(4 * (offset + 2)));
- }
- else
- {
- plt[offset ] = OPCODE_LI (11, i * 4);
- plt[offset+1] = OPCODE_B (-(4 * (offset + 1)));
- }
- }
-
- /* Multiply index of entry by 3 (in r11). */
- plt[0] = OPCODE_SLWI (12, 11, 1);
- plt[1] = OPCODE_ADD (11, 12, 11);
- if (dlrr <= 0x01fffffc || dlrr >= 0xfe000000)
- {
- /* Load address of link map in r12. */
- plt[2] = OPCODE_LI (12, (Elf32_Word) (char *) map);
- plt[3] = OPCODE_ADDIS (12, 12, (((Elf32_Word) (char *) map
- + 0x8000) >> 16));
-
- /* Call _dl_runtime_resolve. */
- plt[4] = OPCODE_BA (dlrr);
- }
- else
- {
- /* Get address of _dl_runtime_resolve in CTR. */
- plt[2] = OPCODE_LI (12, dlrr);
- plt[3] = OPCODE_ADDIS (12, 12, (dlrr + 0x8000) >> 16);
- plt[4] = OPCODE_MTCTR (12);
-
- /* Load address of link map in r12. */
- plt[5] = OPCODE_LI (12, (Elf32_Word) (char *) map);
- plt[6] = OPCODE_ADDIS (12, 12, (((Elf32_Word) (char *) map
- + 0x8000) >> 16));
-
- /* Call _dl_runtime_resolve. */
- plt[7] = OPCODE_BCTR ();
- }
-
-
- /* Convert the index in r11 into an actual address, and get the
- word at that address. */
- 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);
-
- /* Call the procedure at that address. */
- plt[PLT_LONGBRANCH_ENTRY_WORDS+2] = OPCODE_MTCTR (11);
- plt[PLT_LONGBRANCH_ENTRY_WORDS+3] = OPCODE_BCTR ();
-
-
- /* Now, we've modified code (quite a lot of code, possibly). We
- need to write the changes from the data cache to a
- second-level unified cache, then make sure that stale data in
- the instruction cache is removed. (In a multiprocessor
- system, the effect is more complex.)
-
- Assumes the cache line size is at least 32 bytes, or at least
- that dcbst and icbi apply to 32-byte lines. At present, all
- PowerPC processors have line sizes of exactly 32 bytes. */
-
- size_modified = lazy ? rel_offset_words : PLT_INITIAL_ENTRY_WORDS;
- for (i = 0; i < size_modified; i+=8)
- PPC_DCBST (plt + i);
- PPC_SYNC;
- for (i = 0; i < size_modified; i+=8)
- PPC_ICBI (plt + i);
- PPC_ISYNC;
- }
-
- return lazy;
-}
-
-static inline void
+extern inline void
elf_machine_lazy_rel (Elf32_Addr l_addr, const Elf32_Rela *reloc)
{
/* elf_machine_runtime_setup handles this. */
}
-static inline void
-elf_machine_fixup_plt(struct link_map *map, const Elf32_Rela *reloc,
- Elf32_Addr *reloc_addr, Elf32_Addr finaladdr)
-{
- Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
- if (delta << 6 >> 6 == delta)
- *reloc_addr = OPCODE_B (delta);
- else if (finaladdr <= 0x01fffffc || finaladdr >= 0xfe000000)
- *reloc_addr = OPCODE_BA (finaladdr);
- else
- {
- Elf32_Word *plt;
- Elf32_Word index;
-
- plt = (Elf32_Word *)((char *)map->l_addr
- + map->l_info[DT_PLTGOT]->d_un.d_val);
- index = (reloc_addr - plt - PLT_INITIAL_ENTRY_WORDS)/2;
- if (index >= PLT_DOUBLE_SIZE)
- {
- /* Slots greater than or equal to 2^13 have 4 words available
- instead of two. */
- /* FIXME: There are some possible race conditions in this code,
- when called from 'fixup'.
-
- 1) Suppose that a lazy PLT entry is executing, a context switch
- between threads (or a signal) occurs, and the new thread or
- signal handler calls the same lazy PLT entry. Then the PLT entry
- would be changed while it's being run, which will cause a segfault
- (almost always).
-
- 2) Suppose the reverse: that a lazy PLT entry is being updated,
- a context switch occurs, and the new code calls the lazy PLT
- entry that is being updated. Then the half-fixed PLT entry will
- be executed, which will also almost always cause a segfault.
-
- These problems don't happen with the 2-word entries, because
- only one of the two instructions are changed when a lazy entry
- is retargeted at the actual PLT entry; the li instruction stays
- the same (we have to update it anyway, because we might not be
- updating a lazy PLT entry). */
-
- reloc_addr[0] = OPCODE_LI (11, finaladdr);
- reloc_addr[1] = OPCODE_ADDIS (11, 11, finaladdr + 0x8000 >> 16);
- reloc_addr[2] = OPCODE_MTCTR (11);
- reloc_addr[3] = OPCODE_BCTR ();
- }
- else
- {
- Elf32_Word num_plt_entries;
-
- num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
- / sizeof(Elf32_Rela));
-
- plt[index+PLT_DATA_START_WORDS (num_plt_entries)] = finaladdr;
- reloc_addr[0] = OPCODE_LI (11, index*4);
- reloc_addr[1] = OPCODE_B (-(4*(index*2
- + 1
- - PLT_LONGBRANCH_ENTRY_WORDS
- + PLT_INITIAL_ENTRY_WORDS)));
- }
- }
- MODIFIED_CODE (reloc_addr);
-}
+/* Change the PLT entry whose reloc is 'reloc' to call the actual routine. */
+extern void __elf_machine_fixup_plt(struct link_map *map,
+ const Elf32_Rela *reloc,
+ Elf32_Addr *reloc_addr,
+ Elf32_Addr finaladdr);
+#define elf_machine_fixup_plt __elf_machine_fixup_plt
/* Return the final value of a plt relocation. */
-static inline Elf32_Addr
+extern inline Elf32_Addr
elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
Elf32_Addr value)
{
@@ -624,32 +264,38 @@ elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
#ifdef RESOLVE
+/* Do the actual processing of a reloc, once its target address
+ has been determined. */
+extern void __process_machine_rela (struct link_map *map,
+ const Elf32_Rela *reloc,
+ const Elf32_Sym *sym,
+ const Elf32_Sym *refsym,
+ Elf32_Addr *const reloc_addr,
+ Elf32_Addr finaladdr,
+ int rinfo);
+
/* 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. */
-static void
+extern 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)
{
-#ifndef RTLD_BOOTSTRAP
const Elf32_Sym *const refsym = sym;
- extern char **_dl_argv;
-#endif
Elf32_Word loadbase, finaladdr;
const int rinfo = ELF32_R_TYPE (reloc->r_info);
if (rinfo == R_PPC_NONE)
return;
- assert (sym != NULL);
/* The condition on the next two lines is a hack around a bug in Solaris
tools on Sparc. It's not clear whether it should really be here at all,
but if not the binutils need to be changed. */
- if ((sym->st_shndx != SHN_UNDEF
- && ELF32_ST_BIND (sym->st_info) == STB_LOCAL)
- || rinfo == R_PPC_RELATIVE)
+ if (rinfo == R_PPC_RELATIVE
+ || (sym->st_shndx != SHN_UNDEF
+ && ELF32_ST_BIND (sym->st_info) == STB_LOCAL))
{
/* Has already been relocated. */
loadbase = map->l_addr;
@@ -670,99 +316,27 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
+ reloc->r_addend);
}
- /* This is still an if/else if chain because GCC uses the GOT to find
- the table for table-based switch statements, and we haven't set it
- up yet. */
- if (rinfo == R_PPC_UADDR32 ||
- rinfo == R_PPC_GLOB_DAT ||
- rinfo == R_PPC_ADDR32 ||
- rinfo == R_PPC_RELATIVE)
+ /* A small amount of code is duplicated here for speed. In libc,
+ more than 90% of the relocs are R_PPC_RELATIVE; in the X11 shared
+ libraries, 60% are R_PPC_RELATIVE, 24% are R_PPC_GLOB_DAT or
+ R_PPC_ADDR32, and 16% are R_PPC_JMP_SLOT (which this routine
+ wouldn't usually handle). As an bonus, doing this here allows
+ the switch statement in __process_machine_rela to work. */
+ if (rinfo == R_PPC_RELATIVE
+ || rinfo == R_PPC_GLOB_DAT
+ || rinfo == R_PPC_ADDR32)
{
*reloc_addr = finaladdr;
}
-#ifndef RTLD_BOOTSTRAP
- else if (rinfo == R_PPC_ADDR16_LO)
- {
- *(Elf32_Half*) reloc_addr = finaladdr;
- }
- else if (rinfo == R_PPC_ADDR16_HI)
- {
- *(Elf32_Half*) reloc_addr = finaladdr >> 16;
- }
- else if (rinfo == R_PPC_ADDR16_HA)
- {
- *(Elf32_Half*) reloc_addr = (finaladdr + 0x8000) >> 16;
- }
- else if (rinfo == R_PPC_REL24)
- {
- Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
- if (delta << 6 >> 6 != delta)
- {
- _dl_signal_error(0, map->l_name,
- "R_PPC_REL24 relocation out of range");
- }
- *reloc_addr = *reloc_addr & 0xfc000003 | delta & 0x3fffffc;
- }
- else if (rinfo == R_PPC_ADDR24)
- {
- if (finaladdr << 6 >> 6 != finaladdr)
- {
- _dl_signal_error(0, map->l_name,
- "R_PPC_ADDR24 relocation out of range");
- }
- *reloc_addr = *reloc_addr & 0xfc000003 | finaladdr & 0x3fffffc;
- }
- else if (rinfo == R_PPC_COPY)
- {
- if (sym == NULL)
- /* This can happen in trace mode when an object could not be
- found. */
- return;
- if (sym->st_size > refsym->st_size
- || (_dl_verbose && sym->st_size < refsym->st_size))
- {
- const char *strtab;
-
- strtab = ((void *) map->l_addr
- + map->l_info[DT_STRTAB]->d_un.d_ptr);
- _dl_sysdep_error (_dl_argv[0] ?: "<program name unknown>",
- ": Symbol `", strtab + refsym->st_name,
- "' has different size in shared object, "
- "consider re-linking\n", NULL);
- }
- memcpy (reloc_addr, (char *) finaladdr, MIN (sym->st_size,
- refsym->st_size));
- }
-#endif
- else if (rinfo == R_PPC_REL32)
- {
- *reloc_addr = finaladdr - (Elf32_Word) (char *) reloc_addr;
- }
- else if (rinfo == R_PPC_JMP_SLOT)
- {
- elf_machine_fixup_plt (map, reloc, reloc_addr, finaladdr);
- }
else
- {
-#ifdef RTLD_BOOTSTRAP
- PPC_DIE; /* There is no point calling _dl_sysdep_error, it
- almost certainly hasn't been relocated properly. */
-#else
- _dl_sysdep_error (_dl_argv[0] ?: "<program name unknown>",
- ": Unknown relocation type\n", NULL);
-#endif
- }
-
-#ifndef RTLD_BOOTSTRAP
- if (rinfo == R_PPC_ADDR16_LO ||
- rinfo == R_PPC_ADDR16_HI ||
- rinfo == R_PPC_ADDR16_HA ||
- rinfo == R_PPC_REL24 ||
- rinfo == R_PPC_ADDR24)
- MODIFIED_CODE_NOQUEUE (reloc_addr);
-#endif
+ __process_machine_rela (map, reloc, sym, refsym,
+ reloc_addr, finaladdr, rinfo);
}
#define ELF_MACHINE_NO_REL 1
+/* The SVR4 ABI specifies that the JMPREL relocs must be inside the
+ DT_RELA table. */
+#define ELF_MACHINE_PLTREL_OVERLAP 1
+
#endif /* RESOLVE */