// 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 "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 <time.h>

#include <malloc.h>

#include <string.h>

#include "e32image.h"

#include <e32std.h>

#include <e32std_private.h>

#include "pe_defs.h"

#include "pe_file.h"

#include "h_ver.h"

#include "h_utl.h"

int gAlignConstSection=FALSE;

TUint gConstSectionAddressMask=0;

static TUint gRequiredConstPadding;

extern char* gX86imp;

extern int gX86num_imp_dlls;

extern int gX86imp_size;

extern int gX86num_imports;

E32ImageFile* E32ImageFile::New()

	{

	return new E32ImageFile_PE;

	}

E32ImageFile_PE::E32ImageFile_PE()

	{

	}

E32ImageFile_PE::~E32ImageFile_PE()

	{

	}

TUint E32ImageFile_PE::ImportAddressTableOffset()

//

// Return the offset of the iat

//

	{

	return iHdr->iTextSize;

	}

TUint E32ImageFile_PE::ConstOffset()

//

// return the offset of the const data

//

	{

	return iConstOffset;

	}

void E32ImageFile_PE::CreateExportDirectory(char *aPtr, PEFile &aPeFile)

//

// create a new format export directory

//

	{

	if (iHdr->iExportDirCount==0)

		return;

	TUint *src=(TUint *)aPeFile.iSectionData[KExportSection];

	TUint *dst=(TUint *)aPtr;

	PIMAGE_EXPORT_DIRECTORY dir=(PIMAGE_EXPORT_DIRECTORY)src;

	src+=(((TInt)dir->AddressOfFunctions)-((TInt)aPeFile.iSectionHeader[KExportSection]->VirtualAddress))/4;

	TUint i;

	for (i=0; i<dir->NumberOfFunctions; i++)

		{

		TUint va=*src++;

		dst[i]=va;

		}

	FixExportDirectory(dst, aPeFile);

	}

void E32ImageFile_PE::FixExportDirectory(TUint *aExportDir, PEFile &aPeFile)

//

// Fix the export directory

//

	{

	TUint lb = aPeFile.iLinkedBase;

	TUint *exportdir=aExportDir;

	TInt n;

	for (n=0; n<(TInt)iHdr->iExportDirCount; n++)

		{

		TUint va=*exportdir;

		if (!gLittleEndian) ByteSwap(va);

		// va is the address of an exported item, so assume it can't have been offset

		TInt i=aPeFile.FindSectionByVa(va+lb);

		if (i==KTextSection)

			va=va-aPeFile.iSectionHeader[i]->VirtualAddress;

		else if (i==KConstSection)

			va=va-aPeFile.iSectionHeader[i]->VirtualAddress+ConstOffset();

		else if (i==KDataSection)

			va=va-aPeFile.iSectionHeader[i]->VirtualAddress+DataOffset();

		else if (i==KBssSection)

			va=va-aPeFile.iSectionHeader[i]->VirtualAddress+BssOffset();

		else

			{

			if (va == 0)

				Print(EWarning, "No export specified for ordinal %d\n", n+1, va);

			else

				Print(EError, "Export %d (address %08x) is not from .text, .rdata, or data sections\n", n+1, va);

			}

		if (!gLittleEndian) ByteSwap(va);

		*exportdir++=va;

		}

	}

TInt E32ImageFile_PE::DoCodeHeader(PEFile &aPeFile)

//

// Calculate the code parts of the pefile

//

	{

	// .text

	TInt size=ALIGN4(aPeFile.iSectionHeader[KTextSection]->Misc.VirtualSize);

	// .rdata

	iConstOffset=0;

	if (gAlignConstSection)

		{

	    // Compute the amount of padding to put before the

	    // const section to align it correctly

	    TUint   oldAddressBits = aPeFile.iSectionHeader[KConstSection]->VirtualAddress & gConstSectionAddressMask;

	    TUint   oldConstAddress = size;

	    TUint   newConstAddress = oldConstAddress;

	    // slow but sure

	    while ((newConstAddress & gConstSectionAddressMask) != oldAddressBits)

	    	{

			newConstAddress++;

			}

	    gRequiredConstPadding = newConstAddress - oldConstAddress;

	    size += gRequiredConstPadding;

		}

	if (aPeFile.iSectionHeader[KConstSection])

		{

		iConstOffset = size;

		size += ALIGN4(aPeFile.iSectionHeader[KConstSection]->Misc.VirtualSize);

		}

	// .crt

	iCrtOffset=0;

	if (aPeFile.iSectionHeader[KCrtSection])

		{

		iCrtOffset = size;

		size += ALIGN4(aPeFile.iSectionHeader[KCrtSection]->Misc.VirtualSize);

		}

	iHdr->iTextSize=size; // The "text" part of the E32 code section combines PE's .text + .rdata + .crt.

						  // The remainder of the E32 code section is the IAT + export directory.

	// Import Address Table (IAT)

	TInt nimports=gX86imp?gX86num_imports:aPeFile.NumberOfImports();

	if (nimports!=0)

		size+=nimports*4+4; // null terminated

	// Export Dir

	if (iHdr->iExportDirCount)

		{

		iHdr->iExportDirOffset = iHdr->iCodeOffset + size;

		size += ALIGN4(iHdr->iExportDirCount*4);

		}

	iHdr->iCodeSize=size;

	return size;

	}

TInt E32ImageFile_PE::DoDataHeader(PEFile &aPeFile, TUint aDataBase)

//

//

//

	{

	if (aDataBase == (TUint)0)

		aDataBase=iHdr->iCodeBase+iHdr->iCodeSize;

	TInt size=0;

	if (PEFile::HasInitialisedData(aPeFile.iSectionHeader[KDataSection]))

		{

		size=ALIGN4(aPeFile.iSectionHeader[KDataSection]->Misc.VirtualSize);

		iHdr->iDataBase=aDataBase;

		iHdr->iDataOffset = iHdr->iCodeOffset + iHdr->iCodeSize;

		TInt bsssize=aPeFile.iSectionHeader[KDataSection]->Misc.VirtualSize-aPeFile.iSectionHeader[KDataSection]->SizeOfRawData;

		// drop any uninitialised data

		if (bsssize>0)

			{

			iHdr->iBssSize+=bsssize;

			size=ALIGN4(aPeFile.iSectionHeader[KDataSection]->SizeOfRawData);

			}

		iHdr->iDataSize=size;

		}

	else if (aPeFile.iSectionHeader[KDataSection])

		{ // just .bss

		iHdr->iDataBase=aDataBase;

		TInt bsssize=aPeFile.iSectionHeader[KDataSection]->Misc.VirtualSize;

		iHdr->iBssSize+=bsssize;

		}

	if (aPeFile.iSectionHeader[KBssSection])

		{

		iHdr->iBssSize+=ALIGN4(aPeFile.iSectionHeader[KBssSection]->Misc.VirtualSize);

		if (iHdr->iDataBase==0) // .bss but no .data

			iHdr->iDataBase=aDataBase;

		}

	return size;

	}

TInt E32ImageFile_PE::CopyCode(char *p, PEFile &aPeFile)

//

// Copies the files code sections to p

// returns the number of bytes copied or KErrGeneral

//

	{

	// text

	TInt size=aPeFile.iSectionHeader[KTextSection]->Misc.VirtualSize;

	memcpy(p, aPeFile.iSectionData[KTextSection], size);

	TInt text_offset=ALIGN4(size);

	p+=text_offset;

	// rdata

	if (aPeFile.iSectionData[KConstSection])

		{

		if (gAlignConstSection)

			{

			// add padding ahead of const section

			p += gRequiredConstPadding;

			}

		TInt size=ALIGN4(aPeFile.iSectionHeader[KConstSection]->Misc.VirtualSize);

		memcpy(p, aPeFile.iSectionData[KConstSection], size);

		p+=size;

		}

	if (aPeFile.iSectionData[KCrtSection])

		{

		TInt size=ALIGN4(aPeFile.iSectionHeader[KCrtSection]->Misc.VirtualSize);

		memcpy(p, aPeFile.iSectionData[KCrtSection], size);

		p+=size;

		}

	// iat

	TInt nimports=gX86imp?gX86num_imports:aPeFile.NumberOfImports();

//	TInt nimports=aPeFile.NumberOfImports();

	if (nimports)

		{

		if (gX86imp)

			{

			TUint *rdata=(TUint*)aPeFile.iSectionData[KConstSection];

			int i;

			int* s=(int*)gX86imp;

			s++;

			for (i=0; i<gX86num_imp_dlls; ++i)

				{

				++s;

				int n=*s++;

				while (n--)

					{

					*(int*)p=rdata[(*s)>>2]&0x7fffffffu;	// rdata offset to ordinal

					++s;

					p+=4;

					}

				}

			*(int*)p=0;

			p+=4;

			}

		else

			{

			TInt r=CopyImportAddrTable(p, aPeFile);

			p+=ALIGN4(nimports*4+4);

			if (r!=KErrNone)

				return Print(EError, "%s is importing symbols by name.\n", iFileName);

			}

		}

	// export dir

	CreateExportDirectory(p, aPeFile);

	p+=iHdr->iExportDirCount*4;

	return iHdr->iCodeSize;

	}

TInt E32ImageFile_PE::CopyData(char *p, PEFile &aPeFile)

	{

	if (iHdr->iDataSize)

		memcpy(p, aPeFile.iSectionData[KDataSection], iHdr->iDataSize);

	return iHdr->iDataSize;

	}

TInt E32ImageFile_PE::Translate(const char* aFileName, TUint aDataBase, TBool aAllowDllData, TBool /*aSymLkupEnabled*/)

//

// Translate a PE format file to a E32Image file

//

	{

	iSource = EPeFile;

	PEFile pefile;

	if (!pefile.Init((const char * const)aFileName))

		return KErrGeneral;

	TInt r=pefile.ReadSectionHeaders();

	if (r!=KErrNone) return r;

	r=pefile.ReadData();

	if (r!=KErrNone) return r;

	pefile.Close();

	r=pefile.Normalise();

	if (r!=KErrNone) return r;

	iFileName = strdup(aFileName);

	Adjust(ALIGN4(sizeof(E32ImageHeaderV)));	// fixed for now because holes not supported

	SetDefaultHeader();

	if (gX86imp)

		iHdr->iDllRefTableCount=gX86num_imp_dlls;

	else

		iHdr->iDllRefTableCount=pefile.NumberOfImportDlls();

	iHdr->iExportDirCount=pefile.NumberOfExports();

	iHdr->iCodeBase=pefile.iLinkedBase;

	TInt nimports=gX86imp?gX86num_imports:pefile.NumberOfImports();

	TInt importSectionSize;

	char *newImportSection=CreateImportSection(pefile, importSectionSize);

	TInt size = ALIGN4(sizeof(E32ImageHeaderV));	// fixed for now because holes not supported

	iHdr->iCodeOffset = size;

	TInt pos = size;

	size+=DoCodeHeader(pefile);

	TInt t=DoDataHeader(pefile, aDataBase);

	if (t>0)

		{

		iHdr->iDataOffset = size;

		size += t;

		}

	if (importSectionSize!=0)

		{

		iHdr->iImportOffset = size;

		size += importSectionSize;

		}

	char *newCodeRelocs=NULL;

	char *newDataRelocs=NULL;

	TInt codeRelocSize=0, dataRelocSize=0;

	TInt nrelocs=pefile.NumberOfRelocs();

	if (nrelocs)

		{

		TUint *relocs=new TUint [nrelocs];

		TUint *relocsection=new TUint [nrelocs];

		pefile.GetRelocs(relocs, relocsection, nrelocs);

		FixRelocs(pefile, relocs, relocsection, nrelocs);

		newCodeRelocs=CreateCodeRelocs(relocs, relocsection, nrelocs, codeRelocSize);

		newDataRelocs=CreateDataRelocs(relocs, relocsection, nrelocs, dataRelocSize);

		if (codeRelocSize)

			{

			iHdr->iCodeRelocOffset = size;

			size += codeRelocSize;

			}

		if (dataRelocSize)

			{

			iHdr->iDataRelocOffset = size;

			size += dataRelocSize;

			}

		delete [] relocs;

		delete [] relocsection;

		}

	Adjust(size);

	t=CopyCode(iData + pos, pefile);

	if (t<0)

		return KErrGeneral;

	pos += t;

	pos += CopyData(iData + pos, pefile);

	if (nimports)

		{

		memcpy(iData + pos, newImportSection, importSectionSize);

		pos += importSectionSize;

		}

	if (codeRelocSize)

		{

		memcpy(iData + pos, newCodeRelocs, codeRelocSize);

		pos += codeRelocSize;

		}

	if (dataRelocSize)

		{

		memcpy(iData + pos, newDataRelocs, dataRelocSize);

		pos += dataRelocSize;

		}

	// locate the entry point

	// entry point must be in the text section

	TInt entryPointSectionIndex=pefile.FindSectionByVa(pefile.iEntryPoint+pefile.iLinkedBase);

	TUint entryPointOffset=pefile.iEntryPoint-pefile.iSectionHeader[entryPointSectionIndex]->VirtualAddress;

	if (entryPointSectionIndex!=KTextSection)

		return Print(EError, "Entry Point not in code section\n");

	// Arrange a header for this E32 Image

	switch (pefile.iCpu)

		{

	case IMAGE_FILE_MACHINE_I386:

		iHdr->iCpuIdentifier = (TUint16)ECpuX86;

		break;

	case 0x0a00:

		iHdr->iCpuIdentifier = (TUint16)ECpuArmV4;

		break;

	case 0x0b00:

		iHdr->iCpuIdentifier = (TUint16)ECpuMCore;

		break;

	default:

		iHdr->iCpuIdentifier = (TUint16)ECpuUnknown;

		break;

		}

	// Import format is PE-derived without redundant ordinal lists

	// ABI is GCC98r2 ABI (on ARM)

	iHdr->iFlags |= KImageImpFmt_PE2;

	if (pefile.iImageIsDll)

		{

		iHdr->iFlags|=KImageDll;

		if (iHdr->iDataSize && !aAllowDllData)

			return Print(EError, "Dll '%s' has initialised data.\n", iFileName);

		if (iHdr->iBssSize  && !aAllowDllData)

			return Print(EError, "Dll '%s' has uninitialised data.\n", iFileName);

		}

	iHdr->iHeapSizeMin=pefile.iHeapCommittedSize;

	iHdr->iHeapSizeMax=pefile.iHeapReservedSize;

	iHdr->iStackSize=pefile.iStackCommittedSize;

	iHdr->iEntryPoint=entryPointOffset;

	r = DetermineEntryPointType();

	if (r == KErrCorrupt)

		return Print(EError, "File '%s': Bad Entry Point.\n", iFileName);

	else if (r == KErrNotSupported)

		return Print(EError, "File '%s': Bad Entry Point Type.\n", iFileName);

	delete [] newImportSection;

	delete [] newCodeRelocs;

	delete [] newDataRelocs;

	return KErrNone;

	}

TBool E32ImageFile_PE::Translate(PEFile &aPeFile)

//

//

//

	{

	return Translate((const char*)aPeFile.iFileName, (TUint)0, EFalse, EFalse);

	}