// 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 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:
// Implementation of the Class ElfExecutable for the elf2e32 tool
// @internalComponent
// @released
// 
//

#if !defined(_PL_ELFEXECUTABLE_H_)
#define _PL_ELFEXECUTABLE_H_

#include "pl_common.h"
#include <list>
#include <hash_map>
#include "pl_elfimports.h"
#include "pl_elfrelocations.h"
#include "pl_elfexports.h"

using std::list;
using std::hash_map;

class DllSymbol;
class Symbol;
class ElfRelocations;
class ElfExports;
class ParameterListInterface;
class ElfLocalRelocation;
/**
This class is for ELF object carrying the elf header, sections, segments.
@internalComponent
@released
*/
class ElfExecutable
{

public:
	ElfExecutable(ParameterListInterface *aParameterListInterface);
	virtual ~ElfExecutable();
	
	PLUINT32 ProcessElfFile(Elf32_Ehdr *aElfHdr);
	void DumpElfFile(char* aFile);

	PLUINT32 ProcessSymbols();
	ElfImports::ImportMap GetImports();
	ElfExports* GetExports();
	DllSymbol* AddToExports(char* aDll, DllSymbol* aSymbol);
	void AddToImports(ElfImportRelocation* aReloc);
	PLUINT32 AddToRelocations(ElfRelocation* aReloc);
	void AddToLocalRelocations(ElfRelocation* aReloc);
	void ProcessVerInfo();

	Elf32_Sym* FindSymbol(char* aSymName);

	PLUINT32 GetSymbolOrdinal( char* aSymName);
	PLUINT32 GetSymbolOrdinal( Elf32_Sym* );
	char* GetSymbolName( PLUINT32 aSymIdx);
	Elf32_Word GetRelocationOffset(ElfRelocation * aReloc);
	Elf32_Word *GetRelocationPlace(ElfRelocation * aReloc);

	Elf32_Word GetROBase();
	Elf32_Word GetRWBase();
	size_t GetROSize();
	size_t GetRWSize();
	size_t GetBssSize();
	MemAddr GetRawROSegment();
	MemAddr GetRawRWSegment();
	Elf32_Word EntryPointOffset();
	ESegmentType SegmentType(Elf32_Addr aAddr);
	Elf32_Phdr* Segment(Elf32_Addr aAddr);
	ElfRelocations::RelocationList & GetCodeRelocations();
	ElfRelocations::RelocationList & GetDataRelocations();
	ElfRelocations& GetLocalRelocations();
	bool ExeceptionsPresentP();
	ElfExports::ExportList& GetExportsInOrdinalOrder();
	Elf32_Sym* LookupStaticSymbol(char * aName);
public:
	/**
	 * The elf header pointer which points to the base of the file records
	 */
	Elf32_Ehdr	*iElfHeader;
	Elf32_Addr	iEntryPoint;
	/**
	 * The dynamic program header of the elf file
	 */
	Elf32_Phdr	*iProgHeader;

	PLUINT32	iSONameOffset;
	char		*iSOName;
	/**
	 * This member points to the base of the section header table.
	 */
	Elf32_Shdr		*iSections;
	Elf32_Verdef	*iVersionDef;
	PLUINT32		iVerDefCount;
	Elf32_Verneed	*iVersionNeed;
	PLUINT32		iVerNeedCount;
	Elf32_Half		*iVersionTbl;
	PLUINT32		iRelSize;
	PLUINT32		iRelEntSize;
	PLUINT32		iNRelocs;
	Elf32_Rel		*iRel;
	PLUINT32		iRelaSize;
	PLUINT32		iRelaEntSize;
	Elf32_Rela		*iRela;
	char			*iStringTable;
	char			*iSectionHdrStrTbl;

	list<char*>		iNeeded;
	VersionInfo		*iVerInfo;
	/**
	 * The dynamic symbol array.
	 */
	Elf32_Sym		*iElfDynSym;//The ELF symbol
	hash_map<PLUINT32, DllSymbol*>	iSymbolTable; //The representation

	/**
	 * The static symbol table.
	 */
	Elf32_Sym *iSymTab; 
	char *iStrTab;
	Elf32_Sym *iLim;

	PLUINT32		iNSymbols;
	Elf32_HashTable	*iHashTbl;
	Elf32_Phdr		*iDynSegmentHdr;
	Elf32_Phdr		*iDataSegmentHdr;
	MemAddr			iDataSegment;
	size_t			iDataSegmentSize;
	PLUINT32		iDataSegmentIdx;
	Elf32_Phdr		*iCodeSegmentHdr;
	MemAddr			iCodeSegment;
	size_t			iCodeSegmentSize;
	PLUINT32		iCodeSegmentIdx;
	ElfImports		iImports;
	ElfExports		*iExports;
	ElfRelocations  iLocalRelocations;
	ParameterListInterface *iParameterListInterface;
	PLUINT32		iPltGotBase;
	PLUINT32		iPltGotLimit;
	PLUINT32		iStrTabSz;
	PLUINT32		iSymEntSz;
	Elf32_Word		*iPltGot;
	PLUINT32		iPltRelType;
	Elf32_Rel		*iPltRel;
	PLUINT32		iPltRelaSz;
	Elf32_Rela		*iPltRela;
	PLUINT32		iPltRelSz;
	PLUINT32		iJmpRelOffset;

	PLUINT32	ValidateElfFile();
	PLUINT32	ProcessDynamicEntries();
	void	ProcessRelocations();
	template <class T> void	ProcessRelocations(T *aElfRel, size_t aSize);

	VersionInfo* GetVersionInfo(PLUINT32 aIndex);
	char*		SymbolDefinedInDll(PLUINT32 aSymbolIndex);
	void SetVersionRecord( ElfRelocation* aReloc );

/** This function says if the Symbol is a global symbol
@return It returns true if the Symbol is a global one.
@param aSym The reference to the Symbol whose attribute is being checked
*/
bool GlobalSymbol(Elf32_Sym* aSym);

/** This function says if the Symbol is Exported
@return It returns true if the Symbol is an exported one.
@param aSym The reference to the Symbol whose attribute is being checked
*/
bool ExportedSymbol(Elf32_Sym* aSym);

/** This function says if the Symbol is Imported
@return It returns true if the Symbol is an imported one.
@param aSym The reference to the Symbol whose attribute is being checked
*/
bool ImportedSymbol(Elf32_Sym* aSym);

/** This function says if the Symbol is a Code Symbol
@return It returns true if the Symbol is of Code type.
@param aSym The reference to the Symbol whose attribute is being checked
*/
bool FunctionSymbol(Elf32_Sym* aSym);

/** This function says if the Symbol is a Data Symbol
@return It returns true if the Symbol is of Data type.
@param aSym The reference to the Symbol whose attribute is being checked
*/
bool DataSymbol(Elf32_Sym* aSym);

/** This function says if the Symbol is Defined
@return It returns true if the Symbol is defined.
@param aSym The reference to the Symbol whose attribute is being checked
*/
bool DefinedSymbol(Elf32_Sym* aSym);

/** This function says if the Symbol has a default Visibility
@return It returns true if the Symbol has a default Visibility
@param aSym The reference to the Symbol whose attribute is being checked
*/
bool VisibleSymbol(Elf32_Sym* aSym);

/** This function finds the segment in which this address belongs
@return the segment type
@param aAddr The address within the executable
*/

Elf32_Word Addend(Elf32_Rel* aRel);
Elf32_Word Addend(Elf32_Rela* aRel);

char* SymbolFromDSO(PLUINT32  aSymbolIndex);
Elf32_Word* GetFixupLocation(ElfLocalRelocation* aReloc, Elf32_Addr aPlace);
ESegmentType Segment(Elf32_Sym *aSym);
Elf32_Phdr* SegmentFromAbs(Elf32_Addr aAddr);
Elf32_Phdr* Segment(ESegmentType aType);

/** This function processes the linker generated Veneer symbols and
 *  creates a relocation entry.
 */
void ProcessVeneers();
/** This function processes the ELF file to find the static symbol table.
*/
void FindStaticSymbolTable();
/** This function finds the .comment section
@return the pointer to the comment section
*/
char* FindCommentSection();
/** This function finds the value at the address passed in
@return the value at the address passed in
@param aAddr The address within the executable
*/
Elf32_Word FindValueAtLoc(Elf32_Addr aOffset);
};




#endif // !defined(_PL_ELFEXECUTABLE_H_)
