/*

* Copyright (c) 1996-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 <e32std.h>

#include <e32std_private.h>

#include <e32uid.h>

#include "h_utl.h"

#include <string.h>

#include <stdlib.h>

#include <iomanip> 

#include "r_global.h"

#include "r_obey.h"

#include "r_rom.h"

#include "r_dir.h"

#include "patchdataprocessor.h"

#include "memmap.h"

#include "byte_pair.h"

#include "symbolgenerator.h"

const TInt KSpareExports=16;

extern TInt gThreadNum;

extern string gDepInfoFile;

extern TBool gGenDepGraph;

TUint32 DeflateCompressCheck(char *bytes,TInt size,ostream &os);

void DeflateCompress(char *bytes,TInt size,ostream &os);

void InflateUnCompress(unsigned char* source, int sourcesize,unsigned char* dest, int destsize);

EntryQueue* LoadImageWorker::m_queue = NULL;

TInt LoadImageWorker::m_errors = 0;

TMemModel LoadImageWorker::m_memmodel;

boost::mutex LoadImageWorker::m_mutex;

LoadImageWorker::LoadImageWorker(EntryQueue* aQueue, TMemModel aMemModel)

	{

	m_queue = aQueue;

	m_memmodel = aMemModel;

	}

void LoadImageWorker::operator()()

	{

	while(1)

		{

		m_mutex.lock();

		if(m_queue->size() > 0)

			{

			TRomBuilderEntry * current = m_queue->front();

			m_queue->pop();

			m_mutex.unlock();

			TInt err = current->OpenImageFile();

			m_mutex.lock();

			err = current->GetImageFileInfo(err);

			m_mutex.unlock();

			if(err)

				{

				m_mutex.lock();

				++m_errors;

				m_mutex.unlock();

				continue;

				}

			if(current->iOverrideFlags&KOverrideAddress || current->iHdr->iFlags & KImageFixedAddressExe)

				{

				if(m_memmodel != E_MM_Multiple && m_memmodel != E_MM_Flexible &&  !current->IsDll())

					current->iRomImageFlags |=KRomImageFlagFixedAddressExe;

				}

			if(gPagedRom)

				{

				if(current->iHdr->iFlags&KImageCodePaged)

					{

					current->iRomImageFlags&=~KRomImageFlagCodeUnpaged;

					current->iRomImageFlags|=KRomImageFlagCodePaged;

					}

				if(current->iHdr->iFlags&KImageCodeUnpaged)

					{

					current->iRomImageFlags|=KRomImageFlagCodeUnpaged;

					current->iRomImageFlags&=~KRomImageFlagCodePaged;

					}

				}

			if(current->iHdr->iFlags&KImageDataPaged)

				{

				current->iRomImageFlags&=~KRomImageFlagDataUnpaged;

				current->iRomImageFlags|=KRomImageFlagDataPaged;

				}

			if(current->iHdr->iFlags&KImageDataUnpaged)

				{

				current->iRomImageFlags|=KRomImageFlagDataUnpaged;

				current->iRomImageFlags&=~KRomImageFlagDataPaged;

				}

			if(current->iHdr->iFlags&KImageDebuggable)

				{

				current->iRomImageFlags|=KRomImageDebuggable;

				}

				else

				{

				current->iRomImageFlags&=~KRomImageDebuggable;

				}

			}

			else

			{

			m_mutex.unlock();

			break;

			}

		}

	}

E32Rom* CompressPageWorker::m_rom = NULL;

TInt CompressPageWorker::m_nextpage = 0;

TInt CompressPageWorker::m_totalpages = 0;

TInt CompressPageWorker::m_pagesize = 0;

boost::mutex CompressPageWorker::m_mutex;

TInt CompressPageWorker::m_error = 0;

CompressPageWorker::CompressPageWorker(E32Rom* aRom, TInt aPageSize, TInt aTotalPages, TInt aNextPage)

	{

	m_rom = aRom;

	m_pagesize = aPageSize;

	m_totalpages = aTotalPages;

	m_nextpage = aNextPage;

	}

void CompressPageWorker::operator()()

	{

	SRomPageInfo* pPageBase = (SRomPageInfo*)((TInt)m_rom->iHeader + m_rom->iHeader->iRomPageIndex);

	CBytePair bpe;

	while(1)

		{

		m_mutex.lock();

		TInt currentPageIndex = m_nextpage++;

		m_mutex.unlock();

		if(currentPageIndex < m_totalpages)

			{

			TInt inOffset = m_pagesize * currentPageIndex;

			TUint8 attrib = (TUint8)SRomPageInfo::EPageable;

			SRomPageInfo info ={ (TUint32)inOffset, (TUint16)m_pagesize, (TUint8)SRomPageInfo::EBytePair, attrib };

			TUint8* in = (TUint8*) m_rom->iHeader + inOffset;

			TUint8* out = in;

			TInt outSize = BytePairCompress(out, in, m_pagesize, &bpe);

			if(outSize == KErrTooBig)

				{

				info.iCompressionType = SRomPageInfo::ENoCompression;

				memcpy(out, in, m_pagesize);

				outSize = m_pagesize;

				}

				if(outSize < 0 )

					{

					m_mutex.lock();

					m_error = outSize;

					m_mutex.unlock();

					break;

					}

				info.iDataSize = (TUint16) outSize;

				*(pPageBase + currentPageIndex) = info;

				if((currentPageIndex & 255) == 255)

					{

					m_mutex.lock();

					Print(EAlways, ".\n");

					m_mutex.unlock();

					}

				}

			else

			{

			break;

			}

		}

	}

////////////////////////////////////////////////////////////////////////

TAddressRange::TAddressRange() 

	: iImagePtr(0), iImageAddr(0), iRunAddr(0), iSize(0) 

	{

	}

void TAddressRange::Append(TAddressRange& aRange)

	{ 

	if(aRange.iSize) 

		{ 

		aRange.iImagePtr = iImagePtr;

		aRange.iImageAddr = iImageAddr;

		aRange.iRunAddr = iRunAddr;

		Extend(aRange.iSize); 

		} 

	}

void TAddressRange::Move(TInt aOffset) 

	{ 

	iImagePtr = static_cast<char*>(iImagePtr) + aOffset; 

	iImageAddr += aOffset; 

	iRunAddr += aOffset;

	}

void TAddressRange::Extend(TInt aOffset) 

	{ 

	Move(aOffset);

	iSize += aOffset; 

	}

////////////////////////////////////////////////////////////////////////

inline TUint32 AlignData(TUint32 anAddr)

	{

	return ((anAddr+0x0f)&~0x0f);

	}

TUint32 E32Rom::AlignToPage(TUint32 anAddr)

	{

	TUint a=(TUint)iObey->iPageSize-1;

	return ((anAddr+a)&~a);

	}

/*

Allocate virtual memory for static data in rom.

@param aAddr Base address of last allocated memory.

@param aSize Size of memory to allocate.

@return Address allocated. This is below aAddr.

*/

TUint32 E32Rom::AllocVirtual(TUint32 aAddr,TUint aSize)

	{

	TInt align = iObey->iVirtualAllocSize;

	if(align<0)

		{

		align = -align; // get correct sign

		// -ve align means also align to next power-of-two >= aSize...

		while(aSize>(TUint)align)

			align <<=1;

		}

	TUint mask = (TUint)align-1;

	aSize = (aSize+mask)&~mask; // round up

	aAddr &= ~mask; // round down

	return aAddr-aSize;

	}

TUint32 E32Rom::AlignToChunk(TUint32 anAddr)

	{

	TUint a=(TUint)iObey->iChunkSize-1;

	return ((anAddr+a)&~a);

	}

COrderedFileList::COrderedFileList(TInt aMaxFiles)

	: iCount(0), iMaxFiles(aMaxFiles), iOrderedFiles(NULL)

	{}

COrderedFileList::~COrderedFileList()

	{

	iCount=0;

	if(iOrderedFiles)

		delete[] iOrderedFiles;

	}

COrderedFileList* COrderedFileList::New(TInt aMaxFiles)

	{

	COrderedFileList *pL=new COrderedFileList(aMaxFiles);

	pL->iOrderedFiles=new TRomBuilderEntry*[aMaxFiles];

	return pL;

	}

void COrderedFileList::Add(TRomBuilderEntry* anEntry)

	{

	// note: this routine assumes that the set of kernel-mode files

	// (primary/extension/device) required by a given variant is linearly ordered by <=

	// e.g. can't have three variants {A,B,V1} {A,B,C,V2} {A,C,V3} because B and C

	// are unordered with respect to <=, since neither of

	// {n | Vn requires B} and {n | Vn requires C} is a subset of the other.

	// In a case like this, ROMBUILD may fail to resolve the addresses of some global data

	THardwareVariant& v=anEntry->iHardwareVariant;

	TInt i=0;

	while(i<iCount && v<=iOrderedFiles[i]->iHardwareVariant) i++;

	TInt j=iCount;

	while(j>i)

		{

		iOrderedFiles[j]=iOrderedFiles[j-1];

		j--;

		}

	iOrderedFiles[i]=anEntry;

	iCount++;

	}

void GetFileNameAndUid(char *aDllName, TUid &aDllUid, char *aExportName)

	{	

	strcpy(aDllName, aExportName);

	aDllUid=KNullUid;

	TInt start;

	for (start=0; start<(TInt)strlen(aExportName) && aExportName[start]!='['; start++)

		;

	if (start==(TInt)strlen(aExportName))

		start=KErrNotFound;

	TInt end=strlen(aExportName)-1;

	while (end>=0)

		{

		if (aExportName[end]==']')

			break;

		--end;

		}

	if (end<0)

		end=KErrNotFound;

	if ((start!=KErrNotFound) && (end!=KErrNotFound) && (end>start))

		{

		// Importing from DLL with Uid

		char uidStr[0x100];

		strcpy(uidStr, "0x");

		strncat(uidStr, aExportName+start+1, end-start-1); 

		if (IsValidNumber(uidStr)){

			TUint32 u = 0;

			Val(u,uidStr);

			aDllUid=TUid::Uid(u);

			char *dot=aExportName+strlen(aExportName)-1;

			while (dot>=aExportName)

				{

				if (*dot=='.')

					break;

				dot--;

				}

			if (dot<aExportName) // no dot

				aDllName[start]=0;

			else

				{

				aDllName[start]=0;

				strcat(aDllName, dot);

				}

			}

		}

	}

E32Rom::E32Rom(CObeyFile *aObey) {

	iSize=sizeof(TRomLoaderHeader)+aObey->iRomSize;

	iObey=aObey;

	iPeFiles=NULL;

	iSymGen = NULL ;

	if(gLowMem)

	{

		iImageMap = new Memmap();

		if(iImageMap == NULL)

		{

			iSize = 0;

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

		}

		else

		{

			iImageMap->SetMaxMapSize(iSize);

			if(iImageMap->CreateMemoryMap(0, 0xff) == EFalse)

			{

				iSize = 0;

				Print(EError, "Failed to create image map object");

				iImageMap->CloseMemoryMap(ETrue);

				delete iImageMap;

				iImageMap = NULL;

			}

			else

			{

				iData = iImageMap->GetMemoryMapPointer();

			}

		}

	}

	else

	{

		iData=new char [iSize];

		if (iData==NULL)

			{

			iSize=0;

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

			}

		HMem::Set(iData, 0xff, iSize);

	}

	iHeader=(TRomHeader *)(iData+sizeof(TRomLoaderHeader));

	iExtensionRomHeader=NULL;

	iLoaderHeader=(TRomLoaderHeader *)iData;

	iSectionPtr=(char *)iHeader+aObey->iSectionStart-aObey->iRomLinearBase+sizeof(TRomSectionHeader);

	TheRomHeader=(ImpTRomHeader *)iHeader;

	TheRomMem=(TUint32)iHeader;

	iNextDataChunkBase=aObey->iKernDataRunAddress;

	iTotalSvDataSize=0;

	iNextDllDataAddr=aObey->iDllDataTop;

	iPrevPrimaryAddress=NULL;

	iPrevVariantAddress=NULL;

	iVariantFileLists=NULL;

	iImportsFixedUp=0;

	iBranchesFixedUp=0;

	iVtableEntriesFixedUp=0;

	iOverhead=0;

	}

E32Rom::~E32Rom() {

	if(iSymGen){		

		delete iSymGen;

		iSymGen = NULL ;

	}

	if(gLowMem)

	{

		iImageMap->CloseMemoryMap(ETrue);

		delete iImageMap;

	}

	else

		delete iData;

	delete [] iPeFiles;

	if (iVariantFileLists)

		{

		TInt i;

		for (i=0; i<iObey->iNumberOfVariants; i++)

			delete iVariantFileLists[i];

		delete [] iVariantFileLists;

		}

	}

TInt E32Rom::Align(TInt aVal)

//

// Align to romalign

//

	{

	return ((aVal+iObey->iRomAlign-1)/iObey->iRomAlign)*iObey->iRomAlign;

	}

TInt E32Rom::LoadContents(char*& anAddr, TRomHeader* aHeader)

	{

	// Load all the PE/E32Image files

	TInt nfiles=iObey->iNumberOfPeFiles;

	iPeFiles=new TRomBuilderEntry* [nfiles];

	if (!iPeFiles)

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

	TInt r=TranslateFiles();

	if (r!=KErrNone)

		return r;

	ProcessDllData();

	EnumerateVariants();

	r=BuildDependenceGraph();

	if (r!=KErrNone)

		return r;

	// Update the ROM image headers with SMP information.

	SetSmpFlags();

	r=ProcessDependencies();

	if (r!=KErrNone)

		return r;

	char* addr = anAddr;

	TRomExceptionSearchTable* exceptionSearchTable = 0;

	if(gPagedRom)

		{ 

		gDepInfoFile = iObey->iRomFileName; 

		iObey->SetArea().DefaultArea()->SortFilesForPagedRom();

		// exception search table needs to go at start of ROM to make it not demand paged...

		addr = ReserveRomExceptionSearchTable(addr,exceptionSearchTable);

		}

	else if(gGenDepGraph)

		{

			Print(EWarning, "Not dependence information in an unpaged ROM.");

		}

	addr=WriteDirectory(addr, aHeader);

	// Aligned

	TRACE(TSCRATCH,Print(EAlways,"Directory written\n"));

	// Stick all the files in ROM

	TReloc* relocationTable;

	addr = AllocateRelocationTable(addr, relocationTable);

	aHeader->iRelocInfo = relocationTable ? ActualToRomAddress(relocationTable) : 0;

	// Aligned

	TRACE(TSCRATCH,Print(EAlways,"Done AllocateRelocationTable\n"));

	CalculateDataAddresses();

	addr = LayoutRom(addr);

	TRACE(TSCRATCH,Print(EAlways,"Done LayoutRom\n"));

	FillInRelocationTable(relocationTable);

	TRACE(TSCRATCH,Print(EAlways,"Done FillInRelocationTable\n"));