X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Usermode%2FLibraries%2Fld-acess.so_src%2Felf.c;h=3bc159ef88dfcfe5b4c30fa2b73727b90026fc65;hb=0542d0b19b79f6439ace9c0f9e35ec29a8af91f9;hp=1df3e8e91d6ab3ccb24698647d01f30331882d40;hpb=c1771fb9d6e85a8453a0f4553b3878959901b613;p=tpg%2Facess2.git

diff --git a/Usermode/Libraries/ld-acess.so_src/elf.c b/Usermode/Libraries/ld-acess.so_src/elf.c
index 1df3e8e9..3bc159ef 100644
--- a/Usermode/Libraries/ld-acess.so_src/elf.c
+++ b/Usermode/Libraries/ld-acess.so_src/elf.c
@@ -1,23 +1,26 @@
 /*
- * AcessOS 1 - Dynamic Loader
- * By thePowersGang
+ * Acess2 Dynamic Linker
+ * - By John Hodge (thePowersGang)
+ *
+ * elf.c
+ * - ELF32/ELF64 relocation
  */
+#define DEBUG	0
+
 #include "common.h"
 #include <stdint.h>
 #include "elf32.h"
 #include "elf64.h"
 
-#define DEBUG	1
-
 #if DEBUG
 # define	DEBUGS(v...)	SysDebug("ld-acess - " v)
 #else
 # define	DEBUGS(...)	
 #endif
 
-#if BITS > 32
+//#if BITS > 32
 # define SUPPORT_ELF64
-#endif
+//#endif
 
 // === CONSTANTS ===
 #if DEBUG
@@ -27,14 +30,14 @@ static const char	*csaR_NAMES[] = {"R_386_NONE", "R_386_32", "R_386_PC32", "R_38
 
 // === PROTOTYPES ===
 void	*ElfRelocate(void *Base, char **envp, const char *Filename);
- int	ElfGetSymbol(void *Base, const char *Name, void **Ret);
+ int	ElfGetSymbol(void *Base, const char *Name, void **Ret, size_t *Size);
 void	*Elf32Relocate(void *Base, char **envp, const char *Filename);
- int	Elf32GetSymbol(void *Base, const char *Name, void **Ret);
+ int	Elf32GetSymbol(void *Base, const char *Name, void **Ret, size_t *Size);
 #ifdef SUPPORT_ELF64
 void	*Elf64Relocate(void *Base, char **envp, const char *Filename);
- int	Elf64GetSymbol(void *Base, const char *Name, void **Ret);
+ int	Elf64GetSymbol(void *Base, const char *Name, void **Ret, size_t *Size);
 #endif
-Uint32	ElfHashString(const char *name);
+uint32_t	ElfHashString(const char *name);
 
 // === CODE ===
 /**
@@ -62,17 +65,17 @@ void *ElfRelocate(void *Base, char **envp, const char *Filename)
 /**
  * \fn int ElfGetSymbol(Uint Base, const char *name, void **ret)
  */
-int ElfGetSymbol(void *Base, const char *Name, void **ret)
+int ElfGetSymbol(void *Base, const char *Name, void **ret, size_t *Size)
 {
 	Elf32_Ehdr	*hdr = Base;
 
 	switch(hdr->e_ident[4])
 	{
 	case ELFCLASS32:
-		return Elf32GetSymbol(Base, Name, ret);
+		return Elf32GetSymbol(Base, Name, ret, Size);
 #ifdef SUPPORT_ELF64
 	case ELFCLASS64:
-		return Elf64GetSymbol(Base, Name, ret);
+		return Elf64GetSymbol(Base, Name, ret, Size);
 #endif
 	default:
 		SysDebug("ld-acess - ElfRelocate: Unknown file class %i", hdr->e_ident[4]);
@@ -89,10 +92,9 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 	intptr_t	iRealBase = -1;
 	intptr_t	iBaseDiff;
 	 int	iSegmentCount;
-	 int	iSymCount;
+//	 int	iSymCount;
 	Elf32_Rel	*rel = NULL;
 	Elf32_Rela	*rela = NULL;
-	Uint32	*pltgot = NULL;
 	void	*plt = NULL;
 	 int	relSz=0, relEntSz=8;
 	 int	relaSz=0, relaEntSz=8;
@@ -100,7 +102,7 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 	Elf32_Dyn	*dynamicTab = NULL;	// Dynamic Table Pointer
 	char	*dynstrtab = NULL;	// .dynamic String Table
 	Elf32_Sym	*dynsymtab;
-	void	(*do_relocate)(uint32_t t_info, uint32_t *ptr, Elf32_Addr addend, int Type, const char *Sym);
+	void	(*do_relocate)(uint32_t t_info, uint32_t *ptr, Elf32_Addr addend, int Type, int bRela, const char *Sym);
 	
 	DEBUGS("ElfRelocate: (Base=0x%x)", Base);
 	
@@ -155,40 +157,28 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 			DEBUGS(" elf_relocate: DYNAMIC Symbol Table 0x%x (0x%x)",
 				dynamicTab[j].d_val, dynamicTab[j].d_val + iBaseDiff);
 			if(iBaseDiff != 0)	dynamicTab[j].d_val += iBaseDiff;
-			dynsymtab = (void*)(dynamicTab[j].d_val);
-//			hdr->misc.SymTable = dynamicTab[j].d_val;	// Saved in unused bytes of ident
+			dynsymtab = (void*)(intptr_t)dynamicTab[j].d_val;
 			break;
 		// --- String Table ---
 		case DT_STRTAB:
 			DEBUGS(" elf_relocate: DYNAMIC String Table 0x%x (0x%x)",
 				dynamicTab[j].d_val, dynamicTab[j].d_val + iBaseDiff);
 			if(iBaseDiff != 0)	dynamicTab[j].d_val += iBaseDiff;
-			dynstrtab = (void*)(dynamicTab[j].d_val);
+			dynstrtab = (void*)(intptr_t)dynamicTab[j].d_val;
 			break;
 		// --- Hash Table --
 		case DT_HASH:
 			if(iBaseDiff != 0)	dynamicTab[j].d_val += iBaseDiff;
-			iSymCount = ((Elf32_Word*)(dynamicTab[j].d_val))[1];
-//			hdr->misc.HashTable = dynamicTab[j].d_val;	// Saved in unused bytes of ident
+//			iSymCount = ((Elf32_Word*)(intptr_t)dynamicTab[j].d_val)[1];
 			break;
 		}
 	}
 
 	if(dynsymtab == NULL) {
 		SysDebug("ld-acess.so - WARNING: No Dynamic Symbol table in %p, returning", hdr);
-		return (void *) hdr->entrypoint + iBaseDiff;
+		return (void *)(intptr_t) (hdr->entrypoint + iBaseDiff);
 	}
 
-	#if 0	
-	// Alter Symbols to true base
-	for(i=0;i<iSymCount;i++)
-	{
-		dynsymtab[i].value += iBaseDiff;
-		dynsymtab[i].nameOfs += (intptr_t)dynstrtab;
-		//DEBUGS("elf_relocate: Sym '%s' = 0x%x (relocated)", dynsymtab[i].name, dynsymtab[i].value);
-	}
-	#endif
-	
 	// === Add to loaded list (can be imported now) ===
 	AddLoaded( Filename, Base );
 
@@ -214,9 +204,10 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 				#endif
 				return 0;
 			}
+			DEBUGS(" Lib loaded");
 			break;
 		// --- PLT/GOT ---
-		case DT_PLTGOT:	pltgot = (void*)(iBaseDiff + dynamicTab[j].d_val);	break;
+//		case DT_PLTGOT:	pltgot = (void*)(iBaseDiff + dynamicTab[j].d_val);	break;
 		case DT_JMPREL:	plt = (void*)(iBaseDiff + dynamicTab[j].d_val);	break;
 		case DT_PLTREL:	pltType = dynamicTab[j].d_val;	break;
 		case DT_PLTRELSZ:	pltSz = dynamicTab[j].d_val;	break;
@@ -248,14 +239,14 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 	
 	DEBUGS(" elf_relocate: Beginning Relocation");
 	
-	void elf_doRelocate_386(uint32_t r_info, uint32_t *ptr, Elf32_Addr addend, int type, const char *Sym)
+	void elf_doRelocate_386(uint32_t r_info, uint32_t *ptr, Elf32_Addr addend, int type, int bRela, const char *Sym)
 	{
-		Uint32	val;
+		intptr_t	val;
 		switch( type )
 		{
 		// Standard 32 Bit Relocation (S+A)
 		case R_386_32:
-			val = (intptr_t) GetSymbol( Sym );
+			val = (intptr_t) GetSymbol(Sym, NULL);
 			DEBUGS(" elf_doRelocate: R_386_32 *0x%x += 0x%x('%s')",
 					ptr, val, Sym);
 			*ptr = val + addend;
@@ -264,7 +255,7 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 		// 32 Bit Relocation wrt. Offset (S+A-P)
 		case R_386_PC32:
 			DEBUGS(" elf_doRelocate: '%s'", Sym);
-			val = (intptr_t) GetSymbol( Sym );
+			val = (intptr_t) GetSymbol(Sym, NULL);
 			DEBUGS(" elf_doRelocate: R_386_PC32 *0x%x = 0x%x + 0x%x - 0x%x",
 				ptr, *ptr, val, (intptr_t)ptr );
 			*ptr = val + addend - (intptr_t)ptr;
@@ -275,7 +266,7 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 		case R_386_GLOB_DAT:
 		case R_386_JMP_SLOT:
 			DEBUGS(" elf_doRelocate: '%s'", Sym);
-			val = (intptr_t) GetSymbol( Sym );
+			val = (intptr_t) GetSymbol( Sym, NULL );
 			DEBUGS(" elf_doRelocate: %s *0x%x = 0x%x", csaR_NAMES[type], ptr, val);
 			*ptr = val;
 			break;
@@ -285,36 +276,55 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 			DEBUGS(" elf_doRelocate: R_386_RELATIVE *0x%x = 0x%x + 0x%x", ptr, iBaseDiff, addend);
 			*ptr = iBaseDiff + addend;
 			break;
-			
+	
+		case R_386_COPY: {
+			size_t	size;
+			void	*src = GetSymbol(Sym, &size);
+			DEBUGS(" elf_doRelocate_386: R_386_COPY (%p, %p, %i)", ptr, src, size);
+			memcpy(ptr, src, size);
+			break; }
+	
 		default:
 			SysDebug("elf_doRelocate_386: Unknown relocation %i", type);
 			break;
 		}
 	}
 
-	void elf_doRelocate_arm(uint32_t r_info, uint32_t *ptr, Elf32_Addr addend, int type, const char *Sym)
+	void elf_doRelocate_arm(uint32_t r_info, uint32_t *ptr, Elf32_Addr addend, int type, int bRela, const char *Sym)
 	{
 		uint32_t	val;
 		switch(type)
 		{
 		// (S + A) | T
 		case R_ARM_GLOB_DAT:
+			DEBUGS(" elf_doRelocate_arm: R_ARM_GLOB_DAT %p (%s + %x)", ptr, Sym, addend);
+			val = (intptr_t)GetSymbol(Sym, NULL);
+			*ptr = val + addend;
+			break;
 		case R_ARM_JUMP_SLOT:
-			val = (intptr_t)GetSymbol(Sym);
+			if(!bRela)	addend = 0;
+			DEBUGS(" elf_doRelocate_arm: R_ARM_JUMP_SLOT %p (%s + %x)", ptr, Sym, addend);
+			val = (intptr_t)GetSymbol(Sym, NULL);
 			*ptr = val + addend;
 			break;
+		case R_ARM_COPY: {
+			size_t	size;
+			void	*src = GetSymbol(Sym, &size);
+			DEBUGS(" elf_doRelocate_arm: R_ARM_COPY (%p, %p, %i)", ptr, src, size);
+			memcpy(ptr, src, size);
+			break; }
 		default:
 			SysDebug("elf_doRelocate_arm: Unknown Relocation, %i", type);
 			break;
 		}
 	}
 
-	void _doRelocate(uint32_t r_info, uint32_t *ptr, Elf32_Addr addend)
+	void _doRelocate(uint32_t r_info, uint32_t *ptr, int bRela, Elf32_Addr addend)
 	{
 		 int	type = ELF32_R_TYPE(r_info);
 		 int	sym = ELF32_R_SYM(r_info);
 		const char	*symname = dynstrtab + dynsymtab[sym].nameOfs;
-		do_relocate(r_info, ptr, addend, type, symname);
+		do_relocate(r_info, ptr, addend, type, bRela, symname);
 	}
 
 	switch(hdr->machine)
@@ -333,33 +343,33 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 	// Parse Relocation Entries
 	if(rel && relSz)
 	{
-		Uint32	*ptr;
+		Elf32_Word	*ptr;
 		DEBUGS(" elf_relocate: rel=0x%x, relSz=0x%x, relEntSz=0x%x", rel, relSz, relEntSz);
 		j = relSz / relEntSz;
 		for( i = 0; i < j; i++ )
 		{
 			//DEBUGS("  Rel %i: 0x%x+0x%x", i, iBaseDiff, rel[i].r_offset);
 			ptr = (void*)(iBaseDiff + rel[i].r_offset);
-			_doRelocate(rel[i].r_info, ptr, *ptr);
+			_doRelocate(rel[i].r_info, ptr, 0, *ptr);
 		}
 	}
 	// Parse Relocation Entries
 	if(rela && relaSz)
 	{
-		Uint32	*ptr;
+		Elf32_Word	*ptr;
 		DEBUGS(" elf_relocate: rela=0x%x, relaSz=0x%x, relaEntSz=0x%x", rela, relaSz, relaEntSz);
 		j = relaSz / relaEntSz;
 		for( i = 0; i < j; i++ )
 		{
 			ptr = (void*)(iBaseDiff + rela[i].r_offset);
-			_doRelocate(rel[i].r_info, ptr, rela[i].r_addend);
+			_doRelocate(rel[i].r_info, ptr, 1, rela[i].r_addend);
 		}
 	}
 	
 	// === Process PLT (Procedure Linkage Table) ===
 	if(plt && pltSz)
 	{
-		Uint32	*ptr;
+		Elf32_Word	*ptr;
 		DEBUGS(" elf_relocate: Relocate PLT, plt=0x%x", plt);
 		if(pltType == DT_REL)
 		{
@@ -369,7 +379,7 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 			for(i=0;i<j;i++)
 			{
 				ptr = (void*)(iBaseDiff + pltRel[i].r_offset);
-				_doRelocate(pltRel[i].r_info, ptr, *ptr);
+				_doRelocate(pltRel[i].r_info, ptr, 0, *ptr);
 			}
 		}
 		else
@@ -380,24 +390,24 @@ void *Elf32Relocate(void *Base, char **envp, const char *Filename)
 			for(i=0;i<j;i++)
 			{
 				ptr = (void*)(iRealBase + pltRela[i].r_offset);
-				_doRelocate(pltRela[i].r_info, ptr, pltRela[i].r_addend);
+				_doRelocate(pltRela[i].r_info, ptr, 1, pltRela[i].r_addend);
 			}
 		}
 	}
 	
-	DEBUGS("ElfRelocate: RETURN 0x%x", hdr->entrypoint + iBaseDiff);
-	return (void*)hdr->entrypoint + iBaseDiff;
+	DEBUGS("ElfRelocate: RETURN 0x%x to %p", hdr->entrypoint + iBaseDiff, __builtin_return_address(0));
+	return (void*)(intptr_t)( hdr->entrypoint + iBaseDiff );
 }
 
-int Elf32GetSymbol(void *Base, const char *Name, void **ret)
+int Elf32GetSymbol(void *Base, const char *Name, void **ret, size_t *Size)
 {
 	Elf32_Ehdr	*hdr = Base;
 	Elf32_Sym	*symtab;
 	 int	nbuckets = 0;
-	 int	iSymCount = 0;
+//	 int	iSymCount = 0;
 	 int	i;
-	Uint32	*pBuckets;
-	Uint32	*pChains;
+	Elf32_Word	*pBuckets;
+	Elf32_Word	*pChains;
 	uint32_t	iNameHash;
 	const char	*dynstrtab;
 	uintptr_t	iBaseDiff = -1;
@@ -439,7 +449,7 @@ int Elf32GetSymbol(void *Base, const char *Name, void **ret)
 	}
 	
 	nbuckets = pBuckets[0];
-	iSymCount = pBuckets[1];
+//	iSymCount = pBuckets[1];
 	pBuckets = &pBuckets[2];
 	pChains = &pBuckets[ nbuckets ];
 	
@@ -451,6 +461,7 @@ int Elf32GetSymbol(void *Base, const char *Name, void **ret)
 	i = pBuckets[ iNameHash ];
 	if(symtab[i].shndx != SHN_UNDEF && strcmp(dynstrtab + symtab[i].nameOfs, Name) == 0) {
 		*ret = (void*) (intptr_t) symtab[ i ].value + iBaseDiff;
+		if(Size)	*Size = symtab[i].size;
 		return 1;
 	}
 	
@@ -459,6 +470,7 @@ int Elf32GetSymbol(void *Base, const char *Name, void **ret)
 		i = pChains[i];
 		if(symtab[i].shndx != SHN_UNDEF && strcmp(dynstrtab + symtab[ i ].nameOfs, Name) == 0) {
 			*ret = (void*)(intptr_t)symtab[ i ].value + iBaseDiff;
+			if(Size)	*Size = symtab[i].size;
 			return 1;
 		}
 	}
@@ -507,16 +519,16 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 			compiledBase = phtab[i].p_vaddr;
 	}
 
-	baseDiff = (Elf64_Addr)Base - compiledBase;
+	baseDiff = (uintptr_t)Base - compiledBase;
 
 	DEBUGS("baseDiff = %p", baseDiff);
 
 	if(dyntab == NULL) {
 		SysDebug(" Elf64Relocate: No PT_DYNAMIC segment in image %p, returning", Base);
-		return (void *)(hdr->e_entry + baseDiff);
+		return (void *)(uintptr_t)(hdr->e_entry + baseDiff);
 	}
 
-	dyntab = (void *)((Elf64_Addr)dyntab + baseDiff);
+	dyntab = (void *)(uintptr_t)((uintptr_t)dyntab + baseDiff);
 
 	// Parse the dynamic table (first pass)
 	// - Search for String, Symbol and Hash tables
@@ -526,15 +538,15 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 		{
 		case DT_SYMTAB:
 			dyntab[i].d_un.d_ptr += baseDiff;
-			symtab = (void *)dyntab[i].d_un.d_ptr;
+			symtab = (void *)(uintptr_t)dyntab[i].d_un.d_ptr;
 			break;
 		case DT_STRTAB:
 			dyntab[i].d_un.d_ptr += baseDiff;
-			strtab = (void *)dyntab[i].d_un.d_ptr;
+			strtab = (void *)(uintptr_t)dyntab[i].d_un.d_ptr;
 			break;
 		case DT_HASH:
 			dyntab[i].d_un.d_ptr += baseDiff;
-			hashtab = (void *)dyntab[i].d_un.d_ptr;
+			hashtab = (void *)(uintptr_t)dyntab[i].d_un.d_ptr;
 			break;
 		}
 	}
@@ -567,7 +579,7 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 		// Relocation entries
 		case DT_REL:
 			dyntab[i].d_un.d_ptr += baseDiff;
-			rel = (void *)dyntab[i].d_un.d_ptr;
+			rel = (void *)(uintptr_t)dyntab[i].d_un.d_ptr;
 			break;
 		case DT_RELSZ:
 			rel_count = dyntab[i].d_un.d_val / sizeof(Elf64_Rel);
@@ -581,7 +593,7 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 			break;
 		case DT_RELA:
 			dyntab[i].d_un.d_ptr += baseDiff;
-			rela = (void *)dyntab[i].d_un.d_ptr;
+			rela = (void *)(uintptr_t)dyntab[i].d_un.d_ptr;
 			break;
 		case DT_RELASZ:
 			rela_count = dyntab[i].d_un.d_val / sizeof(Elf64_Rela);
@@ -595,7 +607,7 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 			break;
 		case DT_JMPREL:
 			dyntab[i].d_un.d_ptr += baseDiff;
-			pltrel = (void *)dyntab[i].d_un.d_ptr;
+			pltrel = (void *)(uintptr_t)dyntab[i].d_un.d_ptr;
 			break;
 		case DT_PLTREL:
 			plt_type = dyntab[i].d_un.d_val;
@@ -617,15 +629,21 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 		case R_X86_64_NONE:
 			break;
 		case R_X86_64_64:
-			*(uint64_t*)ptr = (uint64_t)GetSymbol(symname) + addend;
-			break;
-		case R_X86_64_COPY:
+			*(uint64_t*)ptr = (uintptr_t)GetSymbol(symname, NULL) + addend;
 			break;
+		case R_X86_64_COPY: {
+			size_t	size;
+			void	*sym = GetSymbol(symname, &size);
+			memcpy(ptr, sym, size);
+			} break;
 		case R_X86_64_GLOB_DAT:
-			*(uint64_t*)ptr = (uint64_t)GetSymbol(symname);
+			*(uint64_t*)ptr = (uintptr_t)GetSymbol(symname, NULL);
 			break;
 		case R_X86_64_JUMP_SLOT:
-			*(uint64_t*)ptr = (uint64_t)GetSymbol(symname);
+			*(uint64_t*)ptr = (uintptr_t)GetSymbol(symname, NULL);
+			break;
+		case R_X86_64_RELATIVE:
+			*(uint64_t*)ptr = (uintptr_t)Base + addend;
 			break;
 		default:
 			SysDebug("ld-acess - _Elf64DoReloc: Unknown relocation type %i", type);
@@ -638,7 +656,7 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 		DEBUGS("rel_count = %i", rel_count);
 		for( i = 0; i < rel_count; i ++ )
 		{
-			uint64_t *ptr = (void *)( rel[i].r_offset + baseDiff );
+			uint64_t *ptr = (void *)(uintptr_t)( rel[i].r_offset + baseDiff );
 			_Elf64DoReloc( rel[i].r_info, ptr, *ptr);
 		}
 	}
@@ -648,7 +666,8 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 		DEBUGS("rela_count = %i", rela_count);
 		for( i = 0; i < rela_count; i ++ )
 		{
-			_Elf64DoReloc( rela[i].r_info, (void *)( rela[i].r_offset + baseDiff ), rela[i].r_addend );
+			uint64_t *ptr = (void *)(uintptr_t)( rela[i].r_offset + baseDiff );
+			_Elf64DoReloc( rela[i].r_info, ptr, rela[i].r_addend );
 		}
 	}
 
@@ -660,7 +679,7 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 			DEBUGS("plt rel count = %i", count);
 			for( i = 0; i < count; i ++ )
 			{
-				uint64_t *ptr = (void *)( plt[i].r_offset + baseDiff );
+				uint64_t *ptr = (void *)(uintptr_t)( plt[i].r_offset + baseDiff );
 				_Elf64DoReloc( plt[i].r_info, ptr, *ptr);
 			}
 		}
@@ -670,21 +689,25 @@ void *Elf64Relocate(void *Base, char **envp, const char *Filename)
 			DEBUGS("plt rela count = %i", count);
 			for( i = 0; i < count; i ++ )
 			{
-				_Elf64DoReloc( plt[i].r_info, (void *)(plt[i].r_offset + baseDiff), plt[i].r_addend);
+				uint64_t *ptr = (void *)(uintptr_t)( plt[i].r_offset + baseDiff );
+				_Elf64DoReloc( plt[i].r_info, ptr, plt[i].r_addend);
 			}
 		}
 	}
 
-	DEBUGS("Elf64Relocate: Relocations done, return %p", (void *)(hdr->e_entry + baseDiff));
-	return (void *)(hdr->e_entry + baseDiff);
+	{
+	void *ret = (void *)(uintptr_t)(hdr->e_entry + baseDiff);
+	DEBUGS("Elf64Relocate: Relocations done, return %p", ret);
+	return ret;
+	}
 }
 
-int Elf64GetSymbol(void *Base, const char *Name, void **Ret)
+int Elf64GetSymbol(void *Base, const char *Name, void **Ret, size_t *Size)
 {
 	Elf64_Ehdr	*hdr = Base;
 	Elf64_Sym	*symtab;
 	 int	nbuckets = 0;
-	 int	iSymCount = 0;
+//	 int	iSymCount = 0;
 	 int	i;
 	Elf64_Word	*pBuckets;
 	Elf64_Word	*pChains;
@@ -740,7 +763,7 @@ int Elf64GetSymbol(void *Base, const char *Name, void **Ret)
 	}
 
 	nbuckets = pBuckets[0];
-	iSymCount = pBuckets[1];
+//	iSymCount = pBuckets[1];
 	pBuckets = &pBuckets[2];
 	pChains = &pBuckets[ nbuckets ];
 	
@@ -752,6 +775,7 @@ int Elf64GetSymbol(void *Base, const char *Name, void **Ret)
 	i = pBuckets[ iNameHash ];
 	if(symtab[i].st_shndx != SHN_UNDEF && strcmp(dynstrtab + symtab[i].st_name, Name) == 0) {
 		*Ret = (void*) (intptr_t) symtab[i].st_value + iBaseDiff;
+		if(Size)	*Size = symtab[i].st_size;
 		DEBUGS("%s = %p", Name, *Ret);
 		return 1;
 	}
@@ -761,6 +785,7 @@ int Elf64GetSymbol(void *Base, const char *Name, void **Ret)
 		i = pChains[i];
 		if(symtab[i].st_shndx != SHN_UNDEF && strcmp(dynstrtab + symtab[i].st_name, Name) == 0) {
 			*Ret = (void*)(intptr_t)symtab[i].st_value + iBaseDiff;
+			if(Size)	*Size = symtab[i].st_size;
 			DEBUGS("%s = %p", Name, *Ret);
 			return 1;
 		}
@@ -771,12 +796,12 @@ int Elf64GetSymbol(void *Base, const char *Name, void **Ret)
 #endif
 
 
-Uint32 ElfHashString(const char *name)
+uint32_t ElfHashString(const char *name)
 {
-	Uint32	h = 0, g;
+	uint32_t	h = 0, g;
 	while(*name)
 	{
-		h = (h << 4) + *(Uint8*)name++;
+		h = (h << 4) + *(uint8_t*)name++;
 		if( (g = h & 0xf0000000) )
 			h ^= g >> 24;
 		h &= ~g;