/* vi: set sw=4 ts=4: */
-/* i386 ELF shared library loader suppport
+/* powerpc shared library loader suppport
*
* Copyright (C) 2001-2002, David A. Schleef
+ * Copyright (C) 2003, Erik Andersen
*
* All rights reserved.
*
* SUCH DAMAGE.
*/
-/* FIXME -- Disable this when __SUPPORT_LD_DEBUG__ is undefined */
#if defined (__SUPPORT_LD_DEBUG__)
static const char *_dl_reltypes[] =
{ "R_PPC_NONE", "R_PPC_ADDR32", "R_PPC_ADDR24", "R_PPC_ADDR16",
"R_PPC_PLT16_HA", "R_PPC_SDAREL16", "R_PPC_SECTOFF",
"R_PPC_SECTOFF_LO", "R_PPC_SECTOFF_HI", "R_PPC_SECTOFF_HA",
};
-#define N_RELTYPES (sizeof(_dl_reltypes)/sizeof(_dl_reltypes[0]))
-#endif
-
-/* Program to load an ELF binary on a linux system, and run it.
- References to symbols in sharable libraries can be resolved by either
- an ELF sharable library or a linux style of shared library. */
-/* Disclaimer: I have never seen any AT&T source code for SVr4, nor have
- I ever taken any courses on internals. This program was developed using
- information available through the book "UNIX SYSTEM V RELEASE 4,
- Programmers guide: Ansi C and Programming Support Tools", which did
- a more than adequate job of explaining everything required to get this
- working. */
+static const char *
+_dl_reltypes(int type)
+{
+ static char buf[22];
+ const char *str;
+
+ if (type >= (int)(sizeof (_dl_reltypes_tab)/sizeof(_dl_reltypes_tab[0])) ||
+ NULL == (str = _dl_reltypes_tab[type]))
+ {
+ str =_dl_simple_ltoa( buf, (unsigned long)(type));
+ }
+ return str;
+}
+static
+void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index)
+{
+ if(_dl_debug_symbols)
+ {
+ if(symtab_index){
+ _dl_dprintf(_dl_debug_file, "\n%s\n\tvalue=%x\tsize=%x\tinfo=%x\tother=%x\tshndx=%x",
+ strtab + symtab[symtab_index].st_name,
+ symtab[symtab_index].st_value,
+ symtab[symtab_index].st_size,
+ symtab[symtab_index].st_info,
+ symtab[symtab_index].st_other,
+ symtab[symtab_index].st_shndx);
+ }
+ }
+}
-#ifdef __SUPPORT_LD_DEBUG__
-static void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index);
-static void debug_reloc(ELF_RELOC *rpnt);
-#define DPRINTF(fmt,args...) if (_dl_debug) _dl_dprintf(2,fmt,args)
+static
+void debug_reloc(Elf32_Sym *symtab,char *strtab, ELF_RELOC *rpnt)
+{
+ if(_dl_debug_reloc)
+ {
+ int symtab_index;
+ const char *sym;
+ symtab_index = ELF32_R_SYM(rpnt->r_info);
+ sym = symtab_index ? strtab + symtab[symtab_index].st_name : "sym=0x0";
+
+ if(_dl_debug_symbols)
+ _dl_dprintf(_dl_debug_file, "\n\t");
+ else
+ _dl_dprintf(_dl_debug_file, "\n%s\n\t", sym);
+#ifdef ELF_USES_RELOCA
+ _dl_dprintf(_dl_debug_file, "%s\toffset=%x\taddend=%x",
+ _dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
+ rpnt->r_offset,
+ rpnt->r_addend);
#else
-#define debug_sym(a,b,c)
-#define debug_reloc(a)
-#define DPRINTF(fmt,args...)
+ _dl_dprintf(_dl_debug_file, "%s\toffset=%x\n",
+ _dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
+ rpnt->r_offset);
+#endif
+ }
+}
#endif
extern int _dl_linux_resolve(void);
unsigned long data_words;
unsigned int rel_offset_words;
- DPRINTF("init_got plt=%x, tpnt=%x\n",
- (unsigned long)plt,(unsigned long)tpnt);
+ //DPRINTF("init_got plt=%x, tpnt=%x\n", (unsigned long)plt,(unsigned long)tpnt);
n_plt_entries = tpnt->dynamic_info[DT_PLTRELSZ] / sizeof(ELF_RELOC);
- DPRINTF("n_plt_entries %d\n",n_plt_entries);
+ //DPRINTF("n_plt_entries %d\n",n_plt_entries);
rel_offset_words = PLT_DATA_START_WORDS(n_plt_entries);
- DPRINTF("rel_offset_words %x\n",rel_offset_words);
+ //DPRINTF("rel_offset_words %x\n",rel_offset_words);
data_words = (unsigned long)(plt + rel_offset_words);
- DPRINTF("data_words %x\n",data_words);
+ //DPRINTF("data_words %x\n",data_words);
tpnt->data_words = data_words;
int symtab_index;
unsigned long insn_addr;
unsigned long *insns;
- unsigned long targ_addr;
+ unsigned long new_addr;
int delta;
//DPRINTF("linux_resolver tpnt=%x reloc_entry=%x\n", tpnt, reloc_entry);
symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
- //debug_reloc(this_reloc);
+#if defined (__SUPPORT_LD_DEBUG__)
+ debug_reloc(symtab,strtab,this_reloc);
+#endif
if (reloc_type != R_PPC_JMP_SLOT) {
#if defined (__SUPPORT_LD_DEBUG__)
insn_addr = (unsigned long) tpnt->loadaddr +
(unsigned long) this_reloc->r_offset;
- DPRINTF("Resolving symbol %s %x --> ",
- strtab + symtab[symtab_index].st_name,
- insn_addr);
+ //DPRINTF("Resolving symbol %s %x --> ", strtab + symtab[symtab_index].st_name, insn_addr);
/* Get the address of the GOT entry */
- targ_addr = (unsigned long) _dl_find_hash(
+ new_addr = (unsigned long) _dl_find_hash(
strtab + symtab[symtab_index].st_name,
tpnt->symbol_scope, tpnt, resolver);
- if (!targ_addr) {
+ if (!new_addr) {
_dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
_dl_progname, strtab + symtab[symtab_index].st_name);
_dl_exit(1);
};
- DPRINTF("%x\n", targ_addr);
+ //DPRINTF("%x\n", new_addr);
insns = (unsigned long *)insn_addr;
- delta = targ_addr - insn_addr;
+ delta = new_addr - insn_addr;
if(delta<<6>>6 == delta){
insns[0] = OPCODE_B(delta);
- }else if (targ_addr <= 0x01fffffc || targ_addr >= 0xfe000000){
- insns[0] = OPCODE_BA (targ_addr);
+ }else if (new_addr <= 0x01fffffc || new_addr >= 0xfe000000){
+ insns[0] = OPCODE_BA (new_addr);
}else{
/* Warning: we don't handle double-sized PLT entries */
unsigned long plt_addr;
index = (insn_addr - plt_addr - PLT_INITIAL_ENTRY_WORDS*4)/8;
ptr = (unsigned long *)tpnt->data_words;
- DPRINTF("plt_addr=%x delta=%x index=%x ptr=%x\n",
- plt_addr, delta, index, ptr);
- ptr[index] = targ_addr;
+ //DPRINTF("plt_addr=%x delta=%x index=%x ptr=%x\n", plt_addr, delta, index, ptr);
+ ptr[index] = new_addr;
/* icache sync is not necessary, since this will be a data load */
//PPC_DCBST(ptr+index);
//PPC_SYNC;
PPC_ICBI(insn_addr);
PPC_ISYNC;
- return targ_addr;
+ return new_addr;
}
-void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt,
- unsigned long rel_addr, unsigned long rel_size, int type)
+static int
+_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
+ unsigned long rel_addr, unsigned long rel_size,
+ int (*reloc_fnc) (struct elf_resolve *tpnt, struct dyn_elf *scope,
+ ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab))
{
- int i;
+ unsigned int i;
char *strtab;
- int reloc_type;
- int symtab_index;
Elf32_Sym *symtab;
ELF_RELOC *rpnt;
- unsigned long reloc_addr;
- unsigned long *insns;
- unsigned long *plt;
- int index;
-
- DPRINTF("_dl_parse_lazy_relocation_information(tpnt=%x, rel_addr=%x, rel_size=%x, type=%d)\n",
- tpnt,rel_addr,rel_size,type);
+ int symtab_index;
/* Now parse the relocation information */
- rpnt = (ELF_RELOC *) (rel_addr + tpnt->loadaddr);
+ rpnt = (ELF_RELOC *)(intptr_t) (rel_addr + tpnt->loadaddr);
rel_size = rel_size / sizeof(ELF_RELOC);
- symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
+ symtab = (Elf32_Sym *)(intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
- plt = (unsigned long *)(tpnt->dynamic_info[DT_PLTGOT] + tpnt->loadaddr);
- for (i = 0; i < rel_size; i++, rpnt++) {
- reloc_addr = (unsigned long)tpnt->loadaddr +
- (unsigned long) rpnt->r_offset;
- reloc_type = ELF32_R_TYPE(rpnt->r_info);
+ for (i = 0; i < rel_size; i++, rpnt++) {
+ int res;
+
symtab_index = ELF32_R_SYM(rpnt->r_info);
-
+
/* When the dynamic linker bootstrapped itself, it resolved some symbols.
Make sure we do not do them again */
if (!symtab_index && tpnt->libtype == program_interpreter)
continue;
if (symtab_index && tpnt->libtype == program_interpreter &&
- _dl_symbol(strtab + symtab[symtab_index].st_name))
+ _dl_symbol(strtab + symtab[symtab_index].st_name))
continue;
- DPRINTF("L %x %s %s %x %x\n",
- reloc_addr, _dl_reltypes[reloc_type],
- symtab_index?strtab + symtab[symtab_index].st_name:"",0,0);
+#if defined (__SUPPORT_LD_DEBUG__)
+ debug_sym(symtab,strtab,symtab_index);
+ debug_reloc(symtab,strtab,rpnt);
+#endif
+
+ res = reloc_fnc (tpnt, scope, rpnt, symtab, strtab);
- switch (reloc_type) {
+ if (res==0) continue;
+
+ _dl_dprintf(2, "\n%s: ",_dl_progname);
+
+ if (symtab_index)
+ _dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
+
+ if (res <0)
+ {
+ int reloc_type = ELF32_R_TYPE(rpnt->r_info);
+#if defined (__SUPPORT_LD_DEBUG__)
+ _dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type));
+#else
+ _dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
+#endif
+ _dl_exit(-res);
+ }
+ else if (res >0)
+ {
+ _dl_dprintf(2, "can't resolve symbol\n");
+ return res;
+ }
+ }
+ return 0;
+}
+
+static int
+_dl_do_lazy_reloc (struct elf_resolve *tpnt, struct dyn_elf *scope,
+ ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
+{
+ int reloc_type;
+ unsigned long reloc_addr;
+#if defined (__SUPPORT_LD_DEBUG__)
+ unsigned long old_val;
+#endif
+ (void)scope;
+ (void)symtab;
+ (void)strtab;
+
+ reloc_addr = (unsigned long)tpnt->loadaddr + (unsigned long) rpnt->r_offset;
+ reloc_type = ELF32_R_TYPE(rpnt->r_info);
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ old_val = reloc_addr;
+#endif
+
+ switch (reloc_type) {
case R_PPC_NONE:
break;
case R_PPC_JMP_SLOT:
{
- int delta;
-
- delta = (unsigned long)(plt+PLT_TRAMPOLINE_ENTRY_WORDS+2)
- - (reloc_addr+4);
-
- index = (reloc_addr -
- (unsigned long)(plt+PLT_INITIAL_ENTRY_WORDS))
- /sizeof(unsigned long);
- index /= 2;
- DPRINTF(" index %x delta %x\n",index,delta);
- insns = (unsigned long *)reloc_addr;
- insns[0] = OPCODE_LI(11,index*4);
- insns[1] = OPCODE_B(delta);
- break;
+ int index, delta;
+ unsigned long *plt;
+ unsigned long *insns;
+
+ plt = (unsigned long *)(tpnt->dynamic_info[DT_PLTGOT] + tpnt->loadaddr);
+
+ delta = (unsigned long)(plt+PLT_TRAMPOLINE_ENTRY_WORDS+2) - (reloc_addr+4);
+
+ index = (reloc_addr - (unsigned long)(plt+PLT_INITIAL_ENTRY_WORDS))
+ /sizeof(unsigned long);
+ index /= 2;
+ //DPRINTF(" index %x delta %x\n",index,delta);
+ insns = (unsigned long *)reloc_addr;
+ insns[0] = OPCODE_LI(11,index*4);
+ insns[1] = OPCODE_B(delta);
+ break;
}
default:
+#if 0
_dl_dprintf(2, "%s: (LAZY) can't handle reloc type ",
- _dl_progname);
+ _dl_progname);
#if defined (__SUPPORT_LD_DEBUG__)
_dl_dprintf(2, "%s ", _dl_reltypes[reloc_type]);
#endif
if (symtab_index)
_dl_dprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
- _dl_exit(1);
- };
-
- /* instructions were modified */
- PPC_DCBST(reloc_addr);
- PPC_SYNC;
- PPC_ICBI(reloc_addr);
+#endif
+ //_dl_exit(1);
+ return -1;
};
+
+ /* instructions were modified */
+ PPC_DCBST(reloc_addr);
+ PPC_SYNC;
+ PPC_ICBI(reloc_addr);
+
+#if defined (__SUPPORT_LD_DEBUG__)
+ if(_dl_debug_reloc && _dl_debug_detail)
+ _dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x", old_val, reloc_addr);
+#endif
+ return 0;
+
}
-int _dl_parse_relocation_information(struct elf_resolve *tpnt,
- unsigned long rel_addr, unsigned long rel_size, int type)
+static int
+_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
+ ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
- int i;
- char *strtab;
int reloc_type;
- int goof = 0;
- Elf32_Sym *symtab;
- ELF_RELOC *rpnt;
+ int symtab_index;
+ char *symname;
unsigned long *reloc_addr;
unsigned long symbol_addr;
- int symtab_index;
- unsigned long addend;
- unsigned long *plt;
-
- DPRINTF("_dl_parse_relocation_information(tpnt=%x, rel_addr=%x, rel_size=%x, type=%d)\n",
- tpnt,rel_addr,rel_size,type);
-
- /* Now parse the relocation information */
-
- rpnt = (ELF_RELOC *) (rel_addr + tpnt->loadaddr);
- rel_size = rel_size / sizeof(ELF_RELOC);
+#if defined (__SUPPORT_LD_DEBUG__)
+ unsigned long old_val;
+#endif
- symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
- strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
- plt = (unsigned long *)(tpnt->dynamic_info[DT_PLTGOT] + tpnt->loadaddr);
+ 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;
- for (i = 0; i < rel_size; i++, rpnt++) {
- debug_reloc(rpnt);
+ if (symtab_index) {
- 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);
- addend = rpnt->r_addend;
- symbol_addr = 0;
+ symbol_addr = (unsigned long) _dl_find_hash(symname, scope,
+ (reloc_type == R_386_JMP_SLOT ? tpnt : NULL), symbolrel);
- if (!symtab_index && tpnt->libtype == program_interpreter)
- continue;
+ /*
+ * 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 (symtab_index) {
-
- if (tpnt->libtype == program_interpreter &&
- _dl_symbol(strtab + symtab[symtab_index].st_name))
- continue;
-
- symbol_addr = (unsigned long) _dl_find_hash(strtab + symtab[symtab_index].st_name,
- tpnt->symbol_scope,
- (reloc_type == R_PPC_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) {
- _dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
- _dl_progname, strtab + symtab[symtab_index].st_name);
- goof++;
- }
+ if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {
+#if defined (__SUPPORT_LD_DEBUG__)
+ _dl_dprintf(2, "\tglobal symbol '%s' already defined in '%s'\n",
+ symname, tpnt->libname);
+#endif
+ return 0;
}
- debug_sym(symtab,strtab,symtab_index);
+ }
+#if defined (__SUPPORT_LD_DEBUG__)
+ old_val = *reloc_addr;
+#endif
switch (reloc_type) {
- case R_PPC_NONE:
- break;
- case R_PPC_REL24:
+ case R_PPC_NONE:
+ break;
+ case R_PPC_REL24:
#if 0
- {
- int delta = symbol_addr - (unsigned long)reloc_addr;
- if(delta<<6>>6 != delta){
- _dl_dprintf(2,"R_PPC_REL24: Reloc out of range\n");
- _dl_exit(1);
- }
- *reloc_addr &= 0xfc000003;
- *reloc_addr |= delta&0x03fffffc;
- }
- break;
+ {
+ int delta = symbol_addr - (unsigned long)reloc_addr;
+ if(delta<<6>>6 != delta){
+ _dl_dprintf(2,"R_PPC_REL24: Reloc out of range\n");
+ _dl_exit(1);
+ }
+ *reloc_addr &= 0xfc000003;
+ *reloc_addr |= delta&0x03fffffc;
+ }
+ break;
#else
- _dl_dprintf(2, "%s: symbol '%s' is type R_PPC_REL24\n\tCompile shared libraries with -fPIC!\n",
- _dl_progname, strtab + symtab[symtab_index].st_name);
- _dl_exit(1);
+ _dl_dprintf(2, "%s: symbol '%s' is type R_PPC_REL24\n\tCompile shared libraries with -fPIC!\n",
+ _dl_progname, strtab + symtab[symtab_index].st_name);
+ _dl_exit(1);
#endif
- case R_PPC_RELATIVE:
- *reloc_addr = (unsigned long)tpnt->loadaddr + addend;
- break;
- case R_PPC_ADDR32:
- *reloc_addr += symbol_addr;
- break;
- case R_PPC_ADDR16_HA:
- /* XXX is this correct? */
- *(short *)reloc_addr += (symbol_addr+0x8000)>>16;
- break;
- case R_PPC_ADDR16_HI:
- *(short *)reloc_addr += symbol_addr>>16;
- break;
- case R_PPC_ADDR16_LO:
- *(short *)reloc_addr += symbol_addr;
- break;
- case R_PPC_JMP_SLOT:
- {
- unsigned long targ_addr = (unsigned long)*reloc_addr;
- int delta = targ_addr - (unsigned long)reloc_addr;
- if(delta<<6>>6 == delta){
- *reloc_addr = OPCODE_B(delta);
- }else if (targ_addr <= 0x01fffffc || targ_addr >= 0xfe000000){
- *reloc_addr = OPCODE_BA (targ_addr);
- }else{
- {
- int delta;
- int index;
-
- delta = (unsigned long)(plt+PLT_TRAMPOLINE_ENTRY_WORDS+2)
- - (unsigned long)(reloc_addr+1);
-
- index = ((unsigned long)reloc_addr -
- (unsigned long)(plt+PLT_INITIAL_ENTRY_WORDS))
- /sizeof(unsigned long);
- index /= 2;
- DPRINTF(" index %x delta %x\n",index,delta);
- reloc_addr[0] = OPCODE_LI(11,index*4);
- reloc_addr[1] = OPCODE_B(delta);
- }
- }
- break;
- }
- case R_PPC_GLOB_DAT:
- *reloc_addr += symbol_addr;
- break;
- case R_PPC_COPY:
- // handled later
- break;
- default:
- _dl_dprintf(2, "%s: can't handle reloc type ", _dl_progname);
+ case R_PPC_RELATIVE:
+ *reloc_addr = (unsigned long)tpnt->loadaddr + (unsigned long)rpnt->r_addend;
+ break;
+ case R_PPC_ADDR32:
+ *reloc_addr += symbol_addr;
+ break;
+ case R_PPC_ADDR16_HA:
+ /* XXX is this correct? */
+ *(short *)reloc_addr += (symbol_addr+0x8000)>>16;
+ break;
+ case R_PPC_ADDR16_HI:
+ *(short *)reloc_addr += symbol_addr>>16;
+ break;
+ case R_PPC_ADDR16_LO:
+ *(short *)reloc_addr += symbol_addr;
+ break;
+ case R_PPC_JMP_SLOT:
+ {
+ unsigned long targ_addr = (unsigned long)*reloc_addr;
+ int delta = targ_addr - (unsigned long)reloc_addr;
+ if(delta<<6>>6 == delta){
+ *reloc_addr = OPCODE_B(delta);
+ }else if (targ_addr <= 0x01fffffc || targ_addr >= 0xfe000000){
+ *reloc_addr = OPCODE_BA (targ_addr);
+ }else{
+ {
+ int delta;
+ int index;
+ unsigned long *plt;
+ plt = (unsigned long *)(tpnt->dynamic_info[DT_PLTGOT] + tpnt->loadaddr);
+
+ delta = (unsigned long)(plt+PLT_TRAMPOLINE_ENTRY_WORDS+2)
+ - (unsigned long)(reloc_addr+1);
+
+ index = ((unsigned long)reloc_addr -
+ (unsigned long)(plt+PLT_INITIAL_ENTRY_WORDS))
+ /sizeof(unsigned long);
+ index /= 2;
+ //DPRINTF(" index %x delta %x\n",index,delta);
+ reloc_addr[0] = OPCODE_LI(11,index*4);
+ reloc_addr[1] = OPCODE_B(delta);
+ }
+ }
+ break;
+ }
+ case R_PPC_GLOB_DAT:
+ *reloc_addr += symbol_addr;
+ break;
+ case R_PPC_COPY:
+ // handled later
+ break;
+ default:
+#if 0
+ _dl_dprintf(2, "%s: can't handle reloc type ", _dl_progname);
#if defined (__SUPPORT_LD_DEBUG__)
- _dl_dprintf(2, "%s ", _dl_reltypes[reloc_type]);
+ _dl_dprintf(2, "%s ", _dl_reltypes[reloc_type]);
#endif
- if (symtab_index)
- _dl_dprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
- _dl_exit(1);
+ if (symtab_index)
+ _dl_dprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
+#endif
+ //_dl_exit(1);
+ return -1;
};
/* instructions were modified */
PPC_SYNC;
PPC_ICBI(reloc_addr);
- DPRINTF("reloc_addr %x: %x\n",reloc_addr,*reloc_addr);
- };
- return goof;
+#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;
}
the wrong information being copied. Someone at Sun was complaining about
a bug in the handling of _COPY by SVr4, and this may in fact be what he
was talking about. Sigh. */
-
-/* No, there are cases where the SVr4 linker fails to emit COPY relocs
- at all */
-
-int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr,
- unsigned long rel_size, int type)
+static int
+_dl_do_copy (struct elf_resolve *tpnt, struct dyn_elf *scope,
+ ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
- int i;
- char *strtab;
int reloc_type;
- int goof = 0;
- Elf32_Sym *symtab;
- ELF_RELOC *rpnt;
+ int symtab_index;
unsigned long *reloc_addr;
unsigned long symbol_addr;
- struct elf_resolve *tpnt;
- int symtab_index;
-
- DPRINTF("parse_copy xpnt=%x rel_addr=%x rel_size=%x type=%d\n",
- (int)xpnt,rel_addr,rel_size,type);
-
- /* Now parse the relocation information */
-
- tpnt = xpnt->dyn;
-
- rpnt = (ELF_RELOC *) (rel_addr + tpnt->loadaddr);
- rel_size = rel_size / sizeof(ELF_RELOC);
-
- symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
- strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
-
- for (i = 0; i < rel_size; i++, rpnt++) {
- reloc_addr = (unsigned long *) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
- reloc_type = ELF32_R_TYPE(rpnt->r_info);
- if (reloc_type != R_PPC_COPY)
- continue;
-
- debug_reloc(rpnt);
-
- symtab_index = ELF32_R_SYM(rpnt->r_info);
- symbol_addr = 0;
- if (!symtab_index && tpnt->libtype == program_interpreter)
- continue;
- if (symtab_index) {
-
- if (tpnt->libtype == program_interpreter &&
- _dl_symbol(strtab + symtab[symtab_index].st_name))
- continue;
-
- symbol_addr = (unsigned long) _dl_find_hash(strtab +
- symtab[symtab_index].st_name, xpnt->next,
- NULL, copyrel);
- if (!symbol_addr) {
- _dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
- _dl_progname, strtab + symtab[symtab_index].st_name);
- goof++;
- };
- };
-
- debug_sym(symtab,strtab,symtab_index);
-
- DPRINTF("copy: to=%x from=%x size=%x\n",
- symtab[symtab_index].st_value,
- symbol_addr, symtab[symtab_index].st_size);
+ int goof = 0;
+ char *symname;
+
+ 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_386_COPY)
+ return 0;
+ 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, 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",
+ symname, 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);
+ }
- if (!goof) {
- _dl_memcpy((char *) symtab[symtab_index].st_value,
- (char *) symbol_addr,
- symtab[symtab_index].st_size);
- }
- };
return goof;
}
-
-#ifdef unused
-static void fixup_jmpslot(unsigned long reloc_addr, unsigned long targ_addr)
+void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt,
+ unsigned long rel_addr, unsigned long rel_size, int type)
{
- int delta = targ_addr - reloc_addr;
- int index;
-
- if(delta<<6>>6 == delta){
- *reloc_addr = OPCODE_B(delta);
- }else if (targ_addr <= 0x01fffffc || targ_addr >= 0xfe000000){
- *reloc_addr = OPCODE_BA (targ_addr);
- }else{
- delta = (unsigned long)(plt+PLT_TRAMPOLINE_ENTRY_WORDS+2)
- - (unsigned long)(reloc_addr+1);
-
- index = ((unsigned long)reloc_addr -
- (unsigned long)(plt+PLT_INITIAL_ENTRY_WORDS))
- /sizeof(unsigned long);
- index /= 2;
-
- DPRINTF(" index %x delta %x\n",index,delta);
-
- reloc_addr[0] = OPCODE_LI(11,index*4);
- reloc_addr[1] = OPCODE_B(delta);
- }
+ (void) type;
+ (void)_dl_parse(tpnt, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
}
-#endif
-
-#ifdef __SUPPORT_LD_DEBUG__
-static void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index)
+int _dl_parse_relocation_information(struct elf_resolve *tpnt,
+ unsigned long rel_addr, unsigned long rel_size, int type)
{
- if (_dl_debug_symbols) {
- if(symtab_index){
- _dl_dprintf(2, "sym: name=%s value=%x size=%x info=%x other=%x shndx=%x\n",
- strtab + symtab[symtab_index].st_name,
- symtab[symtab_index].st_value,
- symtab[symtab_index].st_size,
- symtab[symtab_index].st_info,
- symtab[symtab_index].st_other,
- symtab[symtab_index].st_shndx);
- }else{
- _dl_dprintf(2, "sym: null\n");
- }
- }
+ (void) type;
+ return _dl_parse(tpnt, tpnt->symbol_scope, rel_addr, rel_size, _dl_do_reloc);
}
-static void debug_reloc(ELF_RELOC *rpnt)
+int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr,
+ unsigned long rel_size, int type)
{
- if (_dl_debug_reloc) {
- _dl_dprintf(2, "reloc: offset=%x type=%x sym=%x addend=%x\n",
- rpnt->r_offset,
- ELF32_R_TYPE(rpnt->r_info),
- ELF32_R_SYM(rpnt->r_info),
- rpnt->r_addend);
- }
+ (void) type;
+ return _dl_parse(xpnt->dyn, xpnt->next, rel_addr, rel_size, _dl_do_copy);
}
-#endif
-
OSDN Git Service
