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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Implementation of the Class ElfExecutable for the elf2e32 tool

// @internalComponent

// @released

// 

//

#include "pl_elfexecutable.h"

#include "errorhandler.h"

#include <stdio.h>

#include "parameterlistinterface.h"

#include "pl_elfimportrelocation.h"

#include "pl_dllsymbol.h"

#include "messagehandler.h"

#include "pl_elflocalrelocation.h"

/**

Constructor for class ElfExecutable

@param aParameterListInterface - Instance of class ParameterListInterface

@internalComponent

@released

*/

ElfExecutable::ElfExecutable(ParameterListInterface *aParameterListInterface) :\

	iElfHeader(NULL), \

	iEntryPoint(0),\

	iProgHeader(NULL), \

	iSONameOffset(0) ,\

	iSections (NULL) , \

	iVersionDef (NULL) , iVerDefCount(0), \

	iVersionNeed (NULL) , iVerNeedCount(0), \

	iVersionTbl (NULL) ,iRelSize(0),iRelEntSize(0), \

	iNRelocs(0),

	iRel (NULL) ,iRelaSize(0), iRelaEntSize(0), \

	iRela(NULL), 

	iStringTable (NULL) , \

	iSectionHdrStrTbl(NULL), \

	iVerInfo(NULL),	iElfDynSym (NULL), \

	iSymTab (NULL), \

	iStrTab (NULL), \

	iLim (NULL), \

	iNSymbols(0), \

	iHashTbl (NULL) , \

	iDynSegmentHdr (NULL) , \

	iDataSegmentHdr (NULL) ,iDataSegment(NULL), iDataSegmentSize(0), iDataSegmentIdx(0), \

	iCodeSegmentHdr (NULL) , iCodeSegment(NULL), iCodeSegmentSize(0), iCodeSegmentIdx(0), \

	iExports (NULL), \

	iParameterListInterface(aParameterListInterface),\

	iPltGotBase(0), iPltGotLimit(0), iStrTabSz(0), iSymEntSz(0), \

	iPltGot(NULL), iPltRel(NULL),iPltRelaSz(0), iPltRela(NULL), iPltRelSz(0)  \

{

}

/**

Destructor for class ElfExecutable

@internalComponent

@released

*/

ElfExecutable::~ElfExecutable()

{

	delete iExports;

	delete [] iVerInfo;

	/* 

	all of these were getting deleted, they are not allocated by 

	ElfExecutable, they simply refer to a linear array of images 

	in an ElfImage, hence they shouldn't be de-allocated 

	delete iRela;

	delete iPltRel;

	delete iPltRela; */ 

	iNeeded.clear();

	iSymbolTable.clear();

}

/**

Function to process Elf file

@param aElfHdr - pointer to Elf header

@return 0 if its valid ELF file

@internalComponent

@released

*/

PLUINT32  ElfExecutable::ProcessElfFile(Elf32_Ehdr *aElfHdr) {

	iElfHeader = aElfHdr;

	iEntryPoint = aElfHdr->e_entry;

	ValidateElfFile();

	/* A valid ELF file so far..*/

	/* Get the Section base..*/

	if(iElfHeader->e_shnum) {

		iSections = ELF_ENTRY_PTR(Elf32_Shdr, iElfHeader, iElfHeader->e_shoff); 

	}

	/* Get the program header..*/

	if(iElfHeader->e_phnum) {

		iProgHeader = ELF_ENTRY_PTR(Elf32_Phdr, iElfHeader, iElfHeader->e_phoff);

	}

	/* Get the section-header-string table..*/

	if(iElfHeader->e_shstrndx != SHN_UNDEF) {

		if(iElfHeader->e_shstrndx > iElfHeader->e_shnum ) {

			throw ELFFormatError(ELFSHSTRINDEXERROR,iParameterListInterface->ElfInput());

		}

		iSectionHdrStrTbl = ELF_ENTRY_PTR(char, iElfHeader, iSections[iElfHeader->e_shstrndx].sh_offset);

	}

	if( iProgHeader ) {

		PLUINT32 aIdx = 0;

		while( aIdx < iElfHeader->e_phnum) {

			switch( iProgHeader[aIdx].p_type ) {

			case PT_DYNAMIC:

				{

					iDynSegmentHdr = &iProgHeader[aIdx];

				}

				break;

			case PT_LOAD:

				{

					if( (iProgHeader[aIdx].p_flags) & (PF_X | PF_ARM_ENTRY) ) {

						iCodeSegmentHdr = &iProgHeader[aIdx];

						iCodeSegmentIdx = aIdx;

						iCodeSegment = ELF_ENTRY_PTR(char, iElfHeader, iCodeSegmentHdr->p_offset);

						iCodeSegmentSize = iCodeSegmentHdr->p_filesz;

					}

					else if( (iProgHeader[aIdx].p_flags) & (PF_W | PF_R) ) {

						iDataSegmentHdr = &iProgHeader[aIdx];

						iDataSegmentIdx = aIdx;

						iDataSegment = ELF_ENTRY_PTR(char, iElfHeader, iDataSegmentHdr->p_offset);

						iDataSegmentSize = iDataSegmentHdr->p_filesz;

					}

				}

				break;

			default:

				break;

			}

			aIdx++;

		}

		if( iDynSegmentHdr ) {

			ProcessDynamicEntries();

		}

		ProcessSymbols();

		ProcessRelocations();

	}

	return 0;

}

/**

Function to Find the Static Symbol Table

@internalComponent

@released

*/

void ElfExecutable::FindStaticSymbolTable()

{

	size_t nShdrs = iElfHeader->e_shnum;

	if (nShdrs)

	{

		// Find the static symbol table and string table

		for (PLUINT32 i = 0; i < nShdrs; i++)

		{

			if (iSections[i].sh_type == SHT_SYMTAB)

			{

				iSymTab = ELF_ENTRY_PTR(Elf32_Sym, iElfHeader, iSections[i].sh_offset);

				iLim = ELF_ENTRY_PTR(Elf32_Sym, iSymTab, iSections[i].sh_size);

				if (iStrTab) break;

			}

			else if (iSections[i].sh_type == SHT_STRTAB)

			{

				char * aSectionName = iSectionHdrStrTbl + iSections[i].sh_name;

				if (!strcmp(aSectionName, ".strtab"))

				{

					iStrTab = ELF_ENTRY_PTR(char, iElfHeader, iSections[i].sh_offset);

					if (iSymTab) break;

				}

			}

		}

	}

}

/**

Function to Find the Comment Section

@return aComment - Pointer to Comment Section

@internalComponent

@released

*/

char* ElfExecutable::FindCommentSection()

{

	size_t nShdrs = iElfHeader->e_shnum;

	char *aCommentSection = ".comment";

	char *aComment;

	if (nShdrs)

	{

		// find the comment section

		for (PLUINT32 i = 0; i < nShdrs; i++)

		{

			if (iSections[i].sh_type == SHT_PROGBITS)

			{

				char * aSectionName = iSectionHdrStrTbl + iSections[i].sh_name;

				int length = strlen(aCommentSection);

				if (!strncmp(aSectionName, aCommentSection, length))

				{

					aComment = ELF_ENTRY_PTR(char, iElfHeader, iSections[i].sh_offset);

					return aComment;

				}

			}

		}

	}

	return NULL;

}

/**

Function to process the ARM to Thumb veneers

@internalComponent

@released

*/

void ElfExecutable::ProcessVeneers()

{

	if (iSymTab && iStrTab)

	{	

		ElfRelocations::RelocationList & iLocalCodeRelocs = GetCodeRelocations();

		Elf32_Sym *aSymTab = iSymTab;

		int length = strlen("$Ven$AT$L$$");

		// Process the symbol table to find Long ARM to Thumb Veneers

		// i.e. symbols of the form '$Ven$AT$L$$'

		for(; aSymTab < iLim; aSymTab++)

		{

			if (!aSymTab->st_name) continue;

			char * aSymName = iStrTab + aSymTab->st_name;

			Elf32_Sym	*aSym;

			if (!strncmp(aSymName, "$Ven$AT$L$$", length))

			{

				aSym = aSymTab;

				Elf32_Addr r_offset = aSym->st_value;

				Elf32_Addr aOffset = r_offset + 4;

				Elf32_Word	aInstruction = FindValueAtLoc(r_offset);

				bool aRelocEntryFound = false;

				ElfRelocations::RelocationList::iterator r;

				for (r = iLocalCodeRelocs.begin(); r != iLocalCodeRelocs.end(); r++)

				{

					ElfLocalRelocation * aReloc = *r;

					// Check if there is a relocation entry for the veneer symbol

					if (aReloc->iAddr == aOffset)

					{

						aRelocEntryFound = true;

						break;

					}

				}

				Elf32_Word aPointer = FindValueAtLoc(aOffset);

				/* If the symbol addresses a Thumb instruction, its value is the

				 * address of the instruction with bit zero set (in a

				 * relocatable object, the section offset with bit zero set).

				 * This allows a linker to distinguish ARM and Thumb code symbols 

				 * without having to refer to the map. An ARM symbol will always have 

				 * an even value, while a Thumb symbol will always have an odd value.

				 * Reference: Section 4.5.3 in Elf for the ARM Architecture Doc

				 * aIsThumbSymbol will be 1 for a thumb symbol and 0 for ARM symbol

				 */

				int aIsThumbSymbol = aPointer & 0x1;

				/* The relocation entry should be generated for the veneer only if

				 * the following three conditions are satisfied:

				 * 1) Check if the instruction at the symbol is as expected 

				 *    i.e. has the bit pattern 0xe51ff004 == 'LDR pc,[pc,#-4]'

				 * 2) There is no relocation entry generated for the veneer symbol

				 * 3) The instruction in the location provided by the pointer is a thumb symbol

				 */

				if (aInstruction == 0xE51FF004 && !aRelocEntryFound && aIsThumbSymbol)

				{

					ElfLocalRelocation	*aRel;

					PLUCHAR	aType = R_ARM_NONE;

					aRel = new ElfLocalRelocation(this, aOffset, 0, 0, aType, NULL, ESegmentRO, aSym, false, true);

					if(aRel) 

					{

						aRel->Add();

					}

				}

			}

		}

	}

}

/**

Function to find the content of the address passed in

@param aOffset - Address

@return aLocVal - The content of the address, like instruction or a pointer

@internalComponent

@released

*/

Elf32_Word	ElfExecutable::FindValueAtLoc(Elf32_Addr aOffset)

{

	Elf32_Phdr  *aHdr = Segment(aOffset);

	PLUINT32 aLoc = aHdr->p_offset + aOffset - aHdr->p_vaddr;

	Elf32_Word	*aLocVal = ELF_ENTRY_PTR(Elf32_Word, iElfHeader, aLoc);

	return *aLocVal;

}

/**

Function to process Elf symbols

@internalComponent

@released

*/

PLUINT32  ElfExecutable::ProcessSymbols(){

	PLUINT32	aSymIdx = 0;

	DllSymbol	*aSymbol;

	char		*aDllName;

	char		*aSymName, *aNewSymName;

	SymbolType	aType;

	while( aSymIdx < iNSymbols ) {

		aSymName = ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aSymIdx].st_name );

		if( ExportedSymbol( &iElfDynSym[aSymIdx] ) ){

			if( FunctionSymbol( &iElfDynSym[aSymIdx] ))

				aType = SymbolTypeCode;

			else

				aType = SymbolTypeData;

			aSymName = ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aSymIdx].st_name );

			aDllName = iVerInfo[iVersionTbl[aSymIdx]].iLinkAs;

			aNewSymName = new char[strlen(aSymName)+1];

			strcpy(aNewSymName, aSymName);

			aSymbol = new DllSymbol( aNewSymName, aType, &iElfDynSym[aSymIdx], aSymIdx);

			aSymbol->SetSymbolSize(iElfDynSym[aSymIdx].st_size);

			//Putting the symbols into a hash table - Used later while processing relocations

			iSymbolTable[aSymIdx] = aSymbol ;

			if( !AddToExports( aDllName, aSymbol ))

			{

				//Not a valid export... delete it..

				delete aSymbol;

			}

		}

		else if( ImportedSymbol( &iElfDynSym[aSymIdx] ) ){

			if( FunctionSymbol( &iElfDynSym[aSymIdx] ))

				aType = SymbolTypeCode;

			else

				aType = SymbolTypeData;

			aSymName = ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aSymIdx].st_name );

			/*

			 * All imported symbols must be informed via the version needed information.

			 */

			if( iVerInfo[iVersionTbl[aSymIdx]].iVerCategory != VER_CAT_NEEDED ) {

				throw UndefinedSymbolError(UNDEFINEDSYMBOLERROR, iParameterListInterface->ElfInput(), aSymName);

			}

			aDllName = iVerInfo[iVersionTbl[aSymIdx]].iLinkAs;

			//aSymbol = new DllSymbol( aSymName, aType, &iElfDynSym[aSymIdx], aSymIdx);

			//Putting the symbols into a hash table

			//iSymbolTable[aSymIdx] = aSymbol ;

		}

		aSymIdx++;

	}

	return 0;

}

/**

This function Dump all the sections with their section details (i.e., the section name, type,

size and linked section if any)

@param aFile - ELF file name

@internalComponent

@released

*/

void ElfExecutable::DumpElfFile(char* aFile){

	aFile = aFile;

}

/**

This function adds exports into the export list

@param aDll - Dll name

@param aSymbol - Symbol

@return

@internalComponent

@released

*/

DllSymbol* ElfExecutable::AddToExports(char* aDll, DllSymbol* aSymbol){

	if( !iExports ) {

		iExports = new ElfExports();

	}

	return iExports->Add( aDll, this, aSymbol );

}

/**

This function adds imports into the map

@param aReloc - Instance of class ElfImportRelocation

@internalComponent

@released

*/

void  ElfExecutable::AddToImports(ElfImportRelocation* aReloc){

	SetVersionRecord(aReloc);

	//char *aDll = iVerInfo[iVersionTbl[aReloc->iSymNdx]].iLinkAs;

	char *aDll = aReloc->iVerRecord->iLinkAs;

	iImports.Add( (const char*)aDll, aReloc );

}

/**

This function adds local relocation into a list

@param aReloc - Instance of class ElfImportRelocation

@internalComponent

@released

*/

void ElfExecutable::AddToLocalRelocations(ElfRelocation* aReloc) {

	iLocalRelocations.Add((ElfLocalRelocation*)aReloc);

}

/**

This function records the version of an imported symbol

@param aReloc - Instance of class ElfImportRelocation

@internalComponent

@released

*/

void ElfExecutable::SetVersionRecord( ElfRelocation* aReloc ) {

	if( !aReloc )

		return;

	((ElfImportRelocation*)aReloc)->iVerRecord = &iVerInfo[ iVersionTbl[aReloc->iSymNdx]];

}

/**

This function validates the ELF file

@internalComponent

@released

*/

PLUINT32  ElfExecutable::ValidateElfFile() {

	/*Check if the ELF-Magic is correct*/

	if(!(iElfHeader->e_ident[EI_MAG0] == ELFMAG0) &&

		(iElfHeader->e_ident[EI_MAG1] == ELFMAG1) &&

		(iElfHeader->e_ident[EI_MAG2] == ELFMAG2) &&

		(iElfHeader->e_ident[EI_MAG3] == ELFMAG3) ) {

			throw ELFFormatError(ELFMAGICERROR, iParameterListInterface->ElfInput());

	}

	/*32-bit ELF file*/

	if(iElfHeader->e_ident[EI_CLASS] != ELFCLASS32) {

		throw ELFFormatError(ELFCLASSERROR, iParameterListInterface->ElfInput());

	}

	/* Check if the ELF file is in Little endian format*/

	if(iElfHeader->e_ident[EI_DATA] != ELFDATA2LSB) {

		throw ELFFormatError(ELFLEERROR, iParameterListInterface->ElfInput());

	}

	/* The ELF executable must be a DLL or an EXE*/

	if( iElfHeader->e_type != ET_EXEC && iElfHeader->e_type != ET_DYN) {

		throw ELFFormatError(ELFEXECUTABLEERROR, iParameterListInterface->ElfInput());

	}

	return 0;

}

/**

This function processes the dynamic table.

@internalComponent

@released

*/

PLUINT32  ElfExecutable::ProcessDynamicEntries(){

	PLUINT32 aIdx = 0;

	bool aSONameFound = false;

	bool aPltRelTypeSeen = false, aJmpRelSeen = false;

	list<PLUINT32>	aNeeded;

	Elf32_Dyn *aDyn = ELF_ENTRY_PTR(Elf32_Dyn, iElfHeader, iDynSegmentHdr->p_offset);

	while( aDyn[aIdx].d_tag != DT_NULL ) {

		switch (aDyn[aIdx].d_tag) {

		case DT_NEEDED:

			aNeeded.push_back( aDyn[aIdx].d_val );

			break;

		case DT_HASH:

			iHashTbl = ELF_ENTRY_PTR(Elf32_HashTable, iElfHeader, aDyn[aIdx].d_val);

			break;

		case DT_STRTAB:

			iStringTable = ELF_ENTRY_PTR(char, iElfHeader, aDyn[aIdx].d_val);

			break;

		case DT_SYMTAB:

			iElfDynSym = ELF_ENTRY_PTR(Elf32_Sym, iElfHeader, aDyn[aIdx].d_val);

			break;

		case DT_RELA:

			iRela = ELF_ENTRY_PTR(Elf32_Rela, iElfHeader, aDyn[aIdx].d_val);

			break;

		case DT_RELASZ:

			iRelaSize = aDyn[aIdx].d_val;

			break;

		case DT_RELAENT:

			iRelaEntSize = aDyn[aIdx].d_val;

			break;