/*

* Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <string.h>

#include <stdlib.h>

#include <e32std.h>

#include "elfdefs.h"

#include "elfdll.h"

#include "elffile.h"

#include "h_utl.h"

#include <e32ldr.h>

ELFFile::ELFDllData::ELFDllData(ELFFile * f) :

         iElfFile(f), iDynStrTab(0), iDynStrTabSize(0), iDynSymTab(0),

 		iSymSize(0), iRela(0), iRelaSz(0), iRelaEnt(0), 

 		iRel(0), iRelSz(0), iRelEnt(0),

 		iHashTable(0), iNamedExportSymbolHead(0),  iNamedExportCount(0),

		iSymStringTableSize(0),iStringNameOffset(0), 

		iDepRecords(0), iDepRecordsTail(0),iNeededDllNames(0),iNeededDllNamesTail(0),

		iOrdZeroRec(0), iNamedLookupEnabled(0), 

		iDllHead(0), iDllTail(0), 

 		iNumberOfImports(0),  iNumberOfExports(0), iNumberOfImportDlls(0),

 		iStringTableSize(0), iNumberOfRelocs(0), iNumberOfCodeRelocs(0),

 		iNumberOfDataRelocs(0)

		{

		}

ELFFile::ELFDllData::~ELFDllData()

	{

		delete iOrdZeroRec;

		delete iDepRecords;

		delete iNeededDllNames;

	}

TBool ELFFile::ELFDllData::Init()

	{

	// process imported symbols

	// There will be at least one relocation (assumed to be Elf32_Rel) for each such symbol.

	// S iterate over relocations looking for DLL symbols and add them to the record of

	// of import info.

	TInt nrelocs = iRelSz/iRelEnt;

	TInt SrcSegIdx = -1;

	TInt errors = 0;

	for (TInt idx = 0; idx < nrelocs; idx++)

			{

			Elf32_Rel * rel = &iRel[idx];

			TUint relType = ELF32_R_TYPE(rel->r_info);

			if (relType == R_ARM_ABS32)      

					{	

					TInt symIdx = ELF32_R_SYM(rel->r_info);

					Elf32_Sym * sym = &iDynSymTab[symIdx];

					DllSymbol * dllSym = DllSymbolP(sym);

					if (dllSym) 

							{

							dllSym->iRel = rel;

							dllSym->iSegment = iElfFile->GetSegment(SrcSegIdx);

							if (!AddSymbol(dllSym)) return EFalse;

							}

					else errors++;

					}

			else if (relType == R_ARM_RABS32)

					{

					iNumberOfRelocs++;

					if (iElfFile->CodeSegmentP(SrcSegIdx)) iNumberOfCodeRelocs++;

					else iNumberOfDataRelocs++;

					}

			else if (relType == R_ARM_RBASE)

				    {

					SrcSegIdx = ELF32_R_SYM(rel->r_info);

					if (SrcSegIdx) SrcSegIdx--;

					}

			else 

				    {

					// Gives error with all other Relocation types..

					TInt symIdx = ELF32_R_SYM(rel->r_info);

					Elf32_Sym * s = &iDynSymTab[symIdx];

					char * symName = ELFADDR(char,iDynStrTab,s->st_name);

					Print(EPeError, "Unresolved symbol: %s\n", symName);

					errors++;

					}

			}

	// Set up export info

	if (InitExportInfo())

	       { 

	       // If _E32Startup is defined then this is not a DLL

	       iImageIsDll = !iElfFile->SymbolPresent("_E32Startup");

	       }

	if (errors > 0) return EFalse;

	return ETrue;

	}

TBool ELFFile::ELFDllData::ParseDllSymbol(Elf32_Sym * s, char *& dll, TUint& len, TInt& ord)

    {

	char * sym = ELFADDR(char,iDynStrTab,s->st_name);

	if (!strncmp(sym, DLLSYMPREFIX, strlen(DLLSYMPREFIX)))

			{

			dll = sym + strlen(DLLSYMPREFIX);

			TUint lim = strlen(dll);

			TUint index = strcspn(dll, DLLSYMPREFIX0);

			if ((index + strlen(DLLSYMSUFFIX)) < lim)

					{

					len = index;

					char * dllSuffix = dll+index;

					char * match = DLLSYMSUFFIX;

					int suflen = strlen(DLLSYMSUFFIX);

					if (!strncmp(dllSuffix, match, suflen))

							{

							char * ordString = dll+index+suflen;

							char * final;

							TUint X = strtoul(ordString, &final, ORDBASE);

							if (ordString != final)

									{

									ord = (TInt)X;

									return ETrue;

									}

							}

					}

			}

	dll = 0;

	len = 0;

	ord = -1;

	return EFalse;

	}

ELFFile::ELFDllData::DllSymbol * ELFFile::ELFDllData::DllSymbolP(Elf32_Sym * s)

    {

	char * dllName;

	TUint nameLen;

	TInt symOrd;

	if (ParseDllSymbol(s, dllName, nameLen, symOrd))

	       {

	       DllSymbol * ds = new DllSymbol(dllName, nameLen, symOrd);

	       if (ds) return ds;

	       Print(EPeError, "Out of memory.\n");

	       return NULL;

	       }

	// If we get here its not a valid 'dll symbol' and so it is an unresolved symbol

	char * sym = ELFADDR(char,iDynStrTab,s->st_name);

	Print(EPeError, "Unresolved symbol: %s\n", sym);

    return NULL;

	}

TBool ELFFile::ELFDllData::AddSymbol(ELFFile::ELFDllData::DllSymbol * s)

    {

	DllRec * aDll = NULL;

	for (DllRec * r = iDllHead; r != NULL; r = r->iNext)

			{

			if (!strncmp(s->iDll, r->iName, s->iLen))

					{

					aDll = r;

					break;

					}

			}

	if (aDll)

			{

		    iNumberOfImports++;

		    aDll->AddSymbol(s);

			return ETrue;

			}

	else

			{

			aDll = new DllRec(s->iDll, s->iLen, s);

			if (aDll)

					{

					if (!iDllHead) 

							{

							iDllHead = iDllTail = aDll;

							}

					else

							{

							iDllTail->iNext = aDll;

							iDllTail = aDll;

							}

					iStringTableSize += (s->iLen + 1);

	      			iNumberOfImportDlls++;

					iNumberOfImports++;

					return ETrue;

					}

			else

					{

					Print(EPeError, "Out of memory.\n");

					return EFalse;

					}

			}

	}

void ELFFile::ELFDllData::DllRec::AddSymbol(ELFFile::ELFDllData::DllSymbol * s)

	{

	nImports++;

    iTail->iNext = s;

    iTail = s;

    }

static unsigned long elf_hash(const unsigned char* name)

    {

    unsigned long h, g;

    for (h = 0; *name != 0; ++name)

	        {

			h = (h << 4) + *name;

			g = h & 0xf0000000;

			if (g != 0) h ^= g >> 24;

			h &= ~g;

			}

	return h;

    }

Elf32_Word ELFFile::ELFDllData::FindSymbolIndex(const char* s)

    {

	TUint h = elf_hash((const unsigned char*)s);

	TUint nb = iHashTable[0].nBuckets;

	TUint probe = h%nb;

	Elf32_Sword * bucket = ELFADDR(Elf32_Sword, iHashTable, sizeof(Elf32_HashTable));

	Elf32_Sword * chain = ELFADDR(Elf32_Sword, bucket, nb * sizeof(Elf32_Sword));

	Elf32_Sword idx = bucket[probe];

	do 	

			{

			if (!strcmp(ELFADDR(char, iDynStrTab, iDynSymTab[idx].st_name), s)) return idx;

			idx = chain[idx];

			} while (idx > 0);

	if (idx == 0) idx = -1;

	return idx;

	}

TBool ELFFile::ELFDllData::InitExportInfo()

	{

	memset(&iSymInfoHdr, 0, sizeof(iSymInfoHdr)); 

	if ((iExportTableSymIdx = FindSymbolIndex(EXPORTTABLENAME)) != (Elf32_Word)-1)

			{ 

			iExportTableSizeSymIdx = FindSymbolIndex(EXPORTTABLESIZENAME);

			//TUint offset = iDynSymTab[iExportTableSizeSymIdx].st_value - (TUint)code;

			Elf32_Word * pNumberOfExports = iElfFile->CodePtrFromAddr(iDynSymTab[iExportTableSizeSymIdx].st_value);

			iNumberOfExports = * pNumberOfExports;

			iImageIsDll = ETrue;

			return ETrue;

			}

	else iImageIsDll = EFalse;

	return EFalse;

	}

TInt ELFFile::ELFDllData::NumberOfImports(void)

    {

	return iNumberOfImports;

	}

TInt ELFFile::ELFDllData::NumberOfExports(void)

    {

	return iNumberOfExports;

	}

TInt ELFFile::ELFDllData::NumberOfImportDlls(void)

    {

	return iNumberOfImportDlls;

	}

TInt ELFFile::ELFDllData::NumberOfRelocs()

	{

	return iNumberOfRelocs;

	}

char * ELFFile::ELFDllData::CreateImportSection(TInt &aSize)

	{

	if (!iNumberOfImports)

			{

			aSize = 0;

			return 0;

			}

	TInt byteSize = sizeof(E32ImportSection) + 

	                (sizeof(E32ImportBlock) * iNumberOfImportDlls) +

					(sizeof(TUint) * iNumberOfImports) +

					iStringTableSize;

	if(iNamedLookupEnabled)

	{

		// 0th ordinal of each DLL imported from.

		byteSize += (sizeof(TUint) * iNumberOfImportDlls);

	}

	char * newSection = new char[byteSize];

	if (!newSection)

	       {

	       Print(EPeError, "Failed to allocate new import section.\n");

	       aSize = 0;

	       return 0;

	       }

	((E32ImportSection *)newSection)->iSize = byteSize;

	// used to point to current ImportBlock

	E32ImportBlock * bp = ELFADDR(E32ImportBlock, newSection, sizeof(E32ImportSection));

	// used to point to current import relocation entry

	TUint * rp;

	// used to point to current location in string table

	char * sp = ELFADDR(char, newSection, (byteSize - iStringTableSize));

	OrdZeroRecord *aDep = iDepRecords;

	for (DllRec * dll = iDllHead; dll != NULL ; dll = dll->iNext, bp = (E32ImportBlock *)rp )

	        {

			// set up the offset from E32ImportBlock.iOffsetOfDllName to the

			// corresponding  string table location

			bp->iOffsetOfDllName = (sp - (char *)newSection);

			bp->iNumberOfImports = dll->nImports;

			if(iNamedLookupEnabled)

			{

				bp->iNumberOfImports++;

			}

			// copy the DLL name to the string table

			memcpy(sp , dll->iName, dll->iLen);

			sp[dll->iLen] = 0;

			sp = sp + dll->iLen + 1;

			// sort out the import 'relocs'

			rp = ELFADDR(TUint, bp, sizeof(E32ImportBlock));

			for (DllSymbol * sym = dll->iHead; sym != NULL; sym = sym->iNext, rp++)

				    {

					Elf32_Phdr * segment = sym->iSegment;

					Elf32_Addr segBase = segment->p_vaddr;

					// sanity check: segment should be the code segment

					if (!iElfFile->CodeSegmentP(segment))

							{

							Print(EPeError, "Import relocation does not refer to code segment.\n");

							Print(EPeError, "Dll: %s\n", sym->iDll);

							Print(EPeError, "Ordinal: %d\n", sym->iOrd);

							Print(EPeError, "DLL name: %s\n", dll->iName);

							aSize = 0;

							return 0;

							}

					// This field is misnamed because it is actually given as a virtual address in 

					// dynamic relocations

					Elf32_Addr dynOffset = sym->iRel->r_offset;

					//So this is the 'real' offset of the reloc in  the segment in which it occurs

					Elf32_Addr segOffset = dynOffset - segBase;

					TUint * relocAddr = ELFADDR(TUint, iElfFile->ELFFileBase(), (segment->p_offset + segOffset));

					// The only non-zero reloc vals we expect are for vtables.

					// We store there reloc offset in the top 16 bits of the 'reloc info'.

					// NB the ELF reloc values should only ever be multiples of 4. So we could optimize here,

					// but we won't.

					TUint relocVal = *relocAddr;

					TUint importOrdinal = sym->iOrd;

					if (relocVal > 0xFFFF) {

							Print(EPeError, "ELF relocation exceeds E32Image limit of 64K.\n");

							Print(EPeError, "Dll: %s\n", sym->iDll);

							Print(EPeError, "Ordinal: %d\n", sym->iOrd);

							Print(EPeError, "DLL name: %s\n", dll->iName);

					}

					if (importOrdinal > 0xFFFF) {

							Print(EPeError, "Import ordinal exceeds E32Image limit of 64K.\n");

							Print(EPeError, "Dll: %s\n", sym->iDll);

							Print(EPeError, "Ordinal: %d\n", sym->iOrd);

							Print(EPeError, "DLL name: %s\n", dll->iName);

					}   

   					*rp = segOffset;

   					// eek !! surgery on the code segment....

					*relocAddr = (relocVal<<16) | importOrdinal;

					}

				if(iNamedLookupEnabled)

				{

					aDep = FindDependency(dll->iName, dll->iLen);

					if( aDep )

					{

						*rp = aDep->iOffset;

						rp++;

					}

				}

			}

	aSize = byteSize;

	return newSection;

	}

TUint ELFFile::ELFDllData::GetExportTableOffset(void)

    {

	Elf32_Sym * et = &iDynSymTab[iExportTableSymIdx];

	Elf32_Phdr * segment = iElfFile->GetSegment(et->st_shndx - 1);

	return et->st_value - segment->p_vaddr;

	}

TBool ELFFile::ELFDllData::GetRelocs(Elf32_Rel **aCodeRelocs, Elf32_Rel **aDataRelocs)

	//	

	// load the relocs from the reloc section into relocation and relocsection arrays

	//

	{

	TInt nrelocs = iRelSz/iRelEnt;

	TInt SrcSegIdx = -1;

	TInt idx = 0;

	TInt cidx = 0;

	TInt didx = 0;

	for (idx = 0, cidx = 0, didx = 0; idx < nrelocs; idx++)

	        {

			Elf32_Rel * rel = &iRel[idx];

			if (ELF32_R_TYPE(rel->r_info) == R_ARM_RABS32)

					{

					if (iElfFile->CodeSegmentP(SrcSegIdx))

							aCodeRelocs[cidx++]=rel;

					else if (iElfFile->DataSegmentP(SrcSegIdx))

							aDataRelocs[didx++]=rel;

					}

			else if (ELF32_R_TYPE(rel->r_info) == R_ARM_RBASE)

					{

					SrcSegIdx = ELF32_R_SYM(rel->r_info);

					if (!(iElfFile->CodeSegmentP(SrcSegIdx-1) || iElfFile->DataSegmentP(SrcSegIdx-1)))

							{

							Print(EPeError, "Source segment for relocations is neither Code or Data.\n");

							return EFalse;

							}

					SrcSegIdx--;

					}

			}

	if(!iNamedLookupEnabled)

		return ETrue;

	// Add the 0th ordinal of this binary - The relocation info is already setup.

	aCodeRelocs[cidx++] = &iOrdZeroRec->iReloc;

	// add relocation entries for each of the symbols

	NamedExportSymbol *aSym = iNamedExportSymbolHead;

	while(aSym)

	{

		// The symbol name info is part of the code section hence all relocations

		// are collected as part of Code relocations.

		aCodeRelocs[cidx++] = &aSym->iReloc;

		aSym = aSym->Next();

	}

	// Since we have added a few relocations, lets make sure

	// they are still sorted on addresses they refer to.

	//Sorting the code relocs

	TInt aIdx1, aIdx2;

	Elf32_Rel *aTmp;

	for (aIdx1 = 0; aIdx1 < cidx; aIdx1++) {

		for (aIdx2 = aIdx1; aIdx2 < cidx; aIdx2++) {

			if(aCodeRelocs[aIdx1]->r_offset > aCodeRelocs[aIdx2]->r_offset) {

				aTmp = aCodeRelocs[aIdx2];

				aCodeRelocs[aIdx2] = aCodeRelocs[aIdx1];

				aCodeRelocs[aIdx1] = aTmp;

			}

		}

	}

	//Sorting the data relocs

	for (aIdx1 = 0; aIdx1 < didx; aIdx1++) {

		for (aIdx2 = aIdx1; aIdx2 < didx; aIdx2++) {

			if(aDataRelocs[aIdx1]->r_offset > aDataRelocs[aIdx2]->r_offset) {

				aTmp = aDataRelocs[aIdx2];

				aDataRelocs[aIdx2] = aDataRelocs[aIdx1];

				aDataRelocs[aIdx1] = aTmp;

			}

		}

	}

	return ETrue;

	}

NamedExportSymbol::NamedExportSymbol(char* aName, Elf32_Addr aValue) : \

	iSymbolName(aName), iValue(aValue), iNext(NULL)

{

}

TBool ELFFile::ELFDllData::CreateSymLookupTable()

{

	if( !SetupSymbolValues() )