summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--ldso/ldso/x86_64/dl-startup.h69
-rw-r--r--ldso/ldso/x86_64/dl-syscalls.h5
-rw-r--r--ldso/ldso/x86_64/dl-sysdep.h120
3 files changed, 194 insertions, 0 deletions
diff --git a/ldso/ldso/x86_64/dl-startup.h b/ldso/ldso/x86_64/dl-startup.h
new file mode 100644
index 000000000..1b83e5d91
--- /dev/null
+++ b/ldso/ldso/x86_64/dl-startup.h
@@ -0,0 +1,69 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Architecture specific code used by dl-startup.c
+ * Copyright (C) 2000-2004 by Erik Andersen <andersen@codepoet.org>
+ */
+asm(
+ " .text\n"
+ " .align 16\n"
+ " .global _start\n"
+ " .type _start,%function\n"
+ "_start:\n"
+ " movq %rsp, %rdi\n"
+ " call _dl_start\n"
+ " # Save the user entry point address in %r12.\n"
+ " movq %rax, %r12\n"
+ " # See if we were run as a command with the executable file\n"
+ " # name as an extra leading argument.\n"
+ " movl _dl_skip_args(%rip), %eax\n"
+ " # Pop the original argument count.\n"
+ " popq %rdx\n"
+ " # Adjust the stack pointer to skip _dl_skip_args words.\n"
+ " leaq (%rsp,%rax,8), %rsp\n"
+ " # Subtract _dl_skip_args from argc.\n"
+ " subl %eax, %edx\n"
+ " # Push argc back on the stack.\n"
+ " pushq %rdx\n"
+ " # Pass our finalizer function to the user in %rdx, as per ELF ABI.\n"
+ " leaq _dl_fini(%rip), %rdx\n"
+ " # And make sure %rsp points to argc stored on the stack.\n"
+ " movq %r13, %rsp\n"
+ " # Jump to the user's entry point.\n"
+ " jmp *%r12\n"
+ " .size _start,.-_start\n"
+ " .previous\n"
+);
+
+/* 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)+1)
+
+/* Handle relocation of the symbols in the dynamic loader. */
+static __always_inline
+void PERFORM_BOOTSTRAP_RELOC(ELF_RELOC *rpnt, unsigned long *reloc_addr,
+ unsigned long symbol_addr, unsigned long load_addr, Elf64_Sym *sym)
+{
+ switch (ELF64_R_TYPE(rpnt->r_info)) {
+ case R_X86_64_GLOB_DAT:
+ case R_X86_64_JUMP_SLOT:
+ *reloc_addr = symbol_addr + rpnt->r_addend;
+ break;
+ case R_X86_64_DTPMOD64:
+ *reloc_addr = 1;
+ break;
+ case R_X86_64_NONE:
+ case R_X86_64_DTPOFF64:
+ break;
+ case R_X86_64_TPOFF64:
+ *reloc_addr = sym->st_value + rpnt->r_addend - symbol_addr;
+ 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
diff --git a/ldso/ldso/x86_64/dl-syscalls.h b/ldso/ldso/x86_64/dl-syscalls.h
new file mode 100644
index 000000000..dc0cc6164
--- /dev/null
+++ b/ldso/ldso/x86_64/dl-syscalls.h
@@ -0,0 +1,5 @@
+/* We can't use the real errno in ldso, since it has not yet
+ * been dynamicly linked in yet. */
+extern int _dl_errno;
+#define __set_errno(X) {(_dl_errno) = (X);}
+#include "sys/syscall.h"
diff --git a/ldso/ldso/x86_64/dl-sysdep.h b/ldso/ldso/x86_64/dl-sysdep.h
new file mode 100644
index 000000000..6d73e1e51
--- /dev/null
+++ b/ldso/ldso/x86_64/dl-sysdep.h
@@ -0,0 +1,120 @@
+/* vi: set sw=4 ts=4: */
+/* yoinked from glibc/sysdeps/x86_64/dl-machine.h */
+/* Machine-dependent ELF dynamic relocation inline functions. x86-64 version.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Andreas Jaeger <aj@suse.de>.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* Define this if the system uses RELOCA. */
+#define ELF_USES_RELOCA
+#include <elf.h>
+/* Initialization sequence for the GOT. */
+#define INIT_GOT(GOT_BASE,MODULE) \
+do { \
+ GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
+ GOT_BASE[1] = (unsigned long) MODULE; \
+} while(0)
+
+/* Here we define the magic numbers that this dynamic loader should accept */
+#define MAGIC1 EM_X86_64
+#undef MAGIC2
+
+/* Used for error messages */
+#define ELF_TARGET "x86_64"
+
+struct elf_resolve;
+extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
+
+#define do_rem(result, n, base) ((result) = (n) % (base))
+
+/* 4096 bytes alignment */
+#define PAGE_ALIGN 0xfffff000
+#define ADDR_ALIGN 0xfff
+#define OFFS_ALIGN 0x7ffff000
+
+/* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry or
+ TLS variable, so undefined references should not be allowed to
+ define the value.
+ ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to one
+ of the main executable's symbols, as for a COPY reloc. */
+#define elf_machine_type_class(type) \
+ ((((type) == R_X86_64_JUMP_SLOT) * ELF_RTYPE_CLASS_PLT) \
+ | (((type) == R_X86_64_COPY) * ELF_RTYPE_CLASS_COPY))
+
+/* Return the link-time address of _DYNAMIC. Conveniently, this is the
+ first element of the GOT. This must be inlined in a function which
+ uses global data. */
+static __always_inline Elf64_Addr __attribute__ ((unused))
+elf_machine_dynamic (void)
+{
+ Elf64_Addr addr;
+
+#if 0
+ /* This works because we have our GOT address available in the small PIC
+ model. */
+ addr = (Elf64_Addr) &_DYNAMIC;
+
+ return addr;
+#else
+ asm("mov 0(%%rip), %0"
+ : "=r" (addr));
+ return addr;
+#endif
+}
+
+
+/* Return the run-time load address of the shared object. */
+static __always_inline Elf64_Addr __attribute__ ((unused))
+elf_machine_load_address (void)
+{
+ register Elf64_Addr addr, tmp;
+
+ /* The easy way is just the same as on x86:
+ leaq _dl_start, %0
+ leaq _dl_start(%%rip), %1
+ subq %0, %1
+ but this does not work with binutils since we then have
+ a R_X86_64_32S relocation in a shared lib.
+
+ Instead we store the address of _dl_start in the data section
+ and compare it with the current value that we can get via
+ an RIP relative addressing mode. */
+
+ asm ("movq 1f(%%rip), %1\n"
+ "0:\tleaq _dl_start(%%rip), %0\n\t"
+ "subq %1, %0\n\t"
+ ".section\t.data\n"
+ "1:\t.quad _dl_start\n\t"
+ ".previous\n\t"
+ : "=r" (addr), "=r" (tmp) : : "cc");
+
+ return addr;
+}
+
+static __always_inline void
+elf_machine_relative (Elf64_Addr load_off, const Elf64_Addr rel_addr,
+ Elf64_Word relative_count)
+{
+ Elf64_Rel * rpnt = (void *) rel_addr;
+ --rpnt;
+ do {
+ Elf64_Addr *const reloc_addr = (void *) (load_off + (++rpnt)->r_offset);
+
+ *reloc_addr += load_off;
+ } while (--relative_count);
+}