// 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 <e32def.h>
#include <e32def_private.h>
#include <e32std.h>
#include <e32std_private.h>
#include "elftran.h"
#include <tools/elfdefs.h>
#include "elffile.h"
#include "elfdll.h"
#include "h_utl.h"
#include <string.h>
#include <stdlib.h>

TBool hadText, hadReloc = EFalse;

ELFFile::ELFFile() 
	: iFileName(0), iFileHandle(-1) , iElfFile(0),
	iHeapCommittedSize(0x1000), iHeapReservedSize(0x100000), iStackCommittedSize(0),
	iCodeSegmentHdr(0), iDataSegmentHdr(0), iDynamicSegmentHdr(0),
	iCodeSegmentIdx(0), iDataSegmentIdx(0),
	iDynamicSegmentIdx(0), iDllData(0), iCpu(ECpuUnknown)
	{}




ELFFile::~ELFFile()
//
// Destructor
//
	{

	delete [] iFileName;
	delete iElfFile;
	delete iDllData;
	}


TBool ELFFile::Init(const TText * const aFileName)
//
// Read the ELF file into memory
//
 	{

 	delete [] iFileName;	
	iFileName = new TText[strlen((const char *)aFileName)+1];
	strcpy ((char *)iFileName, (const char *)aFileName);

	TInt error = HFile::Open(iFileName, &iFileHandle);
	if (error!=0)
		return EFalse;

	TInt flength = HFile::GetLength(iFileHandle);

	iElfFile = (Elf32_Ehdr *)HMem::Alloc(0,flength);
	if (!iElfFile)
		{
		Print(EPeError,"Failed to allocate memory to read in file.\n");
		Close();
		return EFalse;
		}

	if (!HFile::Read(iFileHandle,iElfFile,flength))
		{
		Print(EPeError,"Unable to read file %s.\n",iFileName);
		Close();
		return EFalse;
		}

        Close();

	if (!IsValidFileHeader(iElfFile))
		{
		Print(EPeError,"Invalid file header.\n");
		return EFalse;
		}
	// we only support this....for the moment
	iCpu = ECpuArmV4;

	if (!InitHeaders()) return EFalse;
	
	if (!InitDllData()) return EFalse;

	iEntryPoint = iElfFile->e_entry;

	iCodeSize = GetCodeSize();
	iDataSize = GetDataSize();
	iBssSize = GetBssSize();

	iStackReservedSize = 0x2000;
	iStackCommittedSize = 0x2000;

 	iLinkedBase = iCodeSegmentHdr->p_vaddr;
	
	iImageIsDll = iDllData->ImageIsDll();

	return ETrue;
	}

char * ELFFile::CreateImportSection(TInt &aSize)
//
// get ELFDLLData to do it
//
	{
	TInt size;
	char * newSection = iDllData->CreateImportSection(size);
	aSize = size;
	return newSection;
	}

TUint ELFFile::GetExportTableOffset(void)
        {
	return iDllData->GetExportTableOffset();
	}

TBool ELFFile::InitHeaders(void)
        {
	TInt nphdrs = iElfFile->e_phnum;
	if (nphdrs)
	       {
	       // Find the dynamic segment
	       Elf32_Phdr * aPhdr = ELFADDR(Elf32_Phdr, iElfFile, iElfFile->e_phoff);
	       iPhdr = aPhdr;
	       for (TInt idx = 0; idx < nphdrs; idx++)
					{
					Elf32_Word ptype = aPhdr[idx].p_type;
					if (ptype == PT_DYNAMIC)
							{
							iDynamicSegmentHdr = &aPhdr[idx];
							iDynamicSegmentIdx = idx;
							}
      				else if (ptype == PT_LOAD && 
							 (aPhdr[idx].p_flags & (PF_X + PF_ARM_ENTRY)))
							{
							iCodeSegmentHdr = &aPhdr[idx];
							iCodeSegmentIdx = idx;
							}
      				else if (ptype == PT_LOAD && 
							 (aPhdr[idx].p_flags & (PF_W + PF_R)))
							{
							iDataSegmentHdr = &aPhdr[idx];
							iDataSegmentIdx = idx;
							}
					}
	       }
	
	// cache pointer to symbol table

	// Get section header table
	Elf32_Shdr * s = ELFADDR(Elf32_Shdr, iElfFile, iElfFile->e_shoff);
	// Index of section header for section header string table
	TInt stIdx = iElfFile->e_shstrndx;
	TInt symIdx = -1;
	// Section name string table
	char * stringtable = ELFADDR(char, iElfFile, s[stIdx].sh_offset);
	// the index at which we find '.symtab' is the index of the symtab section
	for (TInt idx = 0; idx < iElfFile->e_shnum; idx++)
	    {
		if (idx != stIdx)
		       {
		       if (!strcmp(&stringtable[s[idx].sh_name], ".symtab"))
			      {
			      symIdx = idx;
			      break;
			      }
		       }
		}
	if (symIdx == -1) return EFalse;

	// save section header table
	iSectionHeaderTable = s;
	// save the index
	iSymIdx = symIdx;	
	// here's the symbol table
	iSymTab = ELFADDR(Elf32_Sym, iElfFile, s[symIdx].sh_offset);
	return ETrue;
	}

TBool ELFFile::InitDllData(void)
	{
	if (!iDynamicSegmentHdr)
	       {
#if defined(_DEBUG)
	       Print(EWarning, "Image '%s' has no import/export data.\n", iFileName);
#endif
	       return ETrue;
	       }
	iDllData = new ELFDllData(this);
	if (!iDllData)
	       {
	       Print(EPeError, "Out of memory allocating DLL data\n");
	       return EFalse;
	       }

	Elf32_Dyn * dyn = ELFADDR(Elf32_Dyn, iElfFile, iDynamicSegmentHdr->p_offset);
	TInt idx = 0;
	TInt soNameOffset = 0;
	while(dyn[idx].d_tag != DT_NULL) // best to make it explicit
	       {
	       switch (dyn[idx].d_tag)
		      {
		      case DT_HASH:
			   iDllData->iHashTable = ELFADDR(Elf32_HashTable, dyn, dyn[idx].d_val);
			   break;
		      case DT_STRTAB:
			   iDllData->iDynStrTab = ELFADDR(char, dyn, dyn[idx].d_val);
			   break;
		      case DT_SYMTAB:
			   iDllData->iDynSymTab = ELFADDR(Elf32_Sym, dyn, dyn[idx].d_val);
			   break;
		      case DT_RELA:
			   iDllData->iRela = ELFADDR(Elf32_Rela, dyn, dyn[idx].d_val);
			   break;
		      case DT_RELASZ:
			   iDllData->iRelaSz = dyn[idx].d_val;
			   break;
		      case DT_RELAENT:
			   iDllData->iRelaSz = dyn[idx].d_val;
			   break;
		      case DT_STRSZ:
			   iDllData->iDynStrTabSize = dyn[idx].d_val;
			   break;
		      case DT_ARM_SYMTABSZ_21: //For RVCT2.1
			   //iDllData->iDynSymTabSize = dyn[idx].d_val;
		      case DT_ARM_SYMTABSZ:
			  /* This is same as DT_ARM_SYMTABSZ_21, but for RVCT 2.2
			   * The tag value has been changed for RVC2.2 from RVCT2.1.
			   * We just ignore this. i.e., we get the symbol table size
			   * from the nchain field of the hash table as noted in section
			   * 3.2.2.2 of the BPABI.
			   */
			   break;
		      case DT_SYMENT:
			   iDllData->iSymSize = dyn[idx].d_val;
			   break;
		      case DT_SONAME:
			   soNameOffset = dyn[idx].d_val;
			   break;
		      case DT_REL:
			   iDllData->iRel = ELFADDR(Elf32_Rel, dyn, dyn[idx].d_val);
			   break;
		      case DT_RELSZ:
			   iDllData->iRelSz = dyn[idx].d_val;
			   break;
		      case DT_RELENT:
			   iDllData->iRelEnt = dyn[idx].d_val;
			   break;
		      case DT_NEEDED:
			   iDllData->AddToDependency(dyn[idx].d_val);
			   break;
		      case DT_PLTRELSZ:
		      case DT_PLTGOT:
		      case DT_INIT:
		      case DT_FINI:
		      case DT_RPATH:
		      case DT_SYMBOLIC:
		      case DT_PLTREL:
		      case DT_DEBUG:
		      case DT_TEXTREL:
		      case DT_JMPREL:
		      case DT_BIND_NOW:
			   break;
		      default:
		           Print(EPeError,"Unrecognized Dyn Array tag in image '%s'.\n", iFileName);
			   return EFalse;
		      }
		      idx++;
	       }
	return iDllData->Init();
	}


void ELFFile::Close()
//
// close the ELF file
//
	{
	HFile::Close(iFileHandle);
	}



TInt ELFFile::NumberOfImports() const
//
// Count the total number of imports for this image
//
	{
	return iDllData->NumberOfImports();
	}

TInt ELFFile::NumberOfImportDlls() const
//
// Count the number of referenced Dlls
//
	{
	return iDllData->NumberOfImportDlls();
	}

TInt ELFFile::NumberOfExports() const
//
// Count the number of exported symbols
//
	{
	return iDllData->NumberOfExports();
	}

TInt ELFFile::NumberOfCodeRelocs() 
	{ 
	return iDllData->NumberOfCodeRelocs(); 
	}

TInt ELFFile::NumberOfDataRelocs() 
	{ 
	return iDllData->NumberOfDataRelocs(); 
	}

Elf32_Phdr * ELFFile::GetSegmentFromAddr(Elf32_Addr addr)
	{
	TInt nphdrs = iElfFile->e_phnum;
	for (TInt idx = 0; idx < nphdrs; idx++)
	        {
		// take advantage of unsignedness 
		if ((addr - iPhdr[idx].p_vaddr) < iPhdr[idx].p_memsz) return &iPhdr[idx];
		}
	return NULL;
	}


TInt ELFFile::NumberOfRelocs()
	{
	return iDllData->NumberOfRelocs();
	}

TUint16 ELFFile::GetRelocType(Elf32_Rel *aReloc)
    {
	// We work out the type by figuring out the segment of the reloc
	TInt segmentIdx = ELF32_R_SYM(aReloc->r_info);
	
	// check to see if its a reserved or special index.
	if ((!segmentIdx) || ((segmentIdx >= SHN_LORESERVE) && (segmentIdx <= SHN_HIRESERVE)))
		// up until now these have been treated as KInferredRelocType, so lets continue...
		return KInferredRelocType;
			
	// need to see if this section is executable or writable
	if (iPhdr[segmentIdx-1].p_flags & PF_X) 
		return KTextRelocType;
	if (iPhdr[segmentIdx-1].p_flags & PF_W) 
		return KDataRelocType;
	// perhaps we should error here.
	return KInferredRelocType;
	}

TBool ELFFile::GetRelocs(Elf32_Rel **aCodeRelocs, Elf32_Rel **aDataRelocs)
        {
	return iDllData->GetRelocs(aCodeRelocs, aDataRelocs);
	}

TUint ELFFile::GetCodeSize()
    {
	return iCodeSegmentHdr->p_filesz;
	}

TBool ELFFile::HasInitialisedData()
	{
	return iDataSegmentHdr != NULL && iDataSegmentHdr->p_filesz != 0;
	}

TUint ELFFile::GetDataSize()
    {
	return iDataSegmentHdr != NULL ? iDataSegmentHdr->p_filesz : 0;
	}

TBool ELFFile::HasBssData()
	{
	return iDataSegmentHdr != NULL && (iDataSegmentHdr->p_memsz - iDataSegmentHdr->p_filesz) != 0;
	}

TUint ELFFile::GetBssSize()
    {
	return iDataSegmentHdr != NULL ? iDataSegmentHdr->p_memsz - iDataSegmentHdr->p_filesz: 0;
	}






TBool ELFFile::IsValidFileHeader(Elf32_Ehdr * iElfFile)
 	{
        if (!(iElfFile->e_ident[EI_MAG0] == ELFMAG0 &&
	      iElfFile->e_ident[EI_MAG1] == ELFMAG1 &&
	      iElfFile->e_ident[EI_MAG2] == ELFMAG2 &&
	      iElfFile->e_ident[EI_MAG3] == ELFMAG3))
		{
                Print(EPeError,"Invalid ELF magic.\n");
		return EFalse;
		}

        if (iElfFile->e_ident[EI_CLASS] != ELFCLASS32)
		{
                Print(EPeError,"File is not a 32 bit object file.\n");
		return EFalse;
		}
        if (iElfFile->e_ident[EI_DATA] != ELFDATA2LSB)
		{
                Print(EPeError,"File data encoding is not Little Endian.\n");
		return EFalse;
		}

  	if (iElfFile->e_machine != EM_ARM)
		{
		Print(EPeError,"File does not target ARM/THUMB processors.\n");
		return EFalse;
		}

  	if (!(iElfFile->e_type == ET_EXEC || iElfFile->e_type == ET_DYN))
		{
		Print(EPeError,"File is neither an executable nor a shared object\n");
		return EFalse;
		}

	return ETrue;
	}


// Get details of the next import to fix-up in the current file. Fill in the name of the dll 
//it is imported from, the ordinal number and the address to write back to.
#define ORDINAL_DONE 0x40000000


// The following static functions are passed an array of PE files to operate on

Elf32_Sym * ELFFile::FindSymbol(const TText *aName)
    {
	Elf32_Shdr * s = ELFADDR(Elf32_Shdr, iElfFile, iElfFile->e_shoff);	
	TInt symIdx = iSymIdx;
	Elf32_Sym * sym = iSymTab;
	TInt nSyms = s[symIdx].sh_size / s[symIdx].sh_entsize;
	char * symStringtable = ELFADDR(char, iElfFile, s[s[symIdx].sh_link].sh_offset);
	for (TInt jdx = 0; jdx < nSyms; jdx++)
	    {
		if (!strcmp(&symStringtable[sym[jdx].st_name], (char *)aName)) 
			return &sym[jdx];
		}
	return (Elf32_Sym *)0;
    }

TBool ELFFile::SymbolPresent(TText *aName)
    {
	return (FindSymbol(aName) != 0);
    }

TBool ELFFile::GetExceptionIndexInfo(TUint32 &aOffset)
    {
    const TText * aBase = (TText *)".ARM.exidx$$Base";
    const TText * aLimit = (TText *)".ARM.exidx$$Limit";
	Elf32_Sym * exidxBase = FindSymbol(aBase);
	Elf32_Sym * exidxLimit = FindSymbol(aLimit);
	if (exidxBase && exidxLimit && (exidxLimit->st_value - exidxBase->st_value)) 
	    {
		const TText * aExceptionDescriptor = (TText *)"Symbian$$CPP$$Exception$$Descriptor";
		Elf32_Sym * aED = FindSymbol(aExceptionDescriptor);
		if (aED) 
			{
			// Set bottom bit so 0 in header slot means an old binary.
			// The decriptor is always aligned on a 4 byte boundary.
			aOffset = (aED->st_value - iLinkedBase) | 0x00000001;
			return ETrue;
			}
		else
			{
			Print(EPeError,"Executable has exception table but no exception descriptor\n");
			exit(666);
			}
		}
	return EFalse;
    }

TBool ELFFile::SetUpLookupTable()
{
	if(!iDllData->CreateSymLookupTable() ) {
		Print(EPeError,"Failed to create named symbol lookup information\n");
		return FALSE;
	}
	if(!iDllData->CreateDependency()){
		Print(EPeError,"Failed to create dependency ordering for named symbol lookup\n");
		return FALSE;
	}

	iDllData->SetExportSymInfo();
	return TRUE;
}

void ELFFile::GetExportSymInfoHeader(E32EpocExpSymInfoHdr& aSymInfoHdr)
{
	iDllData->GetExportSymInfoHeader(aSymInfoHdr);
}

void ELFFile::SetLookupTblBase(TInt aBaseOffset)
{
	iDllData->SetLookupTblBase(aBaseOffset);
}

TInt ELFFile::GetLookupTblSize()
{
	return iDllData->GetLookupTblSize();
}

TUint ELFFile::GetSymLookupSection(char* aBuff)
{
	return iDllData->GetSymLookupSection(aBuff);
}

