unsigned long _dl_linux_resolver(unsigned long got_offset, unsigned long *got)
{
struct elf_resolve *tpnt = (struct elf_resolve *)got[1];
Elf32_Sym *sym;
unsigned long local_gotno;
unsigned long gotsym;
unsigned long new_addr;
char *strtab, *symname;
unsigned long *entry;
unsigned long sym_index = got_offset / 4;
#if 0
local_gotno = tpnt->dynamic_info[DT_AVR32_LOCAL_GOTNO];
gotsym = tpnt->dynamic_info[DT_AVR32_GOTSYM];
sym = ((Elf32_Sym *)(tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr))
+ sym_index;
strtab = (char *)(tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
symname = strtab + sym->st_name;
#if 0
new_addr = (unsigned long) _dl_find_hash(strtab + sym->st_name,
tpnt->symbol_scope, tpnt,
resolver);
#endif
entry = (unsigned long *)(got + local_gotno + sym_index - gotsym);
*entry = new_addr;
#endif
return new_addr;
}
unsigned long
_dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
{
int reloc_type;
int symtab_index;
char *strtab;
char *symname;
char *new_addr;
char *rel_addr;
char **got_addr;
Elf32_Sym *symtab;
ELF_RELOC *this_reloc;
unsigned long instr_addr;
rel_addr = (char *)tpnt->dynamic_info[DT_JMPREL];
this_reloc = (ELF_RELOC *)(intptr_t)(rel_addr + reloc_entry);
reloc_type = ELF32_R_TYPE(this_reloc->r_info);
symtab_index = ELF32_R_SYM(this_reloc->r_info);
symtab = (Elf32_Sym *)(intptr_t)tpnt->dynamic_info[DT_SYMTAB];
strtab = (char *)tpnt->dynamic_info[DT_STRTAB];
symname = strtab + symtab[symtab_index].st_name;
if (unlikely(reloc_type != R_CRIS_JUMP_SLOT)) {
_dl_dprintf(2, "%s: Incorrect relocation type in jump relocations\n",
_dl_progname);
_dl_exit(1);
}
/* Address of the jump instruction to fix up. */
instr_addr = ((unsigned long)this_reloc->r_offset +
(unsigned long)tpnt->loadaddr);
got_addr = (char **)instr_addr;
/* Get the address of the GOT entry. */
new_addr = _dl_find_hash(symname, tpnt->symbol_scope, tpnt, ELF_RTYPE_CLASS_PLT);
if (unlikely(!new_addr)) {
_dl_dprintf(2, "%s: Can't resolve symbol '%s'\n", _dl_progname, symname);
_dl_exit(1);
}
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_bindings) {
_dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
if (_dl_debug_detail)
_dl_dprintf(_dl_debug_file,
"\n\tpatched: %x ==> %x @ %x",
*got_addr, new_addr, got_addr);
}
if (!_dl_debug_nofixups) {
*got_addr = new_addr;
}
#else
*got_addr = new_addr;
#endif
return (unsigned long)new_addr;
}
static int _dl_do_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope,
Elf32_Rela *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
char *symname;
unsigned long *reloc_addr;
unsigned long symbol_addr;
#if defined(__SUPPORT_LD_DEBUG__)
unsigned long old_val;
#endif
reloc_addr = (unsigned long *)(tpnt->loadaddr + rpnt->r_offset);
reloc_type = ELF32_R_TYPE(rpnt->r_info);
symtab_index = ELF32_R_SYM(rpnt->r_info);
symbol_addr = 0;
symname = strtab + symtab[symtab_index].st_name;
if (symtab_index) {
symbol_addr = (unsigned long)
_dl_find_hash(strtab + symtab[symtab_index].st_name,
tpnt->symbol_scope, tpnt,
elf_machine_type_class(reloc_type));
/* Allow undefined references to weak symbols */
if (!symbol_addr &&
ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK) {
_dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
_dl_progname, symname);
return 0;
}
}
#if defined(__SUPPORT_LD_DEBUG__)
old_val = *reloc_addr;
#endif
switch (reloc_type) {
case R_AVR32_NONE:
break;
case R_AVR32_GLOB_DAT:
case R_AVR32_JMP_SLOT:
*reloc_addr = symbol_addr + rpnt->r_addend;
break;
case R_AVR32_RELATIVE:
*reloc_addr = (unsigned long)tpnt->loadaddr
+ rpnt->r_addend;
break;
default:
return -1;
}
#if defined(__SUPPORT_LD_DEBUG__)
if (_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x\n",
old_val, *reloc_addr);
#endif
return 0;
}
unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
{
ELF_RELOC *this_reloc;
char *strtab;
char *symname;
Elf32_Sym *symtab;
ELF_RELOC *rel_addr;
int symtab_index;
unsigned long new_addr;
char **got_addr;
unsigned long instr_addr;
rel_addr = (ELF_RELOC *) tpnt->dynamic_info[DT_JMPREL];
this_reloc = rel_addr + reloc_entry;
symtab_index = ELF32_R_SYM(this_reloc->r_info);
symtab = (Elf32_Sym *) tpnt->dynamic_info[DT_SYMTAB];
strtab = (char *) tpnt->dynamic_info[DT_STRTAB];
symname = strtab + symtab[symtab_index].st_name;
/* Address of jump instruction to fix up */
instr_addr = ((unsigned long) this_reloc->r_offset +
(unsigned long) tpnt->loadaddr);
got_addr = (char **) instr_addr;
/* Get the address of the GOT entry */
new_addr = _dl_find_hash(symname, &_dl_loaded_modules->symbol_scope,
tpnt, ELF_RTYPE_CLASS_PLT, NULL);
if (unlikely(!new_addr)) {
_dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
_dl_progname, symname);
_dl_exit(1);
}
#if defined (__SUPPORT_LD_DEBUG__)
#if !defined __SUPPORT_LD_DEBUG_EARLY__
if ((unsigned long) got_addr < 0x40000000)
#endif
{
if (_dl_debug_bindings)
{
_dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
if (_dl_debug_detail) _dl_dprintf(_dl_debug_file,
"\tpatch %x ==> %x @ %x", *got_addr, new_addr, got_addr);
}
}
if (!_dl_debug_nofixups) {
*got_addr = (char *)new_addr;
}
#else
*got_addr = (char *)new_addr;
#endif
return new_addr;
}
void *_dlsym(void *vhandle, const char *name)
{
struct elf_resolve *tpnt, *tfrom;
struct dyn_elf *handle;
char *from;
struct dyn_elf *rpnt;
void *ret;
handle = (struct dyn_elf *) vhandle;
/* First of all verify that we have a real handle
of some kind. Return NULL if not a valid handle. */
if (handle == NULL)
handle = _dl_symbol_tables;
else if (handle != RTLD_NEXT && handle != _dl_symbol_tables) {
for (rpnt = _dl_handles; rpnt; rpnt = rpnt->next_handle)
if (rpnt == handle)
break;
if (!rpnt) {
_dl_error_number = LD_BAD_HANDLE;
return NULL;
}
} else if (handle == RTLD_NEXT) {
/*
* Try and locate the module we were called from - we
* need this so that we know where to start searching
* from. We never pass RTLD_NEXT down into the actual
* dynamic loader itself, as it doesn't know
* how to properly treat it.
*/
from = __builtin_return_address(0);
tfrom = NULL;
for (rpnt = _dl_symbol_tables; rpnt; rpnt = rpnt->next) {
tpnt = rpnt->dyn;
if (tpnt->loadaddr < from
&& (tfrom == NULL || tfrom->loadaddr < tpnt->loadaddr)) {
tfrom = tpnt;
handle = rpnt->next;
}
}
}
ret = _dl_find_hash((char*)name, handle, NULL, copyrel);
/*
* Nothing found.
*/
if (!ret)
_dl_error_number = LD_NO_SYMBOL;
return ret;
}
/* No, there are cases where the SVr4 linker fails to emit COPY relocs
at all */
static int
_dl_do_copy (struct elf_resolve *tpnt, struct dyn_elf *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
unsigned long *reloc_addr;
unsigned long symbol_addr;
int goof = 0;
reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
reloc_type = ELF32_R_TYPE(rpnt->r_info);
if (reloc_type != R_SH_COPY)
return 0;
symtab_index = ELF32_R_SYM(rpnt->r_info);
symbol_addr = 0;
if (symtab_index) {
symbol_addr = (unsigned long) _dl_find_hash(strtab +
symtab[symtab_index].st_name, scope,
NULL, copyrel);
if (!symbol_addr) goof++;
}
if (!goof) {
#if defined (__SUPPORT_LD_DEBUG__)
if(_dl_debug_move)
_dl_dprintf(_dl_debug_file,"\n%s move %x bytes from %x to %x",
strtab + symtab[symtab_index].st_name,
symtab[symtab_index].st_size,
symbol_addr, symtab[symtab_index].st_value);
#endif
_dl_memcpy((char *) symtab[symtab_index].st_value,
(char *) symbol_addr, symtab[symtab_index].st_size);
}
return goof;
}
struct funcdesc_value volatile *
_dl_linux_resolver (struct elf_resolve *tpnt, int reloc_entry)
{
ELF_RELOC *this_reloc;
char *strtab;
ElfW(Sym) *symtab;
int symtab_index;
char *rel_addr;
char *new_addr;
struct funcdesc_value funcval;
struct funcdesc_value volatile *got_entry;
char *symname;
struct symbol_ref sym_ref;
rel_addr = (char *)tpnt->dynamic_info[DT_JMPREL];
this_reloc = (ELF_RELOC *)(intptr_t)(rel_addr + reloc_entry);
symtab_index = ELF_R_SYM(this_reloc->r_info);
symtab = (Elf32_Sym *) tpnt->dynamic_info[DT_SYMTAB];
strtab = (char *) tpnt->dynamic_info[DT_STRTAB];
sym_ref.sym = &symtab[symtab_index];
sym_ref.tpnt = NULL;
symname= strtab + symtab[symtab_index].st_name;
/* Address of GOT entry fix up */
got_entry = (struct funcdesc_value *) DL_RELOC_ADDR(tpnt->loadaddr, this_reloc->r_offset);
/* Get the address to be used to fill in the GOT entry. */
new_addr = _dl_find_hash(symname, tpnt->symbol_scope, NULL, 0, &sym_ref);
if (!new_addr) {
new_addr = _dl_find_hash(symname, NULL, NULL, 0, &sym_ref);
if (!new_addr) {
_dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
_dl_progname, symname);
_dl_exit(1);
}
}
funcval.entry_point = new_addr;
funcval.got_value = sym_ref.tpnt->loadaddr.got_value;
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_bindings) {
_dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
if (_dl_debug_detail)
_dl_dprintf(_dl_debug_file,
"\n\tpatched (%x,%x) ==> (%x,%x) @ %x\n",
got_entry->entry_point, got_entry->got_value,
funcval.entry_point, funcval.got_value,
got_entry);
}
if (1 || !_dl_debug_nofixups) {
*got_entry = funcval;
}
#else
*got_entry = funcval;
#endif
return got_entry;
}
static int
_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
unsigned long *reloc_addr;
unsigned long symbol_addr;
int goof = 0;
reloc_addr = (unsigned long *)(intptr_t) (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) {
symbol_addr = (unsigned long) _dl_find_hash(strtab + symtab[symtab_index].st_name,
scope,
(reloc_type == R_SH_JMP_SLOT ? tpnt : NULL), symbolrel);
/*
* 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) {
goof++;
}
}
#if defined (__SUPPORT_LD_DEBUG__)
{
unsigned long old_val = *reloc_addr;
#endif
switch (reloc_type) {
case R_SH_NONE:
break;
case R_SH_COPY:
/* handled later on */
break;
case R_SH_DIR32:
case R_SH_GLOB_DAT:
case R_SH_JMP_SLOT:
*reloc_addr = symbol_addr + rpnt->r_addend;
break;
case R_SH_REL32:
*reloc_addr = symbol_addr + rpnt->r_addend -
(unsigned long) reloc_addr;
break;
case R_SH_RELATIVE:
*reloc_addr = (unsigned long) tpnt->loadaddr + rpnt->r_addend;
break;
default:
return -1; /*call _dl_exit(1) */
}
#if defined (__SUPPORT_LD_DEBUG__)
if(_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\tpatch: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
}
#endif
return goof;
}
static int
_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
char *symname;
unsigned long *reloc_addr;
unsigned long symbol_addr;
#if defined (__SUPPORT_LD_DEBUG__)
unsigned long old_val;
#endif
struct elf_resolve *tls_tpnt = NULL;
struct symbol_ref sym_ref;
reloc_addr = (unsigned long *)(intptr_t) (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;
sym_ref.sym = &symtab[symtab_index];
sym_ref.tpnt = NULL;
if (symtab_index) {
symname = strtab + symtab[symtab_index].st_name;
symbol_addr = (unsigned long) _dl_find_hash(symname, scope, tpnt,
elf_machine_type_class(reloc_type), &sym_ref);
/*
* 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
&& (ELF_ST_TYPE(symtab[symtab_index].st_info) != STT_TLS)
&& (ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK)) {
_dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
_dl_progname, symname);
/* Let the caller to handle the error: it may be non fatal if called from dlopen */
return 1;
}
tls_tpnt = sym_ref.tpnt;
}
#if defined (__SUPPORT_LD_DEBUG__)
old_val = *reloc_addr;
#endif
#if defined USE_TLS && USE_TLS
/* In case of a TLS reloc, tls_tpnt NULL means we have an 'anonymous'
symbol. This is the case for a static tls variable, so the lookup
module is just that one is referencing the tls variable. */
if (!tls_tpnt)
tls_tpnt = tpnt;
#endif
switch (reloc_type) {
case R_SH_NONE:
break;
case R_SH_COPY:
if (symbol_addr) {
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_move)
_dl_dprintf(_dl_debug_file,"\n%s move %x bytes from %x to %x",
symname, symtab[symtab_index].st_size,
symbol_addr, reloc_addr);
#endif
_dl_memcpy((char *) reloc_addr, (char *) symbol_addr, symtab[symtab_index].st_size);
}
return 0; /* no further LD_DEBUG messages for copy relocs */
case R_SH_DIR32:
case R_SH_GLOB_DAT:
case R_SH_JMP_SLOT:
*reloc_addr = symbol_addr + rpnt->r_addend;
break;
case R_SH_REL32:
*reloc_addr = symbol_addr + rpnt->r_addend -
(unsigned long) reloc_addr;
break;
case R_SH_RELATIVE:
*reloc_addr = (unsigned long) tpnt->loadaddr + rpnt->r_addend;
break;
#if defined USE_TLS && USE_TLS
case R_SH_TLS_DTPMOD32:
*reloc_addr = tls_tpnt->l_tls_modid;
break;
case R_SH_TLS_DTPOFF32:
*reloc_addr = symbol_addr;
break;
case R_SH_TLS_TPOFF32:
CHECK_STATIC_TLS ((struct link_map *) tls_tpnt);
*reloc_addr = tls_tpnt->l_tls_offset + symbol_addr + rpnt->r_addend;
break;
#endif
default:
return -1;
}
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x\n", old_val, *reloc_addr, reloc_addr);
#endif
return 0;
}
static int
_dl_do_reloc (struct elf_resolve *tpnt,struct r_scope_elem *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
char *symname;
unsigned long *reloc_addr;
unsigned long symbol_addr;
struct symbol_ref sym_ref;
struct elf_resolve *def_mod = 0;
int goof = 0;
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;
sym_ref.sym = &symtab[symtab_index];
sym_ref.tpnt = NULL;
symname = strtab + symtab[symtab_index].st_name;
if (symtab_index) {
symbol_addr = _dl_find_hash(symname, scope, tpnt,
elf_machine_type_class(reloc_type), &sym_ref);
/*
* 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 && (ELF_ST_TYPE(symtab[symtab_index].st_info) != STT_TLS)
&& (ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK)) {
/* This may be non-fatal if called from dlopen. */
return 1;
}
if (_dl_trace_prelink) {
_dl_debug_lookup (symname, tpnt, &symtab[symtab_index],
&sym_ref, elf_machine_type_class(reloc_type));
}
def_mod = sym_ref.tpnt;
} else {
/*
* Relocs against STN_UNDEF are usually treated as using a
* symbol value of zero, and using the module containing the
* reloc itself.
*/
symbol_addr = symtab[symtab_index].st_value;
def_mod = tpnt;
}
#if defined (__SUPPORT_LD_DEBUG__)
{
unsigned long old_val = *reloc_addr;
#endif
switch (reloc_type) {
case R_ARM_NONE:
break;
case R_ARM_ABS32:
*reloc_addr += symbol_addr;
break;
case R_ARM_PC24:
#if 0
{
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 (unlikely(topbits != 0xfe000000 && topbits != 0x00000000))
{
_dl_dprintf(2,"symbol '%s': R_ARM_PC24 relocation out of range.",
symtab[symtab_index].st_name);
_dl_exit(1);
}
}
newvalue >>= 2;
symbol_addr = (*reloc_addr & 0xff000000) | (newvalue & 0x00ffffff);
*reloc_addr = symbol_addr;
break;
}
#else
_dl_dprintf(2,"R_ARM_PC24: Compile shared libraries with -fPIC!\n");
_dl_exit(1);
#endif
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:
_dl_memcpy((void *) reloc_addr,
(void *) symbol_addr, symtab[symtab_index].st_size);
break;
#if defined USE_TLS && USE_TLS
case R_ARM_TLS_DTPMOD32:
*reloc_addr = def_mod->l_tls_modid;
break;
case R_ARM_TLS_DTPOFF32:
*reloc_addr += symbol_addr;
break;
case R_ARM_TLS_TPOFF32:
CHECK_STATIC_TLS ((struct link_map *) def_mod);
*reloc_addr += (symbol_addr + def_mod->l_tls_offset);
break;
#endif
default:
return -1; /*call _dl_exit(1) */
}
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\tpatch: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
}
#endif
return goof;
}
static int
_dl_do_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
char *symname;
unsigned long *reloc_addr;
unsigned long symbol_addr;
#if defined (__SUPPORT_LD_DEBUG__)
unsigned long old_val;
#endif
reloc_addr = (unsigned long *)(intptr_t)(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;
symname = strtab + symtab[symtab_index].st_name;
if (symtab_index) {
if (symtab[symtab_index].st_shndx != SHN_UNDEF &&
ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_LOCAL) {
symbol_addr = (unsigned long)tpnt->loadaddr;
} else {
symbol_addr = (unsigned long)_dl_find_hash(symname, scope, tpnt,
elf_machine_type_class(reloc_type));
}
if (unlikely(!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK)) {
_dl_dprintf(2, "%s: can't resolve symbol '%s'\n", _dl_progname, symname);
_dl_exit(1);
};
symbol_addr += rpnt->r_addend;
}
#if defined (__SUPPORT_LD_DEBUG__)
old_val = *reloc_addr;
#endif
switch (reloc_type) {
case R_CRIS_NONE:
break;
case R_CRIS_GLOB_DAT:
case R_CRIS_JUMP_SLOT:
case R_CRIS_32:
*reloc_addr = symbol_addr;
break;
case R_CRIS_COPY:
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_move)
_dl_dprintf(_dl_debug_file,
"\n%s move %d bytes from %x to %x",
symname, symtab[symtab_index].st_size,
symbol_addr, reloc_addr);
#endif
_dl_memcpy((char *)reloc_addr,
(char *)symbol_addr,
symtab[symtab_index].st_size);
break;
case R_CRIS_RELATIVE:
*reloc_addr = (unsigned long)tpnt->loadaddr + rpnt->r_addend;
break;
default:
return -1; /* Calls _dl_exit(1). */
}
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\n\tpatched: %x ==> %x @ %x",
old_val, *reloc_addr, reloc_addr);
#endif
return 0;
}
static int
_dl_do_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
char *symname;
unsigned long *reloc_addr;
unsigned long symbol_addr;
#if defined (__SUPPORT_LD_DEBUG__)
unsigned long old_val;
#endif
reloc_addr = (unsigned long *)(intptr_t)(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;
symname = strtab + symtab[symtab_index].st_name;
if (symtab_index) {
symbol_addr = (unsigned long)_dl_find_hash(symname, scope, tpnt,
elf_machine_type_class(reloc_type));
/*
* 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 (unlikely(!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK))
return 1;
}
#if defined (__SUPPORT_LD_DEBUG__)
old_val = *reloc_addr;
#endif
switch (reloc_type) {
case R_386_NONE:
break;
case R_386_32:
*reloc_addr += symbol_addr;
break;
case R_386_PC32:
*reloc_addr += symbol_addr - (unsigned long)reloc_addr;
break;
case R_386_GLOB_DAT:
case R_386_JMP_SLOT:
*reloc_addr = symbol_addr;
break;
case R_386_RELATIVE:
*reloc_addr += (unsigned long)tpnt->loadaddr;
break;
case R_386_COPY:
if (symbol_addr) {
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_move)
_dl_dprintf(_dl_debug_file,
"\n%s move %d bytes from %x to %x",
symname, symtab[symtab_index].st_size,
symbol_addr, reloc_addr);
#endif
_dl_memcpy((char *)reloc_addr,
(char *)symbol_addr,
symtab[symtab_index].st_size);
}
break;
default:
return -1;
}
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\n\tpatched: %x ==> %x @ %x",
old_val, *reloc_addr, reloc_addr);
#endif
return 0;
}
static int
_dl_do_reloc(struct elf_resolve *tpnt, struct r_scope_elem *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
char *symname;
struct elf_resolve *tls_tpnt = NULL;
unsigned long *reloc_addr;
unsigned long symbol_addr;
#if defined (__SUPPORT_LD_DEBUG__)
unsigned long old_val;
#endif
struct symbol_ref sym_ref;
reloc_addr = (unsigned long *)(intptr_t)(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;
sym_ref.sym = &symtab[symtab_index];
sym_ref.tpnt = NULL;
symname = strtab + symtab[symtab_index].st_name;
if (symtab_index) {
symbol_addr = (unsigned long)_dl_find_hash(symname, scope, tpnt,
elf_machine_type_class(reloc_type), &sym_ref);
/*
* 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 (unlikely(!symbol_addr && (ELF_ST_TYPE(symtab[symtab_index].st_info) != STT_TLS)
&& ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK))
return 1;
if (_dl_trace_prelink)
_dl_debug_lookup (symname, tpnt, &symtab[symtab_index],
&sym_ref, elf_machine_type_class(reloc_type));
tls_tpnt = sym_ref.tpnt;
} else {
symbol_addr = symtab[symtab_index].st_value;
tls_tpnt = tpnt;
}
#if defined (__SUPPORT_LD_DEBUG__)
old_val = *reloc_addr;
#endif
switch (reloc_type) {
case R_386_NONE:
break;
case R_386_32:
*reloc_addr += symbol_addr;
break;
case R_386_PC32:
*reloc_addr += symbol_addr - (unsigned long)reloc_addr;
break;
case R_386_GLOB_DAT:
case R_386_JMP_SLOT:
*reloc_addr = symbol_addr;
break;
case R_386_RELATIVE:
*reloc_addr += (unsigned long)tpnt->loadaddr;
break;
case R_386_COPY:
if (symbol_addr) {
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_move)
_dl_dprintf(_dl_debug_file,
"\n%s move %d bytes from %x to %x",
symname, symtab[symtab_index].st_size,
symbol_addr, reloc_addr);
#endif
_dl_memcpy((char *)reloc_addr,
(char *)symbol_addr,
symtab[symtab_index].st_size);
}
break;
#if defined USE_TLS && USE_TLS
case R_386_TLS_DTPMOD32:
*reloc_addr = tls_tpnt->l_tls_modid;
break;
case R_386_TLS_DTPOFF32:
/* During relocation all TLS symbols are defined and used.
* Therefore the offset is already correct. */
*reloc_addr = symbol_addr;
break;
case R_386_TLS_TPOFF32:
/* The offset is positive, backward from the thread pointer. */
CHECK_STATIC_TLS((struct link_map*) tls_tpnt);
*reloc_addr += tls_tpnt->l_tls_offset - symbol_addr;
break;
case R_386_TLS_TPOFF:
/* The offset is negative, forward from the thread pointer. */
CHECK_STATIC_TLS((struct link_map*) tls_tpnt);
*reloc_addr += symbol_addr - tls_tpnt->l_tls_offset;
break;
#endif
default:
return -1;
}
#if defined (__SUPPORT_LD_DEBUG__)
if (_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\n\tpatched: %x ==> %x @ %x\n",
old_val, *reloc_addr, reloc_addr);
#endif
return 0;
}
static int
_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
int reloc_type;
int symtab_index;
char *symname;
unsigned long *reloc_addr;
unsigned long symbol_addr;
#if defined (__SUPPORT_LD_DEBUG__)
unsigned long old_val;
#endif
reloc_addr = (unsigned long *)(intptr_t) (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;
symname = strtab + symtab[symtab_index].st_name;
if (symtab_index) {
symbol_addr = (unsigned long) _dl_find_hash(symname, scope, tpnt,
elf_machine_type_class(reloc_type));
/*
* 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_WEAK) {
_dl_dprintf (2, "%s: can't resolve symbol '%s'\n",
_dl_progname, strtab + symtab[symtab_index].st_name);
_dl_exit (1);
}
}
#if defined (__SUPPORT_LD_DEBUG__)
old_val = *reloc_addr;
#endif
switch (reloc_type) {
case R_SH_NONE:
break;
case R_SH_COPY:
if (symbol_addr) {
#if defined (__SUPPORT_LD_DEBUG__)
if(_dl_debug_move)
_dl_dprintf(_dl_debug_file,"\n%s move %x bytes from %x to %x",
symname, symtab[symtab_index].st_size,
symbol_addr, reloc_addr);
#endif
_dl_memcpy((char *) reloc_addr, (char *) symbol_addr, symtab[symtab_index].st_size);
}
return 0; /* no further LD_DEBUG messages for copy relocs */
case R_SH_DIR32:
case R_SH_GLOB_DAT:
case R_SH_JMP_SLOT:
*reloc_addr = symbol_addr + rpnt->r_addend;
break;
case R_SH_REL32:
*reloc_addr = symbol_addr + rpnt->r_addend -
(unsigned long) reloc_addr;
break;
case R_SH_RELATIVE:
*reloc_addr = (unsigned long) tpnt->loadaddr + rpnt->r_addend;
break;
default:
return -1; /*call _dl_exit(1) */
}
#if defined (__SUPPORT_LD_DEBUG__)
if(_dl_debug_reloc && _dl_debug_detail)
_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
#endif
return 0;
}
