Initial pass at supporting shared libraries on amd64. There are still

a few missing relocation types in amd64/reloc.c, but I have not found
any of them in use yet. :-)

Approved by:  re (amd64/* blanket)

2 files changed, 101 insertions, 73 deletions

diff --git a/libexec/rtld-elf/amd64/reloc.c b/libexec/rtld-elf/amd64/reloc.c
index 6778574..fa735f4 100644
--- a/libexec/rtld-elf/amd64/reloc.c
+++ b/libexec/rtld-elf/amd64/reloc.c
@@ -48,7 +48,7 @@
 #include "rtld.h"
 
 /*
- * Process the special R_386_COPY relocations in the main program.  These
+ * Process the special R_X86_64_COPY relocations in the main program.  These
  * copy data from a shared object into a region in the main program's BSS
  * segment.
  *
@@ -57,14 +57,14 @@
 int
 do_copy_relocations(Obj_Entry *dstobj)
 {
-    const Elf_Rel *rellim;
-    const Elf_Rel *rel;
+    const Elf_Rela *relalim;
+    const Elf_Rela *rela;
 
     assert(dstobj->mainprog);	/* COPY relocations are invalid elsewhere */
 
-    rellim = (const Elf_Rel *) ((caddr_t) dstobj->rel + dstobj->relsize);
-    for (rel = dstobj->rel;  rel < rellim;  rel++) {
-	if (ELF_R_TYPE(rel->r_info) == R_386_COPY) {
+    relalim = (const Elf_Rela *) ((caddr_t) dstobj->rela + dstobj->relasize);
+    for (rela = dstobj->rela;  rela < relalim;  rela++) {
+	if (ELF_R_TYPE(rela->r_info) == R_X86_64_COPY) {
 	    void *dstaddr;
 	    const Elf_Sym *dstsym;
 	    const char *name;
@@ -74,8 +74,8 @@ do_copy_relocations(Obj_Entry *dstobj)
 	    const Elf_Sym *srcsym;
 	    Obj_Entry *srcobj;
 
-	    dstaddr = (void *) (dstobj->relocbase + rel->r_offset);
-	    dstsym = dstobj->symtab + ELF_R_SYM(rel->r_info);
+	    dstaddr = (void *) (dstobj->relocbase + rela->r_offset);
+	    dstsym = dstobj->symtab + ELF_R_SYM(rela->r_info);
 	    name = dstobj->strtab + dstsym->st_name;
 	    hash = elf_hash(name);
 	    size = dstsym->st_size;
@@ -112,8 +112,8 @@ init_pltgot(Obj_Entry *obj)
 int
 reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
 {
-	const Elf_Rel *rellim;
-	const Elf_Rel *rel;
+	const Elf_Rela *relalim;
+	const Elf_Rela *rela;
 	SymCache *cache;
 	int bytes = obj->nchains * sizeof(SymCache);
 	int r = -1;
@@ -126,30 +126,30 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
 	if (cache == MAP_FAILED)
 	    cache = NULL;
 
-	rellim = (const Elf_Rel *) ((caddr_t) obj->rel + obj->relsize);
-	for (rel = obj->rel;  rel < rellim;  rel++) {
-	    Elf_Addr *where = (Elf_Addr *) (obj->relocbase + rel->r_offset);
+	relalim = (const Elf_Rela *) ((caddr_t) obj->rela + obj->relasize);
+	for (rela = obj->rela;  rela < relalim;  rela++) {
+	    Elf_Addr *where = (Elf_Addr *) (obj->relocbase + rela->r_offset);
 
-	    switch (ELF_R_TYPE(rel->r_info)) {
+	    switch (ELF_R_TYPE(rela->r_info)) {
 
-	    case R_386_NONE:
+	    case R_X86_64_NONE:
 		break;
 
-	    case R_386_32:
+	    case R_X86_64_64:
 		{
 		    const Elf_Sym *def;
 		    const Obj_Entry *defobj;
 
-		    def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
+		    def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 		      false, cache);
 		    if (def == NULL)
 			goto done;
 
-		    *where += (Elf_Addr) (defobj->relocbase + def->st_value);
+		    *where = (Elf_Addr) (defobj->relocbase + def->st_value + rela->r_addend);
 		}
 		break;
 
-	    case R_386_PC32:
+	    case R_X86_64_PC32:
 		/*
 		 * I don't think the dynamic linker should ever see this
 		 * type of relocation.  But the binutils-2.6 tools sometimes
@@ -159,18 +159,19 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
 		    const Elf_Sym *def;
 		    const Obj_Entry *defobj;
 
-		    def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
+		    def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 		      false, cache);
 		    if (def == NULL)
 			goto done;
 
-		    *where +=
-		      (Elf_Addr) (defobj->relocbase + def->st_value) -
+		    *where =
+		      (Elf_Addr) (defobj->relocbase + def->st_value + rela->r_addend) -
 		      (Elf_Addr) where;
 		}
 		break;
+	/* missing: R_X86_64_GOT32 R_X86_64_PLT32 */
 
-	    case R_386_COPY:
+	    case R_X86_64_COPY:
 		/*
 		 * These are deferred until all other relocations have
 		 * been done.  All we do here is make sure that the COPY
@@ -178,18 +179,18 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
 		 * only in executable files.
 		 */
 		if (!obj->mainprog) {
-		    _rtld_error("%s: Unexpected R_386_COPY relocation"
+		    _rtld_error("%s: Unexpected R_X86_64_COPY relocation"
 		      " in shared library", obj->path);
 		    goto done;
 		}
 		break;
 
-	    case R_386_GLOB_DAT:
+	    case R_X86_64_GLOB_DAT:
 		{
 		    const Elf_Sym *def;
 		    const Obj_Entry *defobj;
 
-		    def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj,
+		    def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj,
 		      false, cache);
 		    if (def == NULL)
 			goto done;
@@ -198,14 +199,16 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
 		}
 		break;
 
-	    case R_386_RELATIVE:
-		*where += (Elf_Addr) obj->relocbase;
+	    case R_X86_64_RELATIVE:
+		*where = (Elf_Addr)(obj->relocbase + rela->r_addend);
 		break;
 
+	/* missing: R_X86_64_GOTPCREL, R_X86_64_32, R_X86_64_32S, R_X86_64_16, R_X86_64_PC16, R_X86_64_8, R_X86_64_PC8 */
+
 	    default:
 		_rtld_error("%s: Unsupported relocation type %d"
 		  " in non-PLT relocations\n", obj->path,
-		  ELF_R_TYPE(rel->r_info));
+		  ELF_R_TYPE(rela->r_info));
 		goto done;
 	    }
 	}
@@ -220,17 +223,17 @@ done:
 int
 reloc_plt(Obj_Entry *obj)
 {
-    const Elf_Rel *rellim;
-    const Elf_Rel *rel;
+    const Elf_Rela *relalim;
+    const Elf_Rela *rela;
 
-    rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
-    for (rel = obj->pltrel;  rel < rellim;  rel++) {
+    relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+    for (rela = obj->pltrela;  rela < relalim;  rela++) {
 	Elf_Addr *where;
 
-	assert(ELF_R_TYPE(rel->r_info) == R_386_JMP_SLOT);
+	assert(ELF_R_TYPE(rela->r_info) == R_X86_64_JMP_SLOT);
 
 	/* Relocate the GOT slot pointing into the PLT. */
-	where = (Elf_Addr *)(obj->relocbase + rel->r_offset);
+	where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
 	*where += (Elf_Addr)obj->relocbase;
     }
     return 0;
@@ -240,24 +243,24 @@ reloc_plt(Obj_Entry *obj)
 int
 reloc_jmpslots(Obj_Entry *obj)
 {
-    const Elf_Rel *rellim;
-    const Elf_Rel *rel;
+    const Elf_Rela *relalim;
+    const Elf_Rela *rela;
 
     if (obj->jmpslots_done)
 	return 0;
-    rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
-    for (rel = obj->pltrel;  rel < rellim;  rel++) {
+    relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+    for (rela = obj->pltrela;  rela < relalim;  rela++) {
 	Elf_Addr *where, target;
 	const Elf_Sym *def;
 	const Obj_Entry *defobj;
 
-	assert(ELF_R_TYPE(rel->r_info) == R_386_JMP_SLOT);
-	where = (Elf_Addr *)(obj->relocbase + rel->r_offset);
-	def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj, true, NULL);
+	assert(ELF_R_TYPE(rela->r_info) == R_X86_64_JMP_SLOT);
+	where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
+	def = find_symdef(ELF_R_SYM(rela->r_info), obj, &defobj, true, NULL);
 	if (def == NULL)
 	    return -1;
-	target = (Elf_Addr)(defobj->relocbase + def->st_value);
-	reloc_jmpslot(where, target, defobj, obj, rel);
+	target = (Elf_Addr)(defobj->relocbase + def->st_value + rela->r_addend);
+	reloc_jmpslot(where, target, defobj, obj, (const Elf_Rel *)rela);
     }
     obj->jmpslots_done = true;
     return 0;
diff --git a/libexec/rtld-elf/amd64/rtld_start.S b/libexec/rtld-elf/amd64/rtld_start.S
index 76f1392..c2c6b9c 100644
--- a/libexec/rtld-elf/amd64/rtld_start.S
+++ b/libexec/rtld-elf/amd64/rtld_start.S
@@ -30,27 +30,24 @@
 	.globl	.rtld_start
 	.type	.rtld_start,@function
 .rtld_start:
-	xorl	%ebp,%ebp		# Clear frame pointer for good form
-	movl	%esp,%eax		# Save initial stack pointer
-	subl	$8,%esp			# A place to store exit procedure addr
-	movl	%esp,%ebx		# save address of exit proc
-	movl	%esp,%ecx		# construct address of obj_main
-	addl	$4,%ecx
-	pushl	%ecx			# Pass address of obj_main
-	pushl	%ebx			# Pass address of exit proc
-	pushl	%eax			# Pass initial stack pointer to rtld
+	xorq	%rbp,%rbp		# Clear frame pointer for good form
+	subq	$16,%rsp		# A place to store exit procedure addr
+	movq	%rdi,%r12
+	movq	%rsp,%rsi		# save address of exit proc
+	movq	%rsp,%rdx		# construct address of obj_main
+	addq	$8,%rdx
 	call	_rtld@PLT		# Call rtld(sp); returns entry point
-	addl	$12,%esp		# Remove arguments from stack
-	popl	%edx			# Get exit procedure address
-	addl	$4,%esp			# Ignore obj_main
+	popq	%rsi			# Get exit procedure address
+	addq	$8,%rsp			# Ignore obj_main
+	movq	%r12,%rdi		# *ap
 /*
- * At this point, %eax contains the entry point of the main program, and
- * %edx contains a pointer to a termination function that should be
+ * At this point, %rax contains the entry point of the main program, and
+ * %rdx contains a pointer to a termination function that should be
  * registered with atexit().  (crt1.o registers it.)
  */
 .globl .rtld_goto_main
 .rtld_goto_main:	# This symbol exists just to make debugging easier.
-	jmp	*%eax			# Enter main program
+	jmp	*%rax			# Enter main program
 
 
 /*
@@ -63,26 +60,54 @@
  * We are careful to preserve all registers, even the the caller-save
  * registers.  That is because this code may be invoked by low-level
  * assembly-language code that is not ABI-compliant.
+ *
+ * Stack map:
+ * reloff       0x58
+ * obj          0x50
+ * rflags       0x48
+ * rax          0x40
+ * rdx          0x38
+ * rcx          0x30
+ * rsi          0x28
+ * rdi          0x20
+ * r8           0x18
+ * r9           0x10
+ * r10          0x8
+ * r11          0x0
  */
 	.align	4
 	.globl	_rtld_bind_start
 	.type	_rtld_bind_start,@function
 _rtld_bind_start:
-	pushf				# Save eflags
-	pushl	%eax			# Save %eax
-	pushl	%edx			# Save %edx
-	pushl	%ecx			# Save %ecx
-	pushl	20(%esp)		# Copy reloff argument
-	pushl	20(%esp)		# Copy obj argument
+	pushfq				# Save rflags
+	pushq	%rax			# Save %rax
+	pushq	%rdx			# Save %rdx
+	pushq	%rcx			# Save %rcx
+	pushq	%rsi			# Save %rsi
+	pushq	%rdi			# Save %rdi
+	pushq	%r8			# Save %r8
+	pushq	%r9			# Save %r9
+	pushq	%r10			# Save %r10
+	pushq	%r11			# Save %r11
+
+	movq	0x50(%rsp),%rdi		# Fetch obj argument
+	movq	0x58(%rsp),%rsi		# Fetch reloff argument
+	leaq	(%rsi,%rsi,2),%rsi	# multiply by 3
+	leaq	(,%rsi,8),%rsi		# now 8, for 24 (sizeof Elf_Rela)
 
 	call	_rtld_bind@PLT		# Transfer control to the binder
-	/* Now %eax contains the entry point of the function being called. */
+	/* Now %rax contains the entry point of the function being called. */
 
-	addl	$8,%esp			# Discard binder arguments
-	movl	%eax,20(%esp)		# Store target over obj argument
-	popl	%ecx			# Restore %ecx
-	popl	%edx			# Restore %edx
-	popl	%eax			# Restore %eax
-	popf				# Restore eflags
-	leal	4(%esp),%esp		# Discard reloff, do not change eflags
+	movq	%rax,0x58(%rsp)		# Store target over reloff argument
+	popq	%r11			# Restore %r11
+	popq	%r10			# Restore %r10
+	popq	%r9			# Restore %r9
+	popq	%r8			# Restore %r8
+	popq	%rdi			# Restore %rdi
+	popq	%rsi			# Restore %rsi
+	popq	%rcx			# Restore %rcx
+	popq	%rdx			# Restore %rdx
+	popq	%rax			# Restore %rax
+	popfq				# Restore rflags
+	leaq	8(%rsp),%rsp		# Discard obj, do not change rflags
 	ret				# "Return" to target address