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)
This commit is contained in:
Peter Wemm
parent
b3aa27a531
commit
9783a12b34
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=115280
@ -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 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld)
|
||||
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;
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user