// 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 e32 image creation and dump for elf2e32 tool

// @internalComponent

// @released

// 

//

#include "pl_elfexecutable.h"

// get E32ImageHeader class...

#define INCLUDE_E32IMAGEHEADER_IMPLEMENTATION

#define RETURN_FAILURE(_r) return (fprintf(stderr, "line %d\n", __LINE__),_r)

//#define E32IMAGEHEADER_TRACE(_t) printf _t

#include "e32imagefile.h"

#include "pl_elfimportrelocation.h"

#include "pl_elflocalrelocation.h"

#include "pl_elfimports.h"

#include "elffilesupplied.h"

#include "pl_dllsymbol.h"

#include "h_ver.h"

#include "checksum.h"

#include "errorhandler.h"

#include <string>

#include <vector>

#include <cassert>

#include <iostream>

#ifndef __LINUX__ 

    #include <io.h>

#else

    #include <time.h>

#endif 

#include <time.h>

#include <stdio.h>

using namespace std;

template <class T> inline T Align(T v, size_t s)

{

	unsigned int inc = s-1;

	unsigned int mask = ~inc;

	unsigned int val = (unsigned int)v;

	unsigned int res = (val+inc) & mask;

	return (T)res;

}

// Need a default constructor for TVersion, but don't want all the other stuff in h_utl.cpp

/**

Default constructor for TVersion class.

@internalComponent

@released

*/

TVersion::TVersion(){}

/**

Constructor for TVersion class.

@internalComponent

@released

*/

TVersion::TVersion(TInt aMajor, TInt aMinor, TInt aBuild): 

	iMajor((TInt8)aMajor), iMinor((TInt8)aMinor), iBuild((TInt16)aBuild)

{

}

/**

Constructor for E32ImageChunkDesc class.

@internalComponent

@released

*/

E32ImageChunkDesc::E32ImageChunkDesc(char * aData, size_t aSize, size_t aOffset, char * aDoc):

	iData(aData), iSize(aSize), iOffset(aOffset), iDoc(aDoc)

{

}

/**

Destructor for E32ImageChunkDesc class.

@internalComponent

@released

*/

E32ImageChunkDesc::~E32ImageChunkDesc()

{

}

/**

This function writes its data in the buffer.

@param aPlace - a location in the buffer

@internalComponent

@released

*/

void E32ImageChunkDesc::Write(char * aPlace)

{

	memcpy(aPlace+iOffset, iData, iSize);

}

/**

Constructor for E32ImageChunks class.

@internalComponent

@released

*/

E32ImageChunks::E32ImageChunks(): 

	iOffset(0)

{

}

/**

Destructor for E32ImageChunks class.

@internalComponent

@released

*/

E32ImageChunks::~E32ImageChunks()

{	

 	if(iChunks.size())

 	{

 		ChunkList::iterator aItr = iChunks.begin();

 		ChunkList::iterator last = iChunks.end();

 		E32ImageChunkDesc *temp;

 		while( aItr != last)

 		{

 			temp = *aItr;

 			aItr++;

 			delete temp;

 		}

 	}

}

/**

This function creates and adds a chunk into a list.

@param aData - input buffer

@param asize - size of the input buffer

@param aOffset - byte offset of this chunk from the 1 byte in e32 image file.

@param aDoc - name of the chunk

@internalComponent

@released

*/

void E32ImageChunks::AddChunk(char * aData, size_t aSize, size_t aOffset, char * aDoc)

{

	E32ImageChunkDesc * aChunk = new E32ImageChunkDesc(aData, aSize, aOffset, aDoc);

	iChunks.push_back(aChunk);

	iOffset += Align(aSize, sizeof(TUint32));

}

/**

This function returns the list of chunks.

@internalComponent

@released

*/

E32ImageChunks::ChunkList & E32ImageChunks::GetChunks()

{

	return iChunks;

}

/**

This function returns the current offset pointing to the last chunk that

was added into the list of chunks.

@internalComponent

@released

*/

size_t E32ImageChunks::GetOffset()

{

	return iOffset;

}

/**

This function sets the current offset pointing to the last chunk that 

was added into the list of chunks.

@internalComponent

@released

*/

void E32ImageChunks::SetOffset(size_t aOffset)

{

	iOffset = aOffset;

}

/**

Constructor for E32ImageFile class.

@internalComponent

@released

*/

E32ImageFile::E32ImageFile(const char * aFileName, ElfExecutable * aExecutable, ElfFileSupplied *aUseCase) :

	iFileName(aFileName), 

	iE32Image(0),

	iExportBitMap(0),

	iElfExecutable(aExecutable), 

	iData(0),

	iUseCase(aUseCase),

	iHdr(0),

	iHdrSize(sizeof(E32ImageHeaderV)),

	iImportSection(0), 

	iImportSectionSize(0),

	iCodeRelocs(0), 

	iCodeRelocsSize(0),

	iDataRelocs(0), 

	iDataRelocsSize(0),

	iExportOffset(0),

	iLayoutDone(false), 

	iMissingExports(0),

	iSymNameOffset(0)

{

}

/**

This function generates the E32 image.

@internalComponent

@released

*/

void E32ImageFile::GenerateE32Image()

{

	if( iUseCase->GetNamedSymLookup() ){

		ProcessSymbolInfo();

	}

	ProcessImports();

	ProcessRelocations();

	ConstructImage();

}

/**

This function processes the import map by looking into the dso files

from which the symbols are imported. It also fetches the ordinal numbers

for the corresponding symbols.

@internalComponent

@released

*/

void E32ImageFile::ProcessImports()

{

	string aStrTab;

	vector<int> aStrTabOffsets;

	int aNumDlls = 0;

	int aNumImports = 0;

	bool aNamedLookup = iUseCase->GetNamedSymLookup();

	TUint aImportTabEntryPos = 0;

	ElfImports::ImportMap aImportMap = iElfExecutable->GetImports();

	ElfImports::ImportMap::iterator p;

	// First set up the string table and record offsets into string table of each 

	// LinkAs name.

	for (p = aImportMap.begin(); p != aImportMap.end(); p++)

	{

		ElfImports::RelocationList & aImports = (*p).second;

		char* aLinkAs = aImports[0]->iVerRecord->iLinkAs;

		aStrTabOffsets.push_back(aStrTab.size()); // 

		string s = aLinkAs;

		aStrTab.insert(aStrTab.end(),s.begin(),s.end());

		aStrTab.insert(aStrTab.end(),0);

		aNumDlls++;

		aNumImports += aImports.size();

	}

	iNumDlls = aNumDlls;

	iNumImports = aNumImports;

	// Now we can figure out the size of everything

	size_t aImportSectionSize = sizeof(E32ImportSection) + 

								(sizeof(E32ImportBlock) * aNumDlls) +

								(sizeof(unsigned int) * aNumImports);

	vector<Elf32_Word> aImportSection;

	// This is the 'E32ImportSection' header - fill with 0 for the moment

	aImportSection.push_back(0);

	if( aNamedLookup ) {

		// These are the 0th ordinals imported into the import table, one

		// entry for each DLL.

		aImportSectionSize += (sizeof(unsigned int) * aNumDlls);

	}

	// Now fill in the E32ImportBlocks

	int idx = 0;

	char * aDsoName;

	for (p = aImportMap.begin(); p != aImportMap.end(); p++, idx++)

	{

		ElfImports::RelocationList & aImports = (*p).second;

		aDsoName = aImports[0]->iVerRecord->iSOName;

		//const char * aDSO = FindDSO((*p).first);

		const char * aDSO = FindDSO(aDsoName);

		aImportSection.push_back(aStrTabOffsets[idx] + aImportSectionSize); 

		int nImports = aImports.size();

		// Take the additional 0th ordinal import into account

		if( aNamedLookup )

			nImports++;

		aImportSection.push_back(nImports);

		size_t aSize;

		Elf32_Ehdr * aElfFile = 0;

		ReadInputELFFile(aDSO, aSize, aElfFile);

		ElfExecutable aElfExecutable(NULL);//(aElfFile, aSize);

		aElfExecutable.ProcessElfFile(aElfFile);

		ElfImports::RelocationList::iterator q;

		for (q = aImports.begin(); q != aImports.end(); q++)

		{

			ElfImportRelocation * aReloc = *q;

			char * aSymName = iElfExecutable->GetSymbolName(aReloc->iSymNdx);

			unsigned int aOrdinal = aElfExecutable.GetSymbolOrdinal(aSymName);

			//check the reloc refers to Code Segment

			try

			{

				if (iElfExecutable->SegmentType(aReloc->iAddr) != ESegmentRO)

				{

					throw ImportRelocationError(ILLEGALEXPORTFROMDATASEGMENT, aSymName, iElfExecutable->iParameterListInterface->ElfInput());

				}

			}

			/**This catch block introduced here is to avoid deleting partially constructed object(s).

			Otherwise global catch block will delete the partially constructed object(s) and the tool will crash.

			*/

			catch(ErrorHandler& aError)

			{

				aError.Report();

				exit(EXIT_FAILURE);

			}

			Elf32_Word aRelocOffset = iElfExecutable->GetRelocationOffset(aReloc);

			aImportSection.push_back(aRelocOffset);

			Elf32_Word * aRelocPlace = iElfExecutable->GetRelocationPlace(aReloc);

			if (aOrdinal > 0xFFFF)

			{

			}

			if (aReloc->iAddend > 0xFFFF)

			{

			}

			* aRelocPlace = (aReloc->iAddend<<16) | aOrdinal;

		}

		if( aNamedLookup ) {

			aImportTabEntryPos = aImportSection.size();

			// Keep track of the location of the entry

			iImportTabLocations.push_back(aImportTabEntryPos);

			// Put the entry as 0 now, which shall be updated 

			aImportSection.push_back(0);

		}

		delete [] ((char*)aElfFile);

	}

	assert(aImportSectionSize == aImportSection.size() * sizeof(Elf32_Word));

	size_t aTotalSize = Align(aImportSectionSize + aStrTab.size(), sizeof(Elf32_Word));

	// Fill in the section header now we have the correct value.

	aImportSection[0] = aTotalSize;

	// Now construct the unified section

	iImportSectionSize = aTotalSize;

	iImportSection = (uint32 *)new char[aTotalSize];

	memset(iImportSection, 0, aTotalSize);

	memcpy(iImportSection, aImportSection.begin(), aImportSectionSize);

	char * strTab = ((char *)iImportSection) + aImportSectionSize;

	memcpy(strTab, aStrTab.data(), aStrTab.size());

}

/**

This function checks if a DSO file exists.

@param aPath - DSO file name.

@internalComponent

@released

*/

static bool ProbePath(string & aPath)

{

	ifstream aInput;

	const char * p = aPath.c_str();

	aInput.open(p);

	if (aInput.is_open())

	{

		aInput.close();

		return true;

	}

	else

	{

		return false;

	}

}

/**

This function allocates space for a DSO file name.

@param aPath - DSO file name

@internalComponent

@released

*/

const char * AllocatePath(string & aPath)

{

	const char * p = aPath.c_str();

	size_t len = aPath.size();

	char * result = new char[len+1];

	strcpy(result, p);

	return (const char *)result;

}

/**

This function searches for a DSO in the libpath specified.

@param aName - DSO file name

@internalComponent

@released

*/

const char * E32ImageFile::FindDSO(const char * aName)

{

	string aDSOName(aName);

	string aDSOPath(aName);

	const char *aNewDsoName;

	if (ProbePath(aDSOName))

	{

		aNewDsoName = AllocatePath(aDSOName);

		cleanupStack.push_back((char*)aNewDsoName);

		return aNewDsoName;

	}

	ParameterListInterface::LibSearchPaths & paths = iUseCase->GetLibSearchPaths();

	ParameterListInterface::LibSearchPaths::iterator p = paths.begin();

	for (; p != paths.end(); p++)

	{

		string path(*p);

		char dir = iUseCase->GetDirectorySeparator();

		aDSOPath.erase();

		aDSOPath.insert(aDSOPath.end(), path.begin(), path.end());

		aDSOPath.insert(aDSOPath.end(), dir);

		aDSOPath.insert(aDSOPath.end(), aDSOName.begin(), aDSOName.end());

		if (ProbePath(aDSOPath))

		{

			aNewDsoName = AllocatePath(aDSOPath);

			cleanupStack.push_back((char*)aNewDsoName);

			return aNewDsoName;

		}

	}

	throw ELFFileError(DSONOTFOUNDERROR,(char*)aName);

}

void E32ImageFile::ReadInputELFFile(const char * aName, size_t & aFileSize, Elf32_Ehdr * & aELFFile )

{

	ifstream aInput;

	aInput.open(aName, ifstream::binary|ifstream::in);

	if (aInput.is_open()) 

	{

		aInput.seekg(0,ios::end);

		aFileSize = (unsigned int) aInput.tellg();

		aInput.seekg(0,ios::beg);

		aELFFile = (Elf32_Ehdr *)new char [aFileSize];

		aInput.read((char *)aELFFile, aFileSize);

		aInput.close();

	} 

	else

	{

		throw FileError(FILEOPENERROR,(char*)aName);

	}

}

/**

This function processes relocations.

@internalComponent

@released

*/

void E32ImageFile::ProcessRelocations()

{

	ProcessCodeRelocations();

	ProcessDataRelocations();

}

/**

This function processes Code relocations.

@internalComponent

@released

*/

void E32ImageFile::ProcessCodeRelocations()

{

	CreateRelocations(iElfExecutable->GetCodeRelocations(), iCodeRelocs, iCodeRelocsSize);

}

/**

This function processes Data relocations.

@internalComponent

@released

*/

void E32ImageFile::ProcessDataRelocations()

{

	CreateRelocations(iElfExecutable->GetDataRelocations(), iDataRelocs, iDataRelocsSize);

}

/**

This function creates Code and Data relocations from the corresponding

ELF form to E32 form.

@internalComponent

@released

*/

void E32ImageFile::CreateRelocations(ElfRelocations::RelocationList & aRelocList, char * & aRelocs, size_t & aRelocsSize)

{

	size_t rsize = RelocationsSize(aRelocList);

	if (rsize)

	{

		aRelocsSize = Align(rsize + sizeof(E32RelocSection), sizeof(uint32));

		uint32 aBase = (*aRelocList.begin())->iSegment->p_vaddr;

		//add for cleanup to be done later..

		cleanupStack.push_back(aRelocs);

		aRelocs =	new char [aRelocsSize];

		memset(aRelocs, 0, aRelocsSize);

		E32RelocSection * aRelocSection = (E32RelocSection * )aRelocs;

		uint16 * data = (uint16 *)(aRelocSection + 1);

		E32RelocPageDesc * startofblock = (E32RelocPageDesc *)data;

		int page = -1;

		int pagesize = sizeof(E32RelocPageDesc);

		ElfRelocations::RelocationList::iterator r;

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