summaryrefslogtreecommitdiff
path: root/ldso
diff options
context:
space:
mode:
Diffstat (limited to 'ldso')
-rw-r--r--ldso/ldso/arm/dl-syscalls.h124
-rw-r--r--ldso/ldso/arm/dl-sysdep.h120
-rw-r--r--ldso/ldso/arm/elfinterp.c374
-rw-r--r--ldso/ldso/arm/ld_syscalls.h124
-rw-r--r--ldso/ldso/arm/ld_sysdep.h120
-rw-r--r--ldso/ldso/arm/resolve.S41
-rw-r--r--ldso/ldso/arm/syscalls.h124
-rw-r--r--ldso/ldso/arm/sysdep.h120
8 files changed, 1147 insertions, 0 deletions
diff --git a/ldso/ldso/arm/dl-syscalls.h b/ldso/ldso/arm/dl-syscalls.h
new file mode 100644
index 000000000..aa08421a5
--- /dev/null
+++ b/ldso/ldso/arm/dl-syscalls.h
@@ -0,0 +1,124 @@
+#include <sys/types.h>
+
+/*
+ * This file contains the system call macros and syscall
+ * numbers used by the shared library loader.
+ */
+
+#define __NR_SYSCALL_BASE 0x900000
+
+#define __NR_exit (__NR_SYSCALL_BASE+ 1)
+#define __NR_read (__NR_SYSCALL_BASE+ 3)
+#define __NR_write (__NR_SYSCALL_BASE+ 4)
+#define __NR_open (__NR_SYSCALL_BASE+ 5)
+#define __NR_close (__NR_SYSCALL_BASE+ 6)
+#define __NR_getuid (__NR_SYSCALL_BASE+ 24)
+#define __NR_geteuid (__NR_SYSCALL_BASE+ 49)
+#define __NR_getgid (__NR_SYSCALL_BASE+ 47)
+#define __NR_getegid (__NR_SYSCALL_BASE+ 50)
+#define __NR_mmap (__NR_SYSCALL_BASE+ 90)
+#define __NR_munmap (__NR_SYSCALL_BASE+ 91)
+#define __NR_stat (__NR_SYSCALL_BASE+106)
+#define __NR_mprotect (__NR_SYSCALL_BASE+125)
+
+
+/* Here are the macros which define how this platform makes
+ * system calls. This particular variant does _not_ set
+ * errno (note how it is disabled in __syscall_return) since
+ * these will get called before the errno symbol is dynamicly
+ * linked. */
+
+/* These are Erik's versions of the syscall routines. His were
+ * cleaner than mine, so I adopted them instead with some
+ * reformating. Shane Nay.
+ */
+
+#define __sys2(x) #x
+#define __sys1(x) __sys2(x)
+
+#ifndef __syscall
+#define __syscall(name) "swi\t" __sys1(__NR_##name) "\n\t"
+#endif
+
+#undef __syscall_return
+#define __syscall_return(type, res) \
+do { \
+ if ((unsigned long)(res) >= (unsigned long)(-125)) { \
+ /*errno = -(res);*/ \
+ res = -1; \
+ } \
+ return (type) (res); \
+} while (0)
+
+#define _syscall0(type,name) \
+type name(void) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ __syscall(name) \
+ "mov %0,r0" \
+ :"=r" (__res) : : "r0","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#define _syscall1(type,name,type1,arg1) \
+type name(type1 arg1) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ __syscall(name) \
+ "mov %0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)) \
+ : "r0","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#define _syscall2(type,name,type1,arg1,type2,arg2) \
+type name(type1 arg1,type2 arg2) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)) \
+ : "r0","r1","lr"); \
+ __syscall_return(type,__res); \
+}
+
+
+#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
+type name(type1 arg1,type2 arg2,type3 arg3) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ "mov\tr2,%3\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)),"r" ((long)(arg3)) \
+ : "r0","r1","r2","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#undef _syscall4
+#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)\
+type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ "mov\tr2,%3\n\t" \
+ "mov\tr3,%4\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)), \
+ "r" ((long)(arg3)),"r" ((long)(arg4)) \
+ : "r0","r1","r2","r3","lr"); \
+ __syscall_return(type,__res); \
+}
+
+
diff --git a/ldso/ldso/arm/dl-sysdep.h b/ldso/ldso/arm/dl-sysdep.h
new file mode 100644
index 000000000..b3d430519
--- /dev/null
+++ b/ldso/ldso/arm/dl-sysdep.h
@@ -0,0 +1,120 @@
+/*
+ * Various assmbly language/system dependent hacks that are required
+ * so that we can minimize the amount of platform specific code.
+ */
+
+/*
+ * Define this if the system uses RELOCA.
+ */
+#undef ELF_USES_RELOCA
+
+/*
+ * Get a pointer to the argv array. On many platforms this can be just
+ * the address if the first argument, on other platforms we need to
+ * do something a little more subtle here.
+ */
+#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long*) ARGS)
+
+/*
+ * Initialization sequence for a GOT.
+ */
+#define INIT_GOT(GOT_BASE,MODULE) \
+{ \
+ GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
+ GOT_BASE[1] = (unsigned long) MODULE; \
+}
+
+/*
+ * Here is a macro to perform a relocation. This is only used when
+ * bootstrapping the dynamic loader. RELP is the relocation that we
+ * are performing, REL is the pointer to the address we are relocating.
+ * SYMBOL is the symbol involved in the relocation, and LOAD is the
+ * load address.
+ */
+#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD) \
+ switch(ELF32_R_TYPE((RELP)->r_info)){ \
+ case R_ARM_ABS32: \
+ *REL += SYMBOL; \
+ break; \
+ case R_ARM_PC24: \
+ { \
+ unsigned long newval, topbits; \
+ long addend=*REL & 0x00ffffff; \
+ if(addend & 0x00800000) \
+ addend|=0xff000000; \
+ newval=SYMBOL- ((unsigned long)REL) + (addend<<2); \
+ topbits=newval & 0xfe000000; \
+ if (topbits != 0xfe000000 && topbits != 0x00000000) {/* \
+ newval=fix_bad_pc24(REL,value) - \
+ ((unsigned long)REL) + (addend << 2); \
+ topbits=newval & 0xfe000000; \
+ if(topbits != 0xfe000000 && topbits != 0x00000000)*/ \
+ _dl_exit(1); \
+ } \
+ newval>>=2; \
+ SYMBOL= (*REL & 0xff000000)|(newval & 0x00ffffff); \
+ *REL=SYMBOL; \
+ } \
+ break; \
+ case R_ARM_GLOB_DAT: \
+ case R_ARM_JUMP_SLOT: \
+ *REL = SYMBOL; \
+ break; \
+ case R_ARM_RELATIVE: \
+ *REL += (unsigned long) LOAD; \
+ break; \
+ case R_ARM_NONE: \
+ break; \
+ default: \
+ _dl_exit(1); \
+ }
+
+
+/*
+ * Transfer control to the user's application, once the dynamic loader
+ * is done. This routine has to exit the current function, then
+ * call the _dl_elf_main function.
+ */
+
+#define START() return _dl_elf_main;
+
+
+
+/* Here we define the magic numbers that this dynamic loader should accept */
+
+#define MAGIC1 EM_ARM
+#undef MAGIC2
+/* Used for error messages */
+#define ELF_TARGET "ARM"
+
+struct elf_resolve;
+extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
+
+static inline unsigned long arm_modulus(unsigned long m, unsigned long p) {
+ unsigned long i,t,inc;
+ i=p; t=0;
+ while(!(i&(1<<31))) {
+ i<<=1;
+ t++;
+ }
+ t--;
+ for(inc=t;inc>2;inc--) {
+ i=p<<inc;
+ if(i&(1<<31))
+ break;
+ while(m>=i) {
+ m-=i;
+ i<<=1;
+ if(i&(1<<31))
+ break;
+ if(i<p)
+ break;
+ }
+ }
+ while(m>=p) {
+ m-=p;
+ }
+ return m;
+}
+
+#define do_rem(result, n, base) result=arm_modulus(n,base);
diff --git a/ldso/ldso/arm/elfinterp.c b/ldso/ldso/arm/elfinterp.c
new file mode 100644
index 000000000..397610bd6
--- /dev/null
+++ b/ldso/ldso/arm/elfinterp.c
@@ -0,0 +1,374 @@
+/* Run an ELF binary on a linux system.
+
+ Copyright (C) 1993, Eric Youngdale.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef VERBOSE_DLINKER
+#define VERBOSE_DLINKER
+#endif
+#ifdef VERBOSE_DLINKER
+static char *_dl_reltypes[] =
+ { "R_ARM_NONE", "R_ARM_PC24", "R_ARM_ABS32", "R_ARM_REL32",
+ "R_ARM_PC13", "R_ARM_ABS16", "R_ARM_ABS12", "R_ARM_THM_ABS5",
+ "R_ARM_ABS8", "R_ARM_SBREL32", "R_ARM_THM_PC22", "R_ARM_THM_PC8",
+ "R_ARM_AMP_VCALL9", "R_ARM_SWI24", "R_ARM_THM_SWI8", "R_ARM_XPC25",
+ "R_ARM_THM_XPC22", "R_ARM_COPY", "R_ARM_GLOB_DAT", "R_ARM_JUMP_SLOT",
+ "R_ARM_RELATIVE", "R_ARM_GOTOFF", "R_ARM_GOTPC", "R_ARM_GOT32",
+ "R_ARM_PLT32", "R_ARM_ALU_PCREL_7_0", "R_ARM_ALU_PCREL_15_8",
+ "R_ARM_ALU_PCREL_23_15", "R_ARM_LDR_SBREL_11_0", "R_ARM_ALU_SBREL_19_12",
+ "R_ARM_ALU_SBREL_27_20", "R_ARM_GNU_VTENTRY", "R_ARM_GNU_VTINHERIT",
+ "R_ARM_THM_PC11", "R_ARM_THM_PC9", "R_ARM_RXPC25", "R_ARM_RSBREL32",
+ "R_ARM_THM_RPC22", "R_ARM_RREL32", "R_ARM_RABS22", "R_ARM_RPC24",
+ "R_ARM_RBASE", "R_ARM_NUM"
+};
+#endif
+
+/* Program to load an ELF binary on a linux system, and run it.
+ References to symbols in sharable libraries can be resolved by either
+ an ELF sharable library or a linux style of shared library. */
+
+/* Disclaimer: I have never seen any AT&T source code for SVr4, nor have
+ I ever taken any courses on internals. This program was developed using
+ information available through the book "UNIX SYSTEM V RELEASE 4,
+ Programmers guide: Ansi C and Programming Support Tools", which did
+ a more than adequate job of explaining everything required to get this
+ working. */
+
+#include <sys/types.h>
+#include <errno.h>
+#include "elf.h"
+#include "hash.h"
+#include "syscall.h"
+#include "string.h"
+#include "sysdep.h"
+
+extern char *_dl_progname;
+
+extern int _dl_linux_resolve(void);
+
+unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
+{
+ int reloc_type;
+ Elf32_Rel *this_reloc;
+ char *strtab;
+ Elf32_Sym *symtab;
+ Elf32_Rel *rel_addr;
+ int symtab_index;
+ char *new_addr;
+ char **got_addr;
+ unsigned long instr_addr;
+
+ rel_addr = (Elf32_Rel *) (tpnt->dynamic_info[DT_JMPREL] + tpnt->loadaddr);
+
+ this_reloc = rel_addr + (reloc_entry >> 3);
+ reloc_type = ELF32_R_TYPE(this_reloc->r_info);
+ symtab_index = ELF32_R_SYM(this_reloc->r_info);
+
+ symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
+ strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
+
+ if (reloc_type != R_ARM_JUMP_SLOT) {
+ _dl_fdprintf(2, "%s: Incorrect relocation type in jump relocations\n",
+ _dl_progname);
+ _dl_exit(1);
+ };
+
+ /* Address of jump instruction to fix up */
+ instr_addr = ((unsigned long) this_reloc->r_offset +
+ (unsigned long) tpnt->loadaddr);
+ got_addr = (char **) instr_addr;
+
+#ifdef DL_DEBUG
+ _dl_fdprintf(2, "Resolving symbol %s\n",
+ strtab + symtab[symtab_index].st_name);
+#endif
+
+ /* Get the address of the GOT entry */
+ new_addr = _dl_find_hash(strtab + symtab[symtab_index].st_name,
+ tpnt->symbol_scope, (unsigned long) got_addr, tpnt, 0);
+ if (!new_addr) {
+ _dl_fdprintf(2, "%s: can't resolve symbol '%s'\n",
+ _dl_progname, strtab + symtab[symtab_index].st_name);
+ _dl_exit(1);
+ };
+#ifdef DL_DEBUG
+ if ((unsigned long) got_addr < 0x40000000) {
+ _dl_fdprintf(2, "Calling library function: %s\n",
+ strtab + symtab[symtab_index].st_name);
+ } else {
+ *got_addr = new_addr;
+ }
+#else
+ *got_addr = new_addr;
+#endif
+ return (unsigned long) new_addr;
+}
+
+void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt,
+ unsigned long rel_addr, unsigned long rel_size, int type)
+{
+ int i;
+ char *strtab;
+ int reloc_type;
+ int symtab_index;
+ Elf32_Sym *symtab;
+ Elf32_Rel *rpnt;
+ unsigned long *reloc_addr;
+
+ /* Now parse the relocation information */
+ rpnt = (Elf32_Rel *) (rel_addr + tpnt->loadaddr);
+ rel_size = rel_size / sizeof(Elf32_Rel);
+
+ symtab =
+ (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
+ strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
+
+ for (i = 0; i < rel_size; i++, rpnt++) {
+ reloc_addr = (unsigned long *) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
+ reloc_type = ELF32_R_TYPE(rpnt->r_info);
+ symtab_index = ELF32_R_SYM(rpnt->r_info);
+
+ /* When the dynamic linker bootstrapped itself, it resolved some symbols.
+ Make sure we do not do them again */
+ if (!symtab_index && tpnt->libtype == program_interpreter)
+ continue;
+ if (symtab_index && tpnt->libtype == program_interpreter &&
+ _dl_symbol(strtab + symtab[symtab_index].st_name))
+ continue;
+
+ switch (reloc_type) {
+ case R_ARM_NONE:
+ break;
+ case R_ARM_JUMP_SLOT:
+ *reloc_addr += (unsigned long) tpnt->loadaddr;
+ break;
+ default:
+ _dl_fdprintf(2, "%s: (LAZY) can't handle reloc type ",
+ _dl_progname);
+#ifdef VERBOSE_DLINKER
+ _dl_fdprintf(2, "%s ", _dl_reltypes[reloc_type]);
+#endif
+ if (symtab_index)
+ _dl_fdprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
+ _dl_exit(1);
+ };
+ };
+}
+
+static unsigned long
+fix_bad_pc24 (unsigned long *const reloc_addr, unsigned long value)
+{
+ static void *fix_page;
+ static unsigned int fix_offset;
+ unsigned int *fix_address;
+ if (! fix_page)
+ {
+ fix_page = _dl_mmap (NULL, 4096 , PROT_READ | PROT_WRITE | PROT_EXEC,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ fix_offset = 0;
+ }
+
+ fix_address = (unsigned int *)(fix_page + fix_offset);
+ fix_address[0] = 0xe51ff004; /* ldr pc, [pc, #-4] */
+ fix_address[1] = value;
+
+ fix_offset += 8;
+ if (fix_offset >= 4096)
+ fix_page = NULL;
+
+ return (unsigned long)fix_address;
+}
+
+
+int _dl_parse_relocation_information(struct elf_resolve *tpnt,
+ unsigned long rel_addr, unsigned long rel_size, int type)
+{
+ int i;
+ char *strtab;
+ int reloc_type;
+ int goof = 0;
+ Elf32_Sym *symtab;
+ Elf32_Rel *rpnt;
+ unsigned long *reloc_addr;
+ unsigned long symbol_addr;
+ int symtab_index;
+
+ /* Now parse the relocation information */
+
+ rpnt = (Elf32_Rel *) (rel_addr + tpnt->loadaddr);
+ rel_size = rel_size / sizeof(Elf32_Rel);
+
+ symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
+ strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
+
+ for (i = 0; i < rel_size; i++, rpnt++) {
+ reloc_addr = (unsigned long *) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
+ reloc_type = ELF32_R_TYPE(rpnt->r_info);
+ symtab_index = ELF32_R_SYM(rpnt->r_info);
+ symbol_addr = 0;
+
+ if (!symtab_index && tpnt->libtype == program_interpreter)
+ continue;
+
+ if (symtab_index) {
+
+ if (tpnt->libtype == program_interpreter &&
+ _dl_symbol(strtab + symtab[symtab_index].st_name))
+ continue;
+
+ symbol_addr = (unsigned long) _dl_find_hash(strtab + symtab[symtab_index].st_name,
+ tpnt->symbol_scope, (unsigned long) reloc_addr,
+ (reloc_type == R_ARM_JUMP_SLOT ? tpnt : NULL), 0);
+
+ /*
+ * We want to allow undefined references to weak symbols - this might
+ * have been intentional. We should not be linking local symbols
+ * here, so all bases should be covered.
+ */
+ if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {
+ _dl_fdprintf(2, "%s: can't resolve symbol '%s'\n",
+ _dl_progname, strtab + symtab[symtab_index].st_name);
+ goof++;
+ }
+ }
+ switch (reloc_type) {
+ case R_ARM_NONE:
+ break;
+ case R_ARM_ABS32:
+ *reloc_addr += symbol_addr;
+ break;
+ case R_ARM_PC24:
+ {
+ unsigned long addend;
+ long newvalue, topbits;
+
+ addend = *reloc_addr & 0x00ffffff;
+ if (addend & 0x00800000) addend |= 0xff000000;
+
+ newvalue = symbol_addr - (unsigned long)reloc_addr + (addend << 2);
+ topbits = newvalue & 0xfe000000;
+ if (topbits != 0xfe000000 && topbits != 0x00000000)
+ {
+ newvalue = fix_bad_pc24(reloc_addr, symbol_addr)
+ - (unsigned long)reloc_addr + (addend << 2);
+ topbits = newvalue & 0xfe000000;
+ if (topbits != 0xfe000000 && topbits != 0x00000000)
+ {
+ _dl_fdprintf(2, "R_ARM_PC24 relocation out of range ");
+ _dl_exit(1);
+ }
+ }
+ newvalue >>= 2;
+ symbol_addr = (*reloc_addr & 0xff000000) | (newvalue & 0x00ffffff);
+ *reloc_addr = symbol_addr;
+ break;
+ }
+ case R_ARM_GLOB_DAT:
+ case R_ARM_JUMP_SLOT:
+ *reloc_addr = symbol_addr;
+ break;
+ case R_ARM_RELATIVE:
+ *reloc_addr += (unsigned long) tpnt->loadaddr;
+ break;
+ case R_ARM_COPY:
+#if 0
+ /* Do this later */
+ _dl_fdprintf(2, "Doing copy for symbol ");
+ if (symtab_index) _dl_fdprintf(2, strtab + symtab[symtab_index].st_name);
+ _dl_fdprintf(2, "\n");
+ _dl_memcpy((void *) symtab[symtab_index].st_value,
+ (void *) symbol_addr, symtab[symtab_index].st_size);
+#endif
+ break;
+ default:
+ _dl_fdprintf(2, "%s: can't handle reloc type ", _dl_progname);
+#ifdef VERBOSE_DLINKER
+ _dl_fdprintf(2, "%s ", _dl_reltypes[reloc_type]);
+#endif
+ if (symtab_index)
+ _dl_fdprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
+ _dl_exit(1);
+ };
+
+ };
+ return goof;
+}
+
+
+/* This is done as a separate step, because there are cases where
+ information is first copied and later initialized. This results in
+ the wrong information being copied. Someone at Sun was complaining about
+ a bug in the handling of _COPY by SVr4, and this may in fact be what he
+ was talking about. Sigh. */
+
+/* No, there are cases where the SVr4 linker fails to emit COPY relocs
+ at all */
+
+int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr,
+ unsigned long rel_size, int type)
+{
+ int i;
+ char *strtab;
+ int reloc_type;
+ int goof = 0;
+ Elf32_Sym *symtab;
+ Elf32_Rel *rpnt;
+ unsigned long *reloc_addr;
+ unsigned long symbol_addr;
+ struct elf_resolve *tpnt;
+ int symtab_index;
+
+ /* Now parse the relocation information */
+
+ tpnt = xpnt->dyn;
+
+ rpnt = (Elf32_Rel *) (rel_addr + tpnt->loadaddr);
+ rel_size = rel_size / sizeof(Elf32_Rel);
+
+ symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
+ strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
+
+ for (i = 0; i < rel_size; i++, rpnt++) {
+ reloc_addr = (unsigned long *) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
+ reloc_type = ELF32_R_TYPE(rpnt->r_info);
+ if (reloc_type != R_ARM_COPY)
+ continue;
+ symtab_index = ELF32_R_SYM(rpnt->r_info);
+ symbol_addr = 0;
+ if (!symtab_index && tpnt->libtype == program_interpreter)
+ continue;
+ if (symtab_index) {
+
+ if (tpnt->libtype == program_interpreter &&
+ _dl_symbol(strtab + symtab[symtab_index].st_name))
+ continue;
+
+ symbol_addr = (unsigned long) _dl_find_hash(strtab +
+ symtab[symtab_index].st_name, xpnt->next,
+ (unsigned long) reloc_addr, NULL, 1);
+ if (!symbol_addr) {
+ _dl_fdprintf(2, "%s: can't resolve symbol '%s'\n",
+ _dl_progname, strtab + symtab[symtab_index].st_name);
+ goof++;
+ };
+ };
+ if (!goof) {
+ _dl_memcpy((char *) symtab[symtab_index].st_value,
+ (char *) symbol_addr, symtab[symtab_index].st_size);
+ }
+ };
+ return goof;
+}
diff --git a/ldso/ldso/arm/ld_syscalls.h b/ldso/ldso/arm/ld_syscalls.h
new file mode 100644
index 000000000..aa08421a5
--- /dev/null
+++ b/ldso/ldso/arm/ld_syscalls.h
@@ -0,0 +1,124 @@
+#include <sys/types.h>
+
+/*
+ * This file contains the system call macros and syscall
+ * numbers used by the shared library loader.
+ */
+
+#define __NR_SYSCALL_BASE 0x900000
+
+#define __NR_exit (__NR_SYSCALL_BASE+ 1)
+#define __NR_read (__NR_SYSCALL_BASE+ 3)
+#define __NR_write (__NR_SYSCALL_BASE+ 4)
+#define __NR_open (__NR_SYSCALL_BASE+ 5)
+#define __NR_close (__NR_SYSCALL_BASE+ 6)
+#define __NR_getuid (__NR_SYSCALL_BASE+ 24)
+#define __NR_geteuid (__NR_SYSCALL_BASE+ 49)
+#define __NR_getgid (__NR_SYSCALL_BASE+ 47)
+#define __NR_getegid (__NR_SYSCALL_BASE+ 50)
+#define __NR_mmap (__NR_SYSCALL_BASE+ 90)
+#define __NR_munmap (__NR_SYSCALL_BASE+ 91)
+#define __NR_stat (__NR_SYSCALL_BASE+106)
+#define __NR_mprotect (__NR_SYSCALL_BASE+125)
+
+
+/* Here are the macros which define how this platform makes
+ * system calls. This particular variant does _not_ set
+ * errno (note how it is disabled in __syscall_return) since
+ * these will get called before the errno symbol is dynamicly
+ * linked. */
+
+/* These are Erik's versions of the syscall routines. His were
+ * cleaner than mine, so I adopted them instead with some
+ * reformating. Shane Nay.
+ */
+
+#define __sys2(x) #x
+#define __sys1(x) __sys2(x)
+
+#ifndef __syscall
+#define __syscall(name) "swi\t" __sys1(__NR_##name) "\n\t"
+#endif
+
+#undef __syscall_return
+#define __syscall_return(type, res) \
+do { \
+ if ((unsigned long)(res) >= (unsigned long)(-125)) { \
+ /*errno = -(res);*/ \
+ res = -1; \
+ } \
+ return (type) (res); \
+} while (0)
+
+#define _syscall0(type,name) \
+type name(void) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ __syscall(name) \
+ "mov %0,r0" \
+ :"=r" (__res) : : "r0","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#define _syscall1(type,name,type1,arg1) \
+type name(type1 arg1) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ __syscall(name) \
+ "mov %0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)) \
+ : "r0","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#define _syscall2(type,name,type1,arg1,type2,arg2) \
+type name(type1 arg1,type2 arg2) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)) \
+ : "r0","r1","lr"); \
+ __syscall_return(type,__res); \
+}
+
+
+#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
+type name(type1 arg1,type2 arg2,type3 arg3) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ "mov\tr2,%3\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)),"r" ((long)(arg3)) \
+ : "r0","r1","r2","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#undef _syscall4
+#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)\
+type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ "mov\tr2,%3\n\t" \
+ "mov\tr3,%4\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)), \
+ "r" ((long)(arg3)),"r" ((long)(arg4)) \
+ : "r0","r1","r2","r3","lr"); \
+ __syscall_return(type,__res); \
+}
+
+
diff --git a/ldso/ldso/arm/ld_sysdep.h b/ldso/ldso/arm/ld_sysdep.h
new file mode 100644
index 000000000..b3d430519
--- /dev/null
+++ b/ldso/ldso/arm/ld_sysdep.h
@@ -0,0 +1,120 @@
+/*
+ * Various assmbly language/system dependent hacks that are required
+ * so that we can minimize the amount of platform specific code.
+ */
+
+/*
+ * Define this if the system uses RELOCA.
+ */
+#undef ELF_USES_RELOCA
+
+/*
+ * Get a pointer to the argv array. On many platforms this can be just
+ * the address if the first argument, on other platforms we need to
+ * do something a little more subtle here.
+ */
+#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long*) ARGS)
+
+/*
+ * Initialization sequence for a GOT.
+ */
+#define INIT_GOT(GOT_BASE,MODULE) \
+{ \
+ GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
+ GOT_BASE[1] = (unsigned long) MODULE; \
+}
+
+/*
+ * Here is a macro to perform a relocation. This is only used when
+ * bootstrapping the dynamic loader. RELP is the relocation that we
+ * are performing, REL is the pointer to the address we are relocating.
+ * SYMBOL is the symbol involved in the relocation, and LOAD is the
+ * load address.
+ */
+#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD) \
+ switch(ELF32_R_TYPE((RELP)->r_info)){ \
+ case R_ARM_ABS32: \
+ *REL += SYMBOL; \
+ break; \
+ case R_ARM_PC24: \
+ { \
+ unsigned long newval, topbits; \
+ long addend=*REL & 0x00ffffff; \
+ if(addend & 0x00800000) \
+ addend|=0xff000000; \
+ newval=SYMBOL- ((unsigned long)REL) + (addend<<2); \
+ topbits=newval & 0xfe000000; \
+ if (topbits != 0xfe000000 && topbits != 0x00000000) {/* \
+ newval=fix_bad_pc24(REL,value) - \
+ ((unsigned long)REL) + (addend << 2); \
+ topbits=newval & 0xfe000000; \
+ if(topbits != 0xfe000000 && topbits != 0x00000000)*/ \
+ _dl_exit(1); \
+ } \
+ newval>>=2; \
+ SYMBOL= (*REL & 0xff000000)|(newval & 0x00ffffff); \
+ *REL=SYMBOL; \
+ } \
+ break; \
+ case R_ARM_GLOB_DAT: \
+ case R_ARM_JUMP_SLOT: \
+ *REL = SYMBOL; \
+ break; \
+ case R_ARM_RELATIVE: \
+ *REL += (unsigned long) LOAD; \
+ break; \
+ case R_ARM_NONE: \
+ break; \
+ default: \
+ _dl_exit(1); \
+ }
+
+
+/*
+ * Transfer control to the user's application, once the dynamic loader
+ * is done. This routine has to exit the current function, then
+ * call the _dl_elf_main function.
+ */
+
+#define START() return _dl_elf_main;
+
+
+
+/* Here we define the magic numbers that this dynamic loader should accept */
+
+#define MAGIC1 EM_ARM
+#undef MAGIC2
+/* Used for error messages */
+#define ELF_TARGET "ARM"
+
+struct elf_resolve;
+extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
+
+static inline unsigned long arm_modulus(unsigned long m, unsigned long p) {
+ unsigned long i,t,inc;
+ i=p; t=0;
+ while(!(i&(1<<31))) {
+ i<<=1;
+ t++;
+ }
+ t--;
+ for(inc=t;inc>2;inc--) {
+ i=p<<inc;
+ if(i&(1<<31))
+ break;
+ while(m>=i) {
+ m-=i;
+ i<<=1;
+ if(i&(1<<31))
+ break;
+ if(i<p)
+ break;
+ }
+ }
+ while(m>=p) {
+ m-=p;
+ }
+ return m;
+}
+
+#define do_rem(result, n, base) result=arm_modulus(n,base);
diff --git a/ldso/ldso/arm/resolve.S b/ldso/ldso/arm/resolve.S
new file mode 100644
index 000000000..514ecb64e
--- /dev/null
+++ b/ldso/ldso/arm/resolve.S
@@ -0,0 +1,41 @@
+/*
+ * This function is _not_ called directly. It is jumped to (so no return
+ * address is on the stack) when attempting to use a symbol that has not yet
+ * been resolved. The first time a jump symbol (such as a function call inside
+ * a shared library) is used (before it gets resolved) it will jump here to
+ * _dl_linux_resolve. When we get called the stack looks like this:
+ * reloc_entry
+ * tpnt
+ *
+ * This function saves all the registers, puts a copy of reloc_entry and tpnt
+ * on the stack (as function arguments) then make the function call
+ * _dl_linux_resolver(tpnt, reloc_entry). _dl_linux_resolver() figures out
+ * where the jump symbol is _really_ supposed to have jumped to and returns
+ * that to us. Once we have that, we overwrite tpnt with this fixed up
+ * address. We then clean up after ourselves, put all the registers back how we
+ * found them, then we jump to where the fixed up address, which is where the
+ * jump symbol that got us here really wanted to jump to in the first place.
+ * found them, then we jump to the fixed up address, which is where the jump
+ * symbol that got us here really wanted to jump to in the first place.
+ * -Erik Andersen
+ */
+.text
+.globl _dl_linux_resolve
+.type _dl_linux_resolve,#function
+.align 2
+_dl_linux_resolve:
+ stmdb sp!,{r0-r3,sl,fp}
+ sub r1, ip, lr
+ sub r1, r1, #4
+ add r1, r1, r1
+ ldr r0, [lr, #-4]
+ mov r3,r0
+
+ bl _dl_linux_resolver
+
+// str r0, [lr, #-4]
+ mov ip, r0
+ ldmia sp!,{r0-r3,sl,fp,lr}
+ mov pc,ip
+.size _dl_linux_resolve, .-_dl_linux_resolve
+
diff --git a/ldso/ldso/arm/syscalls.h b/ldso/ldso/arm/syscalls.h
new file mode 100644
index 000000000..aa08421a5
--- /dev/null
+++ b/ldso/ldso/arm/syscalls.h
@@ -0,0 +1,124 @@
+#include <sys/types.h>
+
+/*
+ * This file contains the system call macros and syscall
+ * numbers used by the shared library loader.
+ */
+
+#define __NR_SYSCALL_BASE 0x900000
+
+#define __NR_exit (__NR_SYSCALL_BASE+ 1)
+#define __NR_read (__NR_SYSCALL_BASE+ 3)
+#define __NR_write (__NR_SYSCALL_BASE+ 4)
+#define __NR_open (__NR_SYSCALL_BASE+ 5)
+#define __NR_close (__NR_SYSCALL_BASE+ 6)
+#define __NR_getuid (__NR_SYSCALL_BASE+ 24)
+#define __NR_geteuid (__NR_SYSCALL_BASE+ 49)
+#define __NR_getgid (__NR_SYSCALL_BASE+ 47)
+#define __NR_getegid (__NR_SYSCALL_BASE+ 50)
+#define __NR_mmap (__NR_SYSCALL_BASE+ 90)
+#define __NR_munmap (__NR_SYSCALL_BASE+ 91)
+#define __NR_stat (__NR_SYSCALL_BASE+106)
+#define __NR_mprotect (__NR_SYSCALL_BASE+125)
+
+
+/* Here are the macros which define how this platform makes
+ * system calls. This particular variant does _not_ set
+ * errno (note how it is disabled in __syscall_return) since
+ * these will get called before the errno symbol is dynamicly
+ * linked. */
+
+/* These are Erik's versions of the syscall routines. His were
+ * cleaner than mine, so I adopted them instead with some
+ * reformating. Shane Nay.
+ */
+
+#define __sys2(x) #x
+#define __sys1(x) __sys2(x)
+
+#ifndef __syscall
+#define __syscall(name) "swi\t" __sys1(__NR_##name) "\n\t"
+#endif
+
+#undef __syscall_return
+#define __syscall_return(type, res) \
+do { \
+ if ((unsigned long)(res) >= (unsigned long)(-125)) { \
+ /*errno = -(res);*/ \
+ res = -1; \
+ } \
+ return (type) (res); \
+} while (0)
+
+#define _syscall0(type,name) \
+type name(void) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ __syscall(name) \
+ "mov %0,r0" \
+ :"=r" (__res) : : "r0","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#define _syscall1(type,name,type1,arg1) \
+type name(type1 arg1) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ __syscall(name) \
+ "mov %0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)) \
+ : "r0","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#define _syscall2(type,name,type1,arg1,type2,arg2) \
+type name(type1 arg1,type2 arg2) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)) \
+ : "r0","r1","lr"); \
+ __syscall_return(type,__res); \
+}
+
+
+#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
+type name(type1 arg1,type2 arg2,type3 arg3) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ "mov\tr2,%3\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)),"r" ((long)(arg3)) \
+ : "r0","r1","r2","lr"); \
+ __syscall_return(type,__res); \
+}
+
+#undef _syscall4
+#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)\
+type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \
+ long __res; \
+ __asm__ __volatile__ ( \
+ "mov\tr0,%1\n\t" \
+ "mov\tr1,%2\n\t" \
+ "mov\tr2,%3\n\t" \
+ "mov\tr3,%4\n\t" \
+ __syscall(name) \
+ "mov\t%0,r0" \
+ : "=r" (__res) \
+ : "r" ((long)(arg1)),"r" ((long)(arg2)), \
+ "r" ((long)(arg3)),"r" ((long)(arg4)) \
+ : "r0","r1","r2","r3","lr"); \
+ __syscall_return(type,__res); \
+}
+
+
diff --git a/ldso/ldso/arm/sysdep.h b/ldso/ldso/arm/sysdep.h
new file mode 100644
index 000000000..b3d430519
--- /dev/null
+++ b/ldso/ldso/arm/sysdep.h
@@ -0,0 +1,120 @@
+/*
+ * Various assmbly language/system dependent hacks that are required
+ * so that we can minimize the amount of platform specific code.
+ */
+
+/*
+ * Define this if the system uses RELOCA.
+ */
+#undef ELF_USES_RELOCA
+
+/*
+ * Get a pointer to the argv array. On many platforms this can be just
+ * the address if the first argument, on other platforms we need to
+ * do something a little more subtle here.
+ */
+#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long*) ARGS)
+
+/*
+ * Initialization sequence for a GOT.
+ */
+#define INIT_GOT(GOT_BASE,MODULE) \
+{ \
+ GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
+ GOT_BASE[1] = (unsigned long) MODULE; \
+}
+
+/*
+ * Here is a macro to perform a relocation. This is only used when
+ * bootstrapping the dynamic loader. RELP is the relocation that we
+ * are performing, REL is the pointer to the address we are relocating.
+ * SYMBOL is the symbol involved in the relocation, and LOAD is the
+ * load address.
+ */
+#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD) \
+ switch(ELF32_R_TYPE((RELP)->r_info)){ \
+ case R_ARM_ABS32: \
+ *REL += SYMBOL; \
+ break; \
+ case R_ARM_PC24: \
+ { \
+ unsigned long newval, topbits; \
+ long addend=*REL & 0x00ffffff; \
+ if(addend & 0x00800000) \
+ addend|=0xff000000; \
+ newval=SYMBOL- ((unsigned long)REL) + (addend<<2); \
+ topbits=newval & 0xfe000000; \
+ if (topbits != 0xfe000000 && topbits != 0x00000000) {/* \
+ newval=fix_bad_pc24(REL,value) - \
+ ((unsigned long)REL) + (addend << 2); \
+ topbits=newval & 0xfe000000; \
+ if(topbits != 0xfe000000 && topbits != 0x00000000)*/ \
+ _dl_exit(1); \
+ } \
+ newval>>=2; \
+ SYMBOL= (*REL & 0xff000000)|(newval & 0x00ffffff); \
+ *REL=SYMBOL; \
+ } \
+ break; \
+ case R_ARM_GLOB_DAT: \
+ case R_ARM_JUMP_SLOT: \
+ *REL = SYMBOL; \
+ break; \
+ case R_ARM_RELATIVE: \
+ *REL += (unsigned long) LOAD; \
+ break; \
+ case R_ARM_NONE: \
+ break; \
+ default: \
+ _dl_exit(1); \
+ }
+
+
+/*
+ * Transfer control to the user's application, once the dynamic loader
+ * is done. This routine has to exit the current function, then
+ * call the _dl_elf_main function.
+ */
+
+#define START() return _dl_elf_main;
+
+
+
+/* Here we define the magic numbers that this dynamic loader should accept */
+
+#define MAGIC1 EM_ARM
+#undef MAGIC2
+/* Used for error messages */
+#define ELF_TARGET "ARM"
+
+struct elf_resolve;
+extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
+
+static inline unsigned long arm_modulus(unsigned long m, unsigned long p) {
+ unsigned long i,t,inc;
+ i=p; t=0;
+ while(!(i&(1<<31))) {
+ i<<=1;
+ t++;
+ }
+ t--;
+ for(inc=t;inc>2;inc--) {
+ i=p<<inc;
+ if(i&(1<<31))
+ break;
+ while(m>=i) {
+ m-=i;
+ i<<=1;
+ if(i&(1<<31))
+ break;
+ if(i<p)
+ break;
+ }
+ }
+ while(m>=p) {
+ m-=p;
+ }
+ return m;
+}
+
+#define do_rem(result, n, base) result=arm_modulus(n,base);
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 22:12:53 +0000