/*
* Resolve a symbol at run-time.
*/
uint64_t
_dl_bind(elf_object_t *object, int reloff)
{
const elf_object_t *sobj;
const Elf_Sym *sym, *this;
Elf_Addr *addr, ooff;
const char *symn;
Elf_Addr value;
Elf_RelA *rela;
sigset_t savedmask;
rela = (Elf_RelA *)object->dyn.jmprel + reloff;
sym = object->dyn.symtab;
sym += ELF_R_SYM(rela->r_info);
symn = object->dyn.strtab + sym->st_name;
addr = (Elf_Addr *)(object->obj_base + rela->r_offset);
this = NULL;
ooff = _dl_find_symbol(symn, &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT, sym, object, &sobj);
if (this == NULL) {
_dl_printf("lazy binding failed!\n");
*(volatile int *)0 = 0; /* XXX */
}
DL_DEB(("%s: %s\n", symn, sobj->load_name));
value = ooff + this->st_value + rela->r_addend;
if (sobj->traced && _dl_trace_plt(sobj, symn))
return ((uint64_t)value << 32) | (Elf_Addr)sobj->dyn.pltgot;
/* if PLT+GOT is protected, allow the write */
if (object->got_size != 0) {
_dl_thread_bind_lock(0, &savedmask);
/* mprotect the actual modified region, not the whole plt */
_dl_mprotect((void*)addr, sizeof (Elf_Addr) * 2,
PROT_READ|PROT_WRITE|PROT_EXEC);
}
addr[0] = value;
addr[1] = (Elf_Addr)sobj->dyn.pltgot;
/* if PLT is (to be protected, change back to RO */
if (object->got_size != 0) {
/* mprotect the actual modified region, not the whole plt */
_dl_mprotect((void*)addr, sizeof (Elf_Addr) * 3,
PROT_READ|PROT_EXEC);
_dl_thread_bind_lock(1, &savedmask);
}
return ((uint64_t)addr[0] << 32) | addr[1];
}
/*
* Resolve a symbol at run-time.
*/
Elf_Addr
_dl_bind(elf_object_t *object, int reloff)
{
Elf_RelA *rela;
Elf_Addr *addr, ooff;
const Elf_Sym *sym, *this;
const char *symn;
sigset_t savedmask;
rela = (Elf_RelA *)(object->Dyn.info[DT_JMPREL] + reloff);
addr = (Elf_Addr *)(object->obj_base + rela->r_offset);
if (object->plt_size != 0 && !(*addr >= object->plt_start &&
*addr < (object->plt_start + object->plt_size ))) {
/* something is broken, relocation has already occurred */
#if 0
DL_DEB(("*addr doesn't point into plt %p obj %s\n",
*addr, object->load_name));
#endif
return *addr;
}
sym = object->dyn.symtab;
sym += ELF64_R_SYM(rela->r_info);
symn = object->dyn.strtab + sym->st_name;
this = NULL;
ooff = _dl_find_symbol(symn, &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT, sym,
object, NULL);
if (this == NULL) {
_dl_printf("lazy binding failed!\n");
*((int *)0) = 0; /* XXX */
}
/* if PLT is protected, allow the write */
if (object->plt_size != 0) {
_dl_thread_bind_lock(0, &savedmask);
_dl_mprotect(addr, sizeof(Elf_Addr),
PROT_READ|PROT_WRITE);
}
*addr = ooff + this->st_value + rela->r_addend;
/* if PLT is (to be protected, change back to RO/X */
if (object->plt_size != 0) {
_dl_mprotect(addr, sizeof(Elf_Addr),
PROT_READ);
_dl_thread_bind_lock(1, &savedmask);
}
return *addr;
}
Elf_Addr
_dl_bind(elf_object_t *object, int reloff)
{
Elf_RelA *rel;
Elf_Addr *r_addr, ooff, value;
const Elf_Sym *sym, *this;
const char *symn;
const elf_object_t *sobj;
sigset_t savedmask;
rel = (Elf_RelA *)(object->Dyn.info[DT_JMPREL] + reloff);
sym = object->dyn.symtab;
sym += ELF_R_SYM(rel->r_info);
symn = object->dyn.strtab + sym->st_name;
r_addr = (Elf_Addr *)(object->obj_base + rel->r_offset);
this = NULL;
ooff = _dl_find_symbol(symn, &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT, sym, object, &sobj);
if (this == NULL) {
_dl_printf("lazy binding failed!\n");
*(volatile int *)0 = 0; /* XXX */
}
value = ooff + this->st_value + rel->r_addend;
if (sobj->traced && _dl_trace_plt(sobj, symn))
return value;
/* if GOT is protected, allow the write */
if (object->got_size != 0) {
_dl_thread_bind_lock(0, &savedmask);
_dl_mprotect((void*)object->got_start, object->got_size,
PROT_READ|PROT_WRITE);
}
*r_addr = value;
/* put the GOT back to RO */
if (object->got_size != 0) {
_dl_mprotect((void*)object->got_start, object->got_size,
PROT_READ);
_dl_thread_bind_lock(1, &savedmask);
}
return (value);
}
/*
* Resolve a symbol at run-time.
*/
Elf_Addr
_dl_bind(elf_object_t *object, int index)
{
Elf_RelA *rel;
const Elf_Sym *sym, *this;
const char *symn;
const elf_object_t *sobj;
Elf_Addr ooff;
int64_t cookie = pcookie;
struct {
struct __kbind param;
Elf_Addr newval;
} buf;
rel = (Elf_RelA *)(object->Dyn.info[DT_JMPREL]) + index;
sym = object->dyn.symtab;
sym += ELF_R_SYM(rel->r_info);
symn = object->dyn.strtab + sym->st_name;
this = NULL;
ooff = _dl_find_symbol(symn, &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT, sym, object, &sobj);
if (this == NULL) {
_dl_printf("lazy binding failed!\n");
*(volatile int *)0 = 0; /* XXX */
}
buf.newval = ooff + this->st_value + rel->r_addend;
if (__predict_false(sobj->traced) && _dl_trace_plt(sobj, symn))
return (buf.newval);
buf.param.kb_addr = (Elf_Word *)(object->obj_base + rel->r_offset);
buf.param.kb_size = sizeof(Elf_Addr);
/* directly code the syscall, so that it's actually inline here */
{
register long syscall_num __asm("rax") = SYS_kbind;
register void *arg1 __asm("rdi") = &buf;
register long arg2 __asm("rsi") = sizeof(buf);
register long arg3 __asm("rdx") = cookie;
__asm volatile("syscall" : "+r" (syscall_num), "+r" (arg3) :
"r" (arg1), "r" (arg2) : "cc", "rcx", "r11", "memory");
}
return (buf.newval);
}
Elf_Addr
_dl_bind(elf_object_t *object, int symidx)
{
Elf_Addr *gotp = object->dyn.pltgot;
Elf_Addr *addr, ooff;
const Elf_Sym *sym, *this;
const char *symn;
sigset_t savedmask;
int n;
sym = object->dyn.symtab;
sym += symidx;
symn = object->dyn.strtab + sym->st_name;
n = object->Dyn.info[DT_MIPS_LOCAL_GOTNO - DT_LOPROC + DT_NUM] -
object->Dyn.info[DT_MIPS_GOTSYM - DT_LOPROC + DT_NUM];
this = NULL;
ooff = _dl_find_symbol(symn, &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT, sym, object, NULL);
if (this == NULL) {
_dl_printf("lazy binding failed\n");
*((int *)0) = 0; /* XXX */
}
addr = &gotp[n + symidx];
/* if GOT is protected, allow the write */
if (object->got_size != 0) {
_dl_thread_bind_lock(0, &savedmask);
_dl_mprotect(addr, sizeof(Elf_Addr), PROT_READ|PROT_WRITE);
}
*addr = ooff + this->st_value;
/* if GOT is (to be protected, change back to RO */
if (object->got_size != 0) {
_dl_mprotect(addr, sizeof (Elf_Addr), PROT_READ);
_dl_thread_bind_lock(1, &savedmask);
}
return *addr;
}
int
_dl_md_reloc(elf_object_t *object, int rel, int relasz)
{
long i;
long numrela;
int fails = 0;
Elf64_Addr loff;
Elf64_Rela *relas;
struct load_list *llist;
loff = object->obj_base;
numrela = object->Dyn.info[relasz] / sizeof(Elf64_Rela);
relas = (Elf64_Rela *)(object->Dyn.info[rel]);
if (relas == NULL)
return(0);
/*
* unprotect some segments if we need it.
* XXX - we unprotect way to much. only the text can have cow
* relocations.
*/
if ((object->dyn.textrel == 1) && (rel == DT_REL || rel == DT_RELA)) {
for (llist = object->load_list; llist != NULL; llist = llist->next) {
if (!(llist->prot & PROT_WRITE)) {
_dl_mprotect(llist->start, llist->size,
llist->prot|PROT_WRITE);
}
}
}
for (i = 0; i < numrela; i++, relas++) {
Elf64_Addr *r_addr;
Elf64_Addr ooff;
const Elf64_Sym *sym, *this;
const char *symn;
r_addr = (Elf64_Addr *)(relas->r_offset + loff);
if (ELF64_R_SYM(relas->r_info) == 0xffffffff)
continue;
sym = object->dyn.symtab;
sym += ELF64_R_SYM(relas->r_info);
symn = object->dyn.strtab + sym->st_name;
this = NULL;
switch (ELF64_R_TYPE(relas->r_info)) {
case R_TYPE(REFQUAD):
ooff = _dl_find_symbol_bysym(object,
ELF64_R_SYM(relas->r_info), &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_NOTPLT,
sym, NULL);
if (this == NULL)
goto resolve_failed;
*r_addr += ooff + this->st_value + relas->r_addend;
break;
case R_TYPE(RELATIVE):
/*
* There is a lot of unaligned RELATIVE
* relocs generated by gcc in the exception handlers.
*/
if ((((Elf_Addr) r_addr) & 0x7) != 0) {
Elf_Addr tmp;
#if 0
_dl_printf("unaligned RELATIVE: %p type: %d %s 0x%lx -> 0x%lx\n", r_addr,
ELF_R_TYPE(relas->r_info), object->load_name, *r_addr, *r_addr+loff);
#endif
_dl_bcopy(r_addr, &tmp, sizeof(Elf_Addr));
tmp += loff;
_dl_bcopy(&tmp, r_addr, sizeof(Elf_Addr));
} else
*r_addr += loff;
break;
case R_TYPE(JMP_SLOT):
ooff = _dl_find_symbol(symn, &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_PLT,
sym, object, NULL);
if (this == NULL)
goto resolve_failed;
*r_addr = ooff + this->st_value + relas->r_addend;
break;
case R_TYPE(GLOB_DAT):
ooff = _dl_find_symbol_bysym(object,
ELF64_R_SYM(relas->r_info), &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|SYM_NOTPLT,
sym, NULL);
if (this == NULL)
goto resolve_failed;
*r_addr = ooff + this->st_value + relas->r_addend;
break;
case R_TYPE(NONE):
break;
default:
_dl_printf("%s:"
" %s: unsupported relocation '%s' %d at %lx\n",
_dl_progname, object->load_name, symn,
ELF64_R_TYPE(relas->r_info), r_addr );
_dl_exit(1);
}
continue;
resolve_failed:
if (ELF_ST_BIND(sym->st_info) != STB_WEAK)
fails++;
}
__asm __volatile("imb" : : : "memory");
/* reprotect the unprotected segments */
if ((object->dyn.textrel == 1) && (rel == DT_REL || rel == DT_RELA)) {
for (llist = object->load_list; llist != NULL; llist = llist->next) {
if (!(llist->prot & PROT_WRITE))
_dl_mprotect(llist->start, llist->size,
llist->prot);
}
}
return (fails);
}
/*
* Initialize a new dynamic object.
*/
elf_object_t *
_dl_finalize_object(const char *objname, Elf_Dyn *dynp, Elf_Phdr *phdrp,
int phdrc, const int objtype, const long lbase, const long obase)
{
elf_object_t *object;
#if 0
_dl_printf("objname [%s], dynp %p, objtype %x lbase %lx, obase %lx\n",
objname, dynp, objtype, lbase, obase);
#endif
object = _dl_malloc(sizeof(elf_object_t));
object->prev = object->next = NULL;
object->load_dyn = dynp;
while (dynp->d_tag != DT_NULL) {
if (dynp->d_tag < DT_NUM)
object->Dyn.info[dynp->d_tag] = dynp->d_un.d_val;
else if (dynp->d_tag >= DT_LOPROC &&
dynp->d_tag < DT_LOPROC + DT_PROCNUM)
object->Dyn.info[dynp->d_tag + DT_NUM - DT_LOPROC] =
dynp->d_un.d_val;
if (dynp->d_tag == DT_TEXTREL)
object->dyn.textrel = 1;
if (dynp->d_tag == DT_SYMBOLIC)
object->dyn.symbolic = 1;
if (dynp->d_tag == DT_BIND_NOW)
object->obj_flags = RTLD_NOW;
dynp++;
}
/*
* Now relocate all pointer to dynamic info, but only
* the ones which have pointer values.
*/
if (object->Dyn.info[DT_PLTGOT])
object->Dyn.info[DT_PLTGOT] += obase;
if (object->Dyn.info[DT_HASH])
object->Dyn.info[DT_HASH] += obase;
if (object->Dyn.info[DT_STRTAB])
object->Dyn.info[DT_STRTAB] += obase;
if (object->Dyn.info[DT_SYMTAB])
object->Dyn.info[DT_SYMTAB] += obase;
if (object->Dyn.info[DT_RELA])
object->Dyn.info[DT_RELA] += obase;
if (object->Dyn.info[DT_SONAME])
object->Dyn.info[DT_SONAME] += obase;
if (object->Dyn.info[DT_RPATH])
object->Dyn.info[DT_RPATH] += object->Dyn.info[DT_STRTAB];
if (object->Dyn.info[DT_REL])
object->Dyn.info[DT_REL] += obase;
if (object->Dyn.info[DT_INIT])
object->Dyn.info[DT_INIT] += obase;
if (object->Dyn.info[DT_FINI])
object->Dyn.info[DT_FINI] += obase;
if (object->Dyn.info[DT_JMPREL])
object->Dyn.info[DT_JMPREL] += obase;
if (object->Dyn.info[DT_HASH] != 0) {
Elf_Word *hashtab = (Elf_Word *)object->Dyn.info[DT_HASH];
object->nbuckets = hashtab[0];
object->nchains = hashtab[1];
object->buckets = hashtab + 2;
object->chains = object->buckets + object->nbuckets;
}
object->phdrp = phdrp;
object->phdrc = phdrc;
object->obj_type = objtype;
object->load_base = lbase;
object->obj_base = obase;
object->load_name = _dl_strdup(objname);
if (_dl_loading_object == NULL) {
/*
* no loading object, object is the loading object,
* as it is either executable, or dlopened()
*/
_dl_loading_object = object->load_object = object;
DL_DEB(("head %s\n", object->load_name ));
} else {
object->load_object = _dl_loading_object;
}
DL_DEB(("obj %s has %s as head\n", object->load_name,
_dl_loading_object->load_name ));
object->refcount = 0;
TAILQ_INIT(&object->child_list);
object->opencount = 0; /* # dlopen() & exe */
object->grprefcount = 0;
/* default dev, inode for dlopen-able objects. */
object->dev = 0;
object->inode = 0;
TAILQ_INIT(&object->grpsym_list);
TAILQ_INIT(&object->grpref_list);
return(object);
}
int
_dl_md_reloc_got(elf_object_t *object, int lazy)
{
Elf_RelA *rela;
Elf_Addr ooff;
int i, numrela, fails = 0;
const Elf_Sym *this;
if (object->dyn.pltrel != DT_RELA)
return (0);
object->got_addr = 0;
object->got_size = 0;
this = NULL;
ooff = _dl_find_symbol("__got_start", &this,
SYM_SEARCH_OBJ|SYM_NOWARNNOTFOUND|SYM_PLT, NULL, object, NULL );
if (this != NULL)
object->got_addr = ooff + this->st_value;
this = NULL;
ooff = _dl_find_symbol("__got_end", &this,
SYM_SEARCH_OBJ|SYM_NOWARNNOTFOUND|SYM_PLT, NULL, object, NULL);
if (this != NULL)
object->got_size = ooff + this->st_value - object->got_addr;
if (object->got_addr == 0)
object->got_start = 0;
else {
object->got_start = ELF_TRUNC(object->got_addr, _dl_pagesz);
object->got_size += object->got_addr - object->got_start;
object->got_size = ELF_ROUND(object->got_size, _dl_pagesz);
}
if (object->traced)
lazy = 1;
if (!lazy) {
fails = _dl_md_reloc(object, DT_JMPREL, DT_PLTRELSZ);
} else {
register Elf_Addr ltp __asm ("%r19");
Elf_Addr *got = NULL;
rela = (Elf_RelA *)(object->dyn.jmprel);
numrela = object->dyn.pltrelsz / sizeof(Elf_RelA);
ooff = object->obj_base;
/*
* Find the PLT stub by looking at all the
* relocations. The PLT stub should be at the end of
* the .plt section so we start with the last
* relocation, since the linker should have emitted
* them in order.
*/
for (i = numrela - 1; i >= 0; i--) {
got = (Elf_Addr *)(ooff + rela[i].r_offset +
PLT_ENTRY_SIZE + PLT_STUB_SIZE);
if (got[-2] == PLT_STUB_MAGIC1 ||
got[-1] == PLT_STUB_MAGIC2)
break;
got = NULL;
}
if (got == NULL)
return (1);
/*
* Patch up the PLT stub such that it doesn't clobber
* %r22, which is used to pass on the errno values
* from failed system calls to __cerrno() in libc.
*/
got[-7] = PLT_STUB_INSN1;
got[-6] = PLT_STUB_INSN2;
__asm volatile("fdc 0(%0)" :: "r" (&got[-7]));
__asm volatile("fdc 0(%0)" :: "r" (&got[-6]));
__asm volatile("sync");
__asm volatile("fic 0(%%sr0,%0)" :: "r" (&got[-7]));
__asm volatile("fic 0(%%sr0,%0)" :: "r" (&got[-6]));
__asm volatile("sync");
/*
* Fill in the PLT stub such that it invokes the
* _dl_bind_start() trampoline to fix up the
* relocation.
*/
got[1] = (Elf_Addr)object;
got[-2] = (Elf_Addr)&_dl_bind_start;
got[-1] = ltp;
/*
* Even though we didn't modify any instructions it
* seems we still need to syncronize the caches.
* There may be instructions in the same cache line
* and they end up being corrupted otherwise.
*/
__asm volatile("fdc 0(%0)" :: "r" (&got[-2]));
__asm volatile("fdc 0(%0)" :: "r" (&got[-1]));
__asm volatile("sync");
__asm volatile("fic 0(%%sr0,%0)" :: "r" (&got[-2]));
__asm volatile("fic 0(%%sr0,%0)" :: "r" (&got[-1]));
__asm volatile("sync");
for (i = 0; i < numrela; i++, rela++) {
Elf_Addr *r_addr = (Elf_Addr *)(ooff + rela->r_offset);
if (ELF_R_TYPE(rela->r_info) != RELOC_IPLT) {
_dl_printf("unexpected reloc 0x%x\n",
ELF_R_TYPE(rela->r_info));
return (1);
}
if (ELF_R_SYM(rela->r_info)) {
r_addr[0] = (Elf_Addr)got - PLT_STUB_GOTOFF;
r_addr[1] = (Elf_Addr) (rela -
(Elf_RelA *)object->dyn.jmprel);
} else {
r_addr[0] = ooff + rela->r_addend;
r_addr[1] = (Elf_Addr)object->dyn.pltgot;
}
}
}
if (object->got_size != 0)
_dl_mprotect((void *)object->got_start, object->got_size,
GOT_PERMS|PROT_EXEC);
return (fails);
}
int
_dl_md_reloc(elf_object_t *object, int rel, int relsz)
{
int i;
int numrel;
int fails = 0;
struct load_list *load_list;
Elf64_Addr loff;
Elf64_Addr ooff;
Elf64_Addr got_start, got_end;
Elf64_Rel *relocs;
const Elf64_Sym *sym, *this;
loff = object->obj_base;
numrel = object->Dyn.info[relsz] / sizeof(Elf64_Rel);
relocs = (Elf64_Rel *)(object->Dyn.info[rel]);
if (relocs == NULL)
return(0);
/*
* Change protection of all write protected segments in the
* object so we can do relocations in the .rodata section.
* After relocation restore protection.
*/
load_list = object->load_list;
while (load_list != NULL) {
if ((load_list->prot & PROT_WRITE) == 0)
_dl_mprotect(load_list->start, load_list->size,
load_list->prot|PROT_WRITE);
load_list = load_list->next;
}
/* XXX We need the got limits to know if reloc is in got. */
/* XXX Relocs against the got should not include the STUB address! */
this = NULL;
got_start = 0;
got_end = 0;
ooff = _dl_find_symbol("__got_start", &this,
SYM_SEARCH_OBJ|SYM_NOWARNNOTFOUND|SYM_PLT, NULL, object, NULL);
if (this != NULL)
got_start = ooff + this->st_value;
this = NULL;
ooff = _dl_find_symbol("__got_end", &this,
SYM_SEARCH_OBJ|SYM_NOWARNNOTFOUND|SYM_PLT, NULL, object, NULL);
if (this != NULL)
got_end = ooff + this->st_value;
DL_DEB(("relocating %d\n", numrel));
for (i = 0; i < numrel; i++, relocs++) {
Elf64_Addr r_addr = relocs->r_offset + loff;
const char *symn;
int type;
if (ELF64_R_SYM(relocs->r_info) == 0xffffff)
continue;
ooff = 0;
sym = object->dyn.symtab;
sym += ELF64_R_SYM(relocs->r_info);
symn = object->dyn.strtab + sym->st_name;
type = ELF64_R_TYPE(relocs->r_info);
this = NULL;
if (ELF64_R_SYM(relocs->r_info) &&
!(ELF64_ST_BIND(sym->st_info) == STB_LOCAL &&
ELF64_ST_TYPE (sym->st_info) == STT_NOTYPE)) {
ooff = _dl_find_symbol(symn, &this,
SYM_SEARCH_ALL | SYM_WARNNOTFOUND | SYM_PLT,
sym, object, NULL);
if (this == NULL) {
if (ELF_ST_BIND(sym->st_info) != STB_WEAK)
fails++;
continue;
}
}
switch (ELF64_R_TYPE(relocs->r_info)) {
/* XXX Handle non aligned relocs. .eh_frame
* XXX in libstdc++ seems to have them... */
u_int64_t robj;
case R_MIPS_REL32_64:
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL &&
(ELF64_ST_TYPE(sym->st_info) == STT_SECTION ||
ELF64_ST_TYPE(sym->st_info) == STT_NOTYPE) ) {
if ((long)r_addr & 7) {
_dl_bcopy((char *)r_addr, &robj, sizeof(robj));
robj += loff + sym->st_value;
_dl_bcopy(&robj, (char *)r_addr, sizeof(robj));
} else {
*(u_int64_t *)r_addr += loff + sym->st_value;
}
} else if (this && ((long)r_addr & 7)) {
_dl_bcopy((char *)r_addr, &robj, sizeof(robj));
robj += this->st_value + ooff;
_dl_bcopy(&robj, (char *)r_addr, sizeof(robj));
} else if (this) {
*(u_int64_t *)r_addr += this->st_value + ooff;
}
break;
case R_MIPS_NONE:
break;
default:
_dl_printf("%s: unsupported relocation '%d'\n",
_dl_progname, ELF64_R_TYPE(relocs->r_info));
_dl_exit(1);
}
}
DL_DEB(("done %d fails\n", fails));
load_list = object->load_list;
while (load_list != NULL) {
if ((load_list->prot & PROT_WRITE) == 0)
_dl_mprotect(load_list->start, load_list->size,
load_list->prot);
load_list = load_list->next;
}
return(fails);
}
elf_object_t *
_dl_tryload_shlib(const char *libname, int type, int flags)
{
int libfile, i;
struct load_list *next_load, *load_list = NULL;
Elf_Addr maxva = 0, minva = ELFDEFNNAME(NO_ADDR);
Elf_Addr libaddr, loff, align = _dl_pagesz - 1;
elf_object_t *object;
char hbuf[4096];
Elf_Dyn *dynp = 0;
Elf_Ehdr *ehdr;
Elf_Phdr *phdp;
struct stat sb;
void *prebind_data;
#define ROUND_PG(x) (((x) + align) & ~(align))
#define TRUNC_PG(x) ((x) & ~(align))
libfile = _dl_open(libname, O_RDONLY);
if (libfile < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
if ( _dl_fstat(libfile, &sb) < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
for (object = _dl_objects; object != NULL; object = object->next) {
if (object->dev == sb.st_dev &&
object->inode == sb.st_ino) {
object->obj_flags |= flags & DF_1_GLOBAL;
_dl_close(libfile);
if (_dl_loading_object == NULL)
_dl_loading_object = object;
if (object->load_object != _dl_objects &&
object->load_object != _dl_loading_object) {
_dl_link_grpref(object->load_object,
_dl_loading_object);
}
return(object);
}
}
_dl_read(libfile, hbuf, sizeof(hbuf));
ehdr = (Elf_Ehdr *)hbuf;
if (ehdr->e_ident[0] != ELFMAG0 || ehdr->e_ident[1] != ELFMAG1 ||
ehdr->e_ident[2] != ELFMAG2 || ehdr->e_ident[3] != ELFMAG3 ||
ehdr->e_type != ET_DYN || ehdr->e_machine != MACHID) {
_dl_close(libfile);
_dl_errno = DL_NOT_ELF;
return(0);
}
/*
* Alright, we might have a winner!
* Figure out how much VM space we need.
*/
phdp = (Elf_Phdr *)(hbuf + ehdr->e_phoff);
for (i = 0; i < ehdr->e_phnum; i++, phdp++) {
switch (phdp->p_type) {
case PT_LOAD:
if (phdp->p_vaddr < minva)
minva = phdp->p_vaddr;
if (phdp->p_vaddr + phdp->p_memsz > maxva)
maxva = phdp->p_vaddr + phdp->p_memsz;
break;
case PT_DYNAMIC:
dynp = (Elf_Dyn *)phdp->p_vaddr;
break;
case PT_TLS:
_dl_printf("%s: unsupported TLS program header in %s\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_LOAD_OBJ;
return(0);
default:
break;
}
}
minva = TRUNC_PG(minva);
maxva = ROUND_PG(maxva);
/*
* We map the entire area to see that we can get the VM
* space required. Map it unaccessible to start with.
*
* We must map the file we'll map later otherwise the VM
* system won't be able to align the mapping properly
* on VAC architectures.
*/
libaddr = (Elf_Addr)_dl_mmap(0, maxva - minva, PROT_NONE,
MAP_PRIVATE|MAP_FILE, libfile, 0);
if (_dl_mmap_error(libaddr)) {
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
return(0);
}
loff = libaddr - minva;
phdp = (Elf_Phdr *)(hbuf + ehdr->e_phoff);
for (i = 0; i < ehdr->e_phnum; i++, phdp++) {
switch (phdp->p_type) {
case PT_LOAD: {
char *start = (char *)(TRUNC_PG(phdp->p_vaddr)) + loff;
Elf_Addr off = (phdp->p_vaddr & align);
Elf_Addr size = off + phdp->p_filesz;
void *res;
if (size != 0) {
res = _dl_mmap(start, ROUND_PG(size),
PFLAGS(phdp->p_flags),
MAP_FIXED|MAP_PRIVATE, libfile,
TRUNC_PG(phdp->p_offset));
} else
res = NULL; /* silence gcc */
next_load = _dl_malloc(sizeof(struct load_list));
next_load->next = load_list;
load_list = next_load;
next_load->start = start;
next_load->size = size;
next_load->prot = PFLAGS(phdp->p_flags);
if (size != 0 && _dl_mmap_error(res)) {
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
_dl_munmap((void *)libaddr, maxva - minva);
_dl_load_list_free(load_list);
return(0);
}
if (phdp->p_flags & PF_W) {
/* Zero out everything past the EOF */
if ((size & align) != 0)
_dl_memset(start + size, 0,
_dl_pagesz - (size & align));
if (ROUND_PG(size) ==
ROUND_PG(off + phdp->p_memsz))
continue;
start = start + ROUND_PG(size);
size = ROUND_PG(off + phdp->p_memsz) -
ROUND_PG(size);
res = _dl_mmap(start, size,
PFLAGS(phdp->p_flags),
MAP_FIXED|MAP_PRIVATE|MAP_ANON, -1, 0);
if (_dl_mmap_error(res)) {
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
_dl_munmap((void *)libaddr, maxva - minva);
_dl_load_list_free(load_list);
return(0);
}
}
break;
}
case PT_OPENBSD_RANDOMIZE:
_dl_randombuf((char *)(phdp->p_vaddr + loff),
phdp->p_memsz);
break;
default:
break;
}
}
prebind_data = prebind_load_fd(libfile, libname);
_dl_close(libfile);
dynp = (Elf_Dyn *)((unsigned long)dynp + loff);
object = _dl_finalize_object(libname, dynp,
(Elf_Phdr *)((char *)libaddr + ehdr->e_phoff), ehdr->e_phnum,type,
libaddr, loff);
if (object) {
object->prebind_data = prebind_data;
object->load_size = maxva - minva; /*XXX*/
object->load_list = load_list;
/* set inode, dev from stat info */
object->dev = sb.st_dev;
object->inode = sb.st_ino;
object->obj_flags |= flags;
_dl_set_sod(object->load_name, &object->sod);
} else {
_dl_munmap((void *)libaddr, maxva - minva);
_dl_load_list_free(load_list);
}
return(object);
}
elf_object_t *
_dl_tryload_shlib(const char *libname, int type, int flags)
{
int libfile, i;
struct load_list *ld, *lowld = NULL;
elf_object_t *object;
Elf_Dyn *dynp = 0;
Elf_Ehdr *ehdr;
Elf_Phdr *phdp;
Elf_Addr load_end = 0;
Elf_Addr align = _dl_pagesz - 1, off, size;
struct stat sb;
void *prebind_data;
char hbuf[4096];
#define ROUND_PG(x) (((x) + align) & ~(align))
#define TRUNC_PG(x) ((x) & ~(align))
libfile = _dl_open(libname, O_RDONLY);
if (libfile < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
if ( _dl_fstat(libfile, &sb) < 0) {
_dl_errno = DL_CANT_OPEN;
return(0);
}
for (object = _dl_objects; object != NULL; object = object->next) {
if (object->dev == sb.st_dev &&
object->inode == sb.st_ino) {
object->obj_flags |= flags & RTLD_GLOBAL;
_dl_close(libfile);
if (_dl_loading_object == NULL)
_dl_loading_object = object;
if (object->load_object != _dl_objects &&
object->load_object != _dl_loading_object) {
_dl_link_grpref(object->load_object,
_dl_loading_object);
}
return(object);
}
}
_dl_read(libfile, hbuf, sizeof(hbuf));
ehdr = (Elf_Ehdr *)hbuf;
if (ehdr->e_ident[0] != ELFMAG0 || ehdr->e_ident[1] != ELFMAG1 ||
ehdr->e_ident[2] != ELFMAG2 || ehdr->e_ident[3] != ELFMAG3 ||
ehdr->e_type != ET_DYN || ehdr->e_machine != MACHID) {
_dl_close(libfile);
_dl_errno = DL_NOT_ELF;
return(0);
}
/* Insertion sort */
#define LDLIST_INSERT(ld) do { \
struct load_list **_ld; \
for (_ld = &lowld; *_ld != NULL; _ld = &(*_ld)->next) \
if ((*_ld)->moff > ld->moff) \
break; \
ld->next = *_ld; \
*_ld = ld; \
} while (0)
/*
* Alright, we might have a winner!
* Figure out how much VM space we need and set up the load
* list that we'll use to find free VM space.
*/
phdp = (Elf_Phdr *)(hbuf + ehdr->e_phoff);
for (i = 0; i < ehdr->e_phnum; i++, phdp++) {
switch (phdp->p_type) {
case PT_LOAD:
off = (phdp->p_vaddr & align);
size = off + phdp->p_filesz;
ld = _dl_malloc(sizeof(struct load_list));
ld->start = NULL;
ld->size = size;
ld->moff = TRUNC_PG(phdp->p_vaddr);
ld->foff = TRUNC_PG(phdp->p_offset);
ld->prot = PFLAGS(phdp->p_flags);
LDLIST_INSERT(ld);
if ((ld->prot & PROT_WRITE) == 0 ||
ROUND_PG(size) == ROUND_PG(off + phdp->p_memsz))
break;
/* This phdr has a zfod section */
ld = _dl_malloc(sizeof(struct load_list));
ld->start = NULL;
ld->size = ROUND_PG(off + phdp->p_memsz) -
ROUND_PG(size);
ld->moff = TRUNC_PG(phdp->p_vaddr) +
ROUND_PG(size);
ld->foff = -1;
ld->prot = PFLAGS(phdp->p_flags);
LDLIST_INSERT(ld);
break;
case PT_DYNAMIC:
dynp = (Elf_Dyn *)phdp->p_vaddr;
break;
default:
break;
}
}
#define LOFF ((Elf_Addr)lowld->start - lowld->moff)
retry:
for (ld = lowld; ld != NULL; ld = ld->next) {
off_t foff;
int fd, flags;
/*
* We don't want to provide the fd/off hint for anything
* but the first mapping, all other might have
* cache-incoherent aliases and will cause this code to
* loop forever.
*/
if (ld == lowld) {
fd = libfile;
foff = ld->foff;
flags = 0;
} else {
fd = -1;
foff = 0;
flags = MAP_FIXED;
}
ld->start = (void *)(LOFF + ld->moff);
/*
* Magic here.
* The first mquery is done with MAP_FIXED to see if
* the mapping we want is free. If it's not, we redo the
* mquery without MAP_FIXED to get the next free mapping,
* adjust the base mapping address to match this free mapping
* and restart the process again.
*/
ld->start = _dl_mquery(ld->start, ROUND_PG(ld->size), ld->prot,
flags, fd, foff);
if (_dl_mmap_error(ld->start)) {
ld->start = (void *)(LOFF + ld->moff);
ld->start = _dl_mquery(ld->start, ROUND_PG(ld->size),
ld->prot, flags & ~MAP_FIXED, fd, foff);
if (_dl_mmap_error(ld->start))
goto fail;
}
if (ld->start != (void *)(LOFF + ld->moff)) {
lowld->start = ld->start - ld->moff + lowld->moff;
goto retry;
}
/*
* XXX - we need some kind of boundary condition here,
* or fix mquery to not run into the stack
*/
}
for (ld = lowld; ld != NULL; ld = ld->next) {
int fd, flags;
off_t foff;
void *res;
if (ld->foff < 0) {
fd = -1;
foff = 0;
flags = MAP_FIXED|MAP_PRIVATE|MAP_ANON;
} else {
fd = libfile;
foff = ld->foff;
flags = MAP_FIXED|MAP_PRIVATE;
}
res = _dl_mmap(ld->start, ROUND_PG(ld->size), ld->prot, flags,
fd, foff);
if (_dl_mmap_error(res))
goto fail;
/* Zero out everything past the EOF */
if ((ld->prot & PROT_WRITE) != 0 && (ld->size & align) != 0)
_dl_memset((char *)ld->start + ld->size, 0,
_dl_pagesz - (ld->size & align));
load_end = (Elf_Addr)ld->start + ROUND_PG(ld->size);
}
prebind_data = prebind_load_fd(libfile, libname);
_dl_close(libfile);
dynp = (Elf_Dyn *)((unsigned long)dynp + LOFF);
object = _dl_finalize_object(libname, dynp,
(Elf_Phdr *)((char *)lowld->start + ehdr->e_phoff), ehdr->e_phnum,
type, (Elf_Addr)lowld->start, LOFF);
if (object) {
object->prebind_data = prebind_data;
object->load_size = (Elf_Addr)load_end - (Elf_Addr)lowld->start;
object->load_list = lowld;
/* set inode, dev from stat info */
object->dev = sb.st_dev;
object->inode = sb.st_ino;
object->obj_flags |= flags;
_dl_build_sod(object->load_name, &object->sod);
} else {
/* XXX no point. object is never returned NULL */
_dl_load_list_free(lowld);
}
return(object);
fail:
_dl_printf("%s: rtld mmap failed mapping %s.\n",
_dl_progname, libname);
_dl_close(libfile);
_dl_errno = DL_CANT_MMAP;
_dl_load_list_free(lowld);
return(0);
}
int
_dl_md_reloc(elf_object_t *object, int rel, int relasz)
{
int i;
int numrela;
int relrel;
int fails = 0;
struct load_list *llist;
Elf32_Addr loff;
Elf32_Rela *relas;
loff = object->obj_base;
numrela = object->Dyn.info[relasz] / sizeof(Elf32_Rela);
relrel = rel == DT_RELA ? object->relacount : 0;
relas = (Elf32_Rela *)(object->Dyn.info[rel]);
#ifdef DL_PRINTF_DEBUG
_dl_printf("object relocation size %x, numrela %x\n",
object->Dyn.info[relasz], numrela);
#endif
if (relas == NULL)
return(0);
if (relrel > numrela) {
_dl_printf("relacount > numrela: %ld > %ld\n", relrel, numrela);
_dl_exit(20);
}
/*
* Change protection of all write protected segments in the object
* so we can do relocations such as PC32. After relocation,
* restore protection.
*/
if (object->dyn.textrel == 1 && (rel == DT_REL || rel == DT_RELA)) {
for (llist = object->load_list; llist != NULL;
llist = llist->next) {
if (!(llist->prot & PROT_WRITE)) {
_dl_mprotect(llist->start, llist->size,
llist->prot|PROT_WRITE);
}
}
}
/* tight loop for leading RELATIVE relocs */
for (i = 0; i < relrel; i++, relas++) {
Elf32_Addr *r_addr;
#ifdef DEBUG
if (ELF_R_TYPE(relas->r_info) != R_68K_RELATIVE) {
_dl_printf("RELACOUNT wrong\n");
_dl_exit(20);
}
#endif
r_addr = (Elf32_Addr *)(relas->r_offset + loff);
*r_addr = relas->r_addend + loff;
}
for (; i < numrela; i++, relas++) {
Elf32_Addr *r_addr = (Elf32_Addr *)(relas->r_offset + loff);
Elf32_Addr ooff, addend, newval;
const Elf32_Sym *sym, *this;
const char *symn;
int type;
Elf32_Addr prev_value = 0, prev_ooff = 0;
const Elf32_Sym *prev_sym = NULL;
type = ELF32_R_TYPE(relas->r_info);
if (type == R_68K_JMP_SLOT && rel != DT_JMPREL)
continue;
if (type == R_68K_NONE)
continue;
sym = object->dyn.symtab;
sym += ELF32_R_SYM(relas->r_info);
symn = object->dyn.strtab + sym->st_name;
if (type == R_68K_COPY) {
/*
* we need to find a symbol, that is not in the current
* object, start looking at the beginning of the list,
* searching all objects but _not_ the current object,
* first one found wins.
*/
const Elf32_Sym *cpysrc = NULL;
Elf32_Addr src_loff;
int size;
src_loff = 0;
src_loff = _dl_find_symbol(symn, &cpysrc,
SYM_SEARCH_OTHER|SYM_WARNNOTFOUND| SYM_NOTPLT,
sym, object, NULL);
if (cpysrc != NULL) {
size = sym->st_size;
if (sym->st_size != cpysrc->st_size) {
/* _dl_find_symbol() has warned
about this already */
size = sym->st_size < cpysrc->st_size ?
sym->st_size : cpysrc->st_size;
}
_dl_bcopy((void *)(src_loff + cpysrc->st_value),
r_addr, size);
} else
fails++;
continue;
}
if (ELF32_R_SYM(relas->r_info) &&
!(ELF32_ST_BIND(sym->st_info) == STB_LOCAL &&
ELF32_ST_TYPE (sym->st_info) == STT_NOTYPE) &&
sym != prev_sym) {
this = NULL;
ooff = _dl_find_symbol_bysym(object,
ELF32_R_SYM(relas->r_info), &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|
((type == R_68K_JMP_SLOT) ? SYM_PLT:SYM_NOTPLT),
sym, NULL);
if (this == NULL) {
if (ELF_ST_BIND(sym->st_info) != STB_WEAK)
fails++;
continue;
}
prev_sym = sym;
prev_value = this->st_value;
prev_ooff = ooff;
}
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL &&
(ELF32_ST_TYPE(sym->st_info) == STT_SECTION ||
ELF32_ST_TYPE(sym->st_info) == STT_NOTYPE))
addend = relas->r_addend;
else
addend = prev_value + relas->r_addend;
switch (type) {
case R_68K_PC32:
newval = prev_ooff + addend;
newval -= (Elf_Addr)r_addr;
*r_addr = newval;
break;
case R_68K_32:
case R_68K_GLOB_DAT:
case R_68K_JMP_SLOT:
newval = prev_ooff + addend;
*r_addr = newval;
break;
case R_68K_RELATIVE:
newval = loff + addend;
*r_addr = newval;
break;
default:
_dl_printf("%s:"
" %s: unsupported relocation '%s' %d at %x\n",
_dl_progname, object->load_name, symn,
ELF32_R_TYPE(relas->r_info), r_addr);
_dl_exit(1);
}
}
/* reprotect the unprotected segments */
if (object->dyn.textrel == 1 && (rel == DT_REL || rel == DT_RELA)) {
for (llist = object->load_list; llist != NULL;
llist = llist->next) {
if (!(llist->prot & PROT_WRITE))
_dl_mprotect(llist->start, llist->size,
llist->prot);
}
}
return(fails);
}
/*
* Initialize a new dynamic object.
*/
elf_object_t *
_dl_finalize_object(const char *objname, Elf_Dyn *dynp, Elf_Phdr *phdrp,
int phdrc, const int objtype, const long lbase, const long obase)
{
elf_object_t *object;
#if 0
_dl_printf("objname [%s], dynp %p, objtype %x lbase %lx, obase %lx\n",
objname, dynp, objtype, lbase, obase);
#endif
object = _dl_calloc(1, sizeof(elf_object_t));
if (object == NULL)
_dl_exit(7);
object->prev = object->next = NULL;
object->load_dyn = dynp;
while (dynp->d_tag != DT_NULL) {
if (dynp->d_tag < DT_NUM)
object->Dyn.info[dynp->d_tag] = dynp->d_un.d_val;
else if (dynp->d_tag >= DT_LOPROC &&
dynp->d_tag < DT_LOPROC + DT_PROCNUM)
object->Dyn.info[dynp->d_tag + DT_NUM - DT_LOPROC] =
dynp->d_un.d_val;
if (dynp->d_tag == DT_TEXTREL)
object->dyn.textrel = 1;
if (dynp->d_tag == DT_SYMBOLIC)
object->dyn.symbolic = 1;
if (dynp->d_tag == DT_BIND_NOW)
object->obj_flags |= DF_1_NOW;
if (dynp->d_tag == DT_FLAGS_1)
object->obj_flags |= dynp->d_un.d_val;
if (dynp->d_tag == DT_RELACOUNT)
object->relacount = dynp->d_un.d_val;
if (dynp->d_tag == DT_RELCOUNT)
object->relcount = dynp->d_un.d_val;
dynp++;
}
DL_DEB((" flags %s = 0x%x\n", objname, object->obj_flags ));
object->obj_type = objtype;
if (_dl_loading_object == NULL) {
/*
* no loading object, object is the loading object,
* as it is either executable, or dlopened()
*/
_dl_loading_object = object;
}
if ((object->obj_flags & DF_1_NOOPEN) != 0 &&
_dl_loading_object->obj_type == OBJTYPE_DLO &&
_dl_traceld == NULL) {
_dl_free(object);
_dl_errno = DL_CANT_LOAD_OBJ;
return(NULL);
}
/*
* Now relocate all pointer to dynamic info, but only
* the ones which have pointer values.
*/
if (object->Dyn.info[DT_PLTGOT])
object->Dyn.info[DT_PLTGOT] += obase;
if (object->Dyn.info[DT_HASH])
object->Dyn.info[DT_HASH] += obase;
if (object->Dyn.info[DT_STRTAB])
object->Dyn.info[DT_STRTAB] += obase;
if (object->Dyn.info[DT_SYMTAB])
object->Dyn.info[DT_SYMTAB] += obase;
if (object->Dyn.info[DT_RELA])
object->Dyn.info[DT_RELA] += obase;
if (object->Dyn.info[DT_SONAME])
object->Dyn.info[DT_SONAME] += object->Dyn.info[DT_STRTAB];
if (object->Dyn.info[DT_RPATH])
object->Dyn.info[DT_RPATH] += object->Dyn.info[DT_STRTAB];
if (object->Dyn.info[DT_REL])
object->Dyn.info[DT_REL] += obase;
if (object->Dyn.info[DT_INIT])
object->Dyn.info[DT_INIT] += obase;
if (object->Dyn.info[DT_FINI])
object->Dyn.info[DT_FINI] += obase;
if (object->Dyn.info[DT_JMPREL])
object->Dyn.info[DT_JMPREL] += obase;
if (object->Dyn.info[DT_HASH] != 0) {
Elf_Word *hashtab = (Elf_Word *)object->Dyn.info[DT_HASH];
object->nbuckets = hashtab[0];
object->nchains = hashtab[1];
object->buckets = hashtab + 2;
object->chains = object->buckets + object->nbuckets;
}
object->phdrp = phdrp;
object->phdrc = phdrc;
object->load_base = lbase;
object->obj_base = obase;
object->load_name = _dl_strdup(objname);
if (object->load_name == NULL)
_dl_exit(7);
object->load_object = _dl_loading_object;
if (object->load_object == object)
DL_DEB(("head %s\n", object->load_name));
DL_DEB(("obj %s has %s as head\n", object->load_name,
_dl_loading_object->load_name ));
object->refcount = 0;
TAILQ_INIT(&object->child_list);
object->opencount = 0; /* # dlopen() & exe */
object->grprefcount = 0;
/* default dev, inode for dlopen-able objects. */
object->dev = 0;
object->inode = 0;
object->grpsym_gen = 0;
TAILQ_INIT(&object->grpsym_list);
TAILQ_INIT(&object->grpref_list);
if (object->dyn.rpath) {
object->rpath = _dl_split_path(object->dyn.rpath);
if ((object->obj_flags & DF_1_ORIGIN) && _dl_trust)
_dl_origin_subst(object);
}
_dl_trace_object_setup(object);
return (object);
}
int
_dl_md_reloc(elf_object_t *object, int rel, int relsz)
{
long i;
long numrel;
long relrel;
int fails = 0;
Elf_Addr loff;
Elf_Addr prev_value = 0;
const Elf_Sym *prev_sym = NULL;
Elf_RelA *rels;
struct load_list *llist;
loff = object->obj_base;
numrel = object->Dyn.info[relsz] / sizeof(Elf_RelA);
relrel = rel == DT_RELA ? object->relacount : 0;
rels = (Elf_RelA *)(object->Dyn.info[rel]);
if (rels == NULL)
return(0);
if (relrel > numrel) {
_dl_printf("relacount > numrel: %ld > %ld\n", relrel, numrel);
_dl_exit(20);
}
/*
* unprotect some segments if we need it.
*/
if ((object->dyn.textrel == 1) && (rel == DT_REL || rel == DT_RELA)) {
for (llist = object->load_list; llist != NULL; llist = llist->next) {
if (!(llist->prot & PROT_WRITE))
_dl_mprotect(llist->start, llist->size,
PROT_READ | PROT_WRITE);
}
}
/* tight loop for leading RELATIVE relocs */
for (i = 0; i < relrel; i++, rels++) {
Elf_Addr *where;
#ifdef DEBUG
if (ELF_R_TYPE(rels->r_info) != R_TYPE(RELATIVE)) {
_dl_printf("RELACOUNT wrong\n");
_dl_exit(20);
}
#endif
where = (Elf_Addr *)(rels->r_offset + loff);
*where = rels->r_addend + loff;
}
for (; i < numrel; i++, rels++) {
Elf_Addr *where, value, ooff, mask;
Elf_Word type;
const Elf_Sym *sym, *this;
const char *symn;
type = ELF_R_TYPE(rels->r_info);
if (RELOC_ERROR(type)) {
_dl_printf("relocation error %d idx %d\n", type, i);
_dl_exit(20);
}
if (type == R_TYPE(NONE))
continue;
if (type == R_TYPE(JUMP_SLOT) && rel != DT_JMPREL)
continue;
where = (Elf_Addr *)(rels->r_offset + loff);
if (RELOC_USE_ADDEND(type))
value = rels->r_addend;
else
value = 0;
sym = NULL;
symn = NULL;
if (RELOC_RESOLVE_SYMBOL(type)) {
sym = object->dyn.symtab;
sym += ELF_R_SYM(rels->r_info);
symn = object->dyn.strtab + sym->st_name;
if (sym->st_shndx != SHN_UNDEF &&
ELF_ST_BIND(sym->st_info) == STB_LOCAL) {
value += loff;
} else if (sym == prev_sym) {
value += prev_value;
} else {
this = NULL;
ooff = _dl_find_symbol_bysym(object,
ELF_R_SYM(rels->r_info), &this,
SYM_SEARCH_ALL|SYM_WARNNOTFOUND|
((type == R_TYPE(JUMP_SLOT))?
SYM_PLT:SYM_NOTPLT),
sym, NULL);
if (this == NULL) {
resolve_failed:
if (ELF_ST_BIND(sym->st_info) !=
STB_WEAK)
fails++;
continue;
}
prev_sym = sym;
prev_value = (Elf_Addr)(ooff + this->st_value);
value += prev_value;
}
}
if (type == R_TYPE(JUMP_SLOT)) {
_dl_reloc_plt(where, value);
continue;
}
if (type == R_TYPE(COPY)) {
void *dstaddr = where;
const void *srcaddr;
const Elf_Sym *dstsym = sym, *srcsym = NULL;
Elf_Addr soff;
soff = _dl_find_symbol(symn, &srcsym,
SYM_SEARCH_OTHER|SYM_WARNNOTFOUND|SYM_NOTPLT,
dstsym, object, NULL);
if (srcsym == NULL)
goto resolve_failed;
srcaddr = (void *)(soff + srcsym->st_value);
_dl_bcopy(srcaddr, dstaddr, dstsym->st_size);
continue;
}
if (RELOC_PC_RELATIVE(type))
value -= (Elf_Addr)where;
if (RELOC_BASE_RELATIVE(type))
value += loff;
mask = RELOC_VALUE_BITMASK(type);
value >>= RELOC_VALUE_RIGHTSHIFT(type);
value &= mask;
if (RELOC_TARGET_SIZE(type) > 32) {
*where &= ~mask;
*where |= value;
} else {
Elf32_Addr *where32 = (Elf32_Addr *)where;
*where32 &= ~mask;
*where32 |= value;
}
}
/* reprotect the unprotected segments */
if ((object->dyn.textrel == 1) && (rel == DT_REL || rel == DT_RELA)) {
for (llist = object->load_list; llist != NULL; llist = llist->next) {
if (!(llist->prot & PROT_WRITE))
_dl_mprotect(llist->start, llist->size,
llist->prot);
}
}
return (fails);
}
