+ case EM_386: return elf_doRelocate_386;
+ case EM_ARM: return elf_doRelocate_arm;
+ default: return NULL;
+ }
+}
+
+
+// --------------------------------------------------------------------
+// Elf64 support
+// --------------------------------------------------------------------
+#ifdef SUPPORT_ELF64
+
+#define ELFTYPE Elf64
+#include "elf_impl.c"
+#undef ELFTYPE
+
+Elf64_RelocFcn elf_doRelocate_x86_64;
+
+int elf_doRelocate_x86_64(const Elf64_RelocInfo *Info, Elf64_Xword r_info, Elf64_Xword* ptr, Elf64_Addr addend, bool bRela)
+{
+ const Elf64_Sym *sym = &Info->symtab[ ELF64_R_SYM(r_info) ];
+ void *symval = (void*)(intptr_t)sym->st_value;
+ size_t size = sym->st_size;
+ TRACE("%i '%s'", ELF64_R_TYPE(r_info), Info->strtab + sym->st_name);
+ switch( ELF64_R_TYPE(r_info) )
+ {
+ case R_X86_64_NONE:
+ break;
+ case R_X86_64_64:
+ TRACE("R_X86_64_64 *0x%x = %p + 0x%x", ptr, symval, addend);
+ *ptr = (intptr_t)symval + addend;
+ break;
+ // Absolute Value of a symbol (S)
+ case R_X86_64_GLOB_DAT:
+ TRACE("R_X86_64_GLOB_DAT *0x%x = %p", ptr, symval); if(0)
+ case R_X86_64_JUMP_SLOT:
+ TRACE("R_X86_64_JUMP_SLOT *0x%x = %p", ptr, symval);
+ *ptr = (intptr_t)symval;
+ break;
+
+ // Base Address (B+A)
+ case R_X86_64_RELATIVE:
+ TRACE("R_X86_64_RELATIVE *0x%x = 0x%x + 0x%x", ptr, Info->iBaseDiff, addend);
+ *ptr = Info->iBaseDiff + addend;
+ break;
+
+ case R_X86_64_COPY: {
+ void *old_symval = symval;
+ GetSymbol(Info->strtab + sym->st_name, &symval, &size, Info->Base);
+ if( symval == old_symval )
+ {
+ if( ELF64_ST_BIND(sym->st_info) != STB_WEAK )
+ {
+ WARNING("sym={val:%p,size:0x%x,info:0x%x,other:0x%x,shndx:%i}",
+ sym->st_value, sym->st_size, sym->st_info, sym->st_other, sym->st_shndx);
+ WARNING("Can't find required external symbol '%s' for R_X86_64_COPY", Info->strtab + sym->st_name);
+ return 1;
+ }
+ // Don't bother doing the memcpy
+ TRACE("R_X86_64_COPY (%p, %p, %i)", ptr, symval, size);
+ }
+ else
+ {
+ TRACE("R_X86_64_COPY (%p, %p, %i)", ptr, symval, size);
+ memcpy(ptr, symval, size);
+ }
+ break; }
+ default:
+ WARNING("Unknown Relocation, %i", ELF64_R_TYPE(r_info));
+ return 2;
+ }
+ return 0;
+}
+
+Elf64_RelocFcn* Elf64_GetRelocFcn(unsigned Machine)
+{
+ switch(Machine)
+ {
+ case EM_X86_64: return elf_doRelocate_x86_64;
+ default: return NULL;
+ }
+}
+
+#endif // SUPPORT_ELF64
+
+
+#ifdef SUPPORT_ELF64
+#if 0
+typedef int (*t_elf64_doreloc)(void *Base, const char *strtab, Elf64_Sym *symtab, Elf64_Xword r_info, void *ptr, Elf64_Sxword addend);
+
+int _Elf64DoReloc_X86_64(void *Base, const char *strtab, Elf64_Sym *symtab, Elf64_Xword r_info, void *ptr, Elf64_Sxword addend)
+{
+ int sym = ELF64_R_SYM(r_info);
+ int type = ELF64_R_TYPE(r_info);
+ const char *symname = strtab + symtab[sym].st_name;
+ void *symval;
+ //DEBUGS("_Elf64DoReloc: %s", symname);
+ switch( type )
+ {
+ case R_X86_64_NONE:
+ break;
+ case R_X86_64_64:
+ if( !GetSymbol(symname, &symval, NULL, NULL) ) return 1;
+ *(uint64_t*)ptr = (uintptr_t)symval + addend;
+ break;
+ case R_X86_64_COPY: {
+ size_t size;
+ if( !GetSymbol(symname, &symval, &size, NULL) ) return 1;
+ memcpy(ptr, symval, size);
+ } break;
+ case R_X86_64_GLOB_DAT:
+ if( !GetSymbol(symname, &symval, NULL, NULL) ) return 1;
+ *(uint64_t*)ptr = (uintptr_t)symval;
+ break;
+ case R_X86_64_JUMP_SLOT:
+ if( !GetSymbol(symname, &symval, NULL, NULL) ) return 1;
+ *(uint64_t*)ptr = (uintptr_t)symval;
+ break;
+ case R_X86_64_RELATIVE:
+ *(uint64_t*)ptr = (uintptr_t)Base + addend;
+ break;
+ default:
+ SysDebug("ld-acess - _Elf64DoReloc: Unknown relocation type %i", type);
+ return 2;
+ }
+ //DEBUGS("_Elf64DoReloc: - Good");
+ return 0;
+}
+
+void *Elf64Relocate(void *Base, char **envp, const char *Filename)
+{
+ int i;
+ Elf64_Ehdr *hdr = Base;
+ Elf64_Phdr *phtab;
+ Elf64_Dyn *dyntab = NULL;
+ Elf64_Addr compiledBase = -1, baseDiff;
+ Elf64_Sym *symtab = NULL;
+ char *strtab = NULL;
+ Elf64_Word *hashtab = NULL;
+ Elf64_Rel *rel = NULL;
+ int rel_count = 0;
+ Elf64_Rela *rela = NULL;
+ int rela_count = 0;
+ void *pltrel = NULL;
+ int plt_size = 0, plt_type = 0;
+
+ TRACE("hdr = {");
+ TRACE(" e_ident = '%.16s'", hdr->e_ident);
+ TRACE(" e_type = 0x%x", hdr->e_type);
+ TRACE(" e_machine = 0x%x", hdr->e_machine);
+ TRACE(" e_version = 0x%x", hdr->e_version);
+ TRACE(" e_entry = %p", hdr->e_entry);
+ TRACE(" e_phoff = 0x%llx", hdr->e_phoff);
+ TRACE(" e_shoff = 0x%llx", hdr->e_shoff);
+ TRACE(" e_flags = 0x%x", hdr->e_flags);
+ TRACE(" e_ehsize = 0x%x", hdr->e_ehsize);
+ TRACE(" e_phentsize = 0x%x", hdr->e_phentsize);
+ TRACE(" e_phnum = %i", hdr->e_phnum);
+
+ // Scan for the dynamic table (and find the compiled base)
+ phtab = (void*)((uintptr_t)Base + (uintptr_t)hdr->e_phoff);
+ for( i = 0; i < hdr->e_phnum; i ++ )
+ {
+ if(phtab[i].p_type == PT_DYNAMIC)
+ dyntab = (void *)(intptr_t)phtab[i].p_vaddr;
+ if(phtab[i].p_type == PT_LOAD && compiledBase > phtab[i].p_vaddr)
+ compiledBase = phtab[i].p_vaddr;
+ }
+
+ baseDiff = (uintptr_t)Base - compiledBase;
+
+ TRACE("baseDiff = %p", baseDiff);
+
+ if(dyntab == NULL) {
+ SysDebug(" Elf64Relocate: No PT_DYNAMIC segment in image %p, returning", Base);
+ return (void *)(uintptr_t)(hdr->e_entry + baseDiff);
+ }
+
+ dyntab = (void *)(uintptr_t)((uintptr_t)dyntab + baseDiff);
+
+ // Parse the dynamic table (first pass)
+ // - Search for String, Symbol and Hash tables
+ for(i = 0; dyntab[i].d_tag != DT_NULL; i ++)
+ {
+ switch(dyntab[i].d_tag)