// 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 <stdlib.h>

#include <string.h>

#include <e32std.h>

#include <e32std_private.h>

#include "pe_file.h"

#include "h_utl.h"

#include <stdio.h>

extern char* gX86imp;

extern int gX86num_imp_dlls;

extern int gX86imp_size;

extern int gX86num_imports;

extern int* gX86imp_relocs;

TInt sizeOfCodeRelocs(TUint *relocs, TUint *relocsection, TInt nrelocs)

	{

	TInt bytecount=0;

	TInt page=-1;

	TInt i;

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

		{

		if ((TInt)relocsection[i]==KTextSection || (TInt)relocsection[i]==KConstSection || (TInt)relocsection[i]==KCrtSection)

			{

			TInt p=relocs[i]&0xfffff000;

			if (page!=p)

				{

				if (bytecount%4!=0)

					bytecount+=2;

				bytecount+=8; // page, block size

				page=p;

				}

			bytecount+=2;

			}

		}

	if (bytecount%4!=0)

		bytecount+=2;

	return bytecount;

	}

TInt sizeOfDataRelocs(TUint *relocs, TUint *relocsection, TInt nrelocs)

	{

	TInt bytecount=0;

	TInt page=-1;

	TInt i;

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

		{

		if ((TInt)relocsection[i]==KDataSection)

			{

			TInt p=relocs[i]&0xfffff000;

			if (page!=p)

				{

				if (bytecount%4!=0)

					bytecount+=2;

				bytecount+=8; // page, block size

				page=p;

				}

			bytecount+=2;

			}

		}

	if (bytecount%4!=0)

		bytecount+=2;

	return bytecount;

	}

void reorderRelocs(TUint aReloc[], TUint aRelocSection[], TInt aNumberOfRelocs)

//

// sort the relocations in section order

//

	{

	TUint *temp=new TUint [aNumberOfRelocs];

	TUint *tempsection=new TUint [aNumberOfRelocs];

	TInt idx=0;

	TUint section=0;

	while (idx<aNumberOfRelocs)

		{

		for (TInt i=0; i<aNumberOfRelocs; i++)

			{

			if (aRelocSection[i]==section)

				{

				temp[idx]=aReloc[i];

				tempsection[idx]=aRelocSection[i];

				idx++;

				}

			}

		section++;

		}

	memcpy((char *)aReloc, (char *)temp, aNumberOfRelocs*sizeof(TUint));

	memcpy((char *)aRelocSection, (char *)tempsection, aNumberOfRelocs*sizeof(TUint));

	delete [] temp;

	delete [] tempsection;

	}

char *E32ImageFile_PE::CreateCodeRelocs(TUint *relocs, TUint *relocsection, TInt nrelocs, TInt &aSize)

	{

	TInt bytecount=sizeOfCodeRelocs(relocs, relocsection, nrelocs);

	aSize=0;

	if (bytecount==0)

		return NULL;

	aSize=bytecount+sizeof(E32RelocSection);

	char *section=new char [bytecount+sizeof(E32RelocSection)];

	char *data=section+sizeof(E32RelocSection);

	char *startofblock=data;

	TInt ncoderelocs=0;

	TInt page=-1;

	TInt pagesize=8;

	TInt i;

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

		{

		if ((TInt)relocsection[i]==KTextSection || (TInt)relocsection[i]==KConstSection || (TInt)relocsection[i]==KCrtSection)

			{

			TInt p=relocs[i]&0xfffff000;

			if (page!=p)

				{

				if (pagesize%4!=0)

					{

					*(TUint16 *)data=0;

					data+=2;

					pagesize+=2;

					}

				*(TUint *)startofblock=page;

				*(TUint *)(startofblock+4)=pagesize;

				pagesize=8;

				page=p;

				startofblock=data;

				data+=8;

				}

			*(TUint16 *)data=(TUint16)((relocs[i]&0xfff)|0x3000);

			data+=2;

			pagesize+=2;

			ncoderelocs++;

			}

		}

	if (pagesize%4!=0)

		{

		*(TUint16 *)data=0;

		data+=2;

		pagesize+=2;

		}

	*(TUint *)startofblock=page;

	*(TUint *)(startofblock+4)=pagesize;

	((E32RelocSection *)section)->iNumberOfRelocs=ncoderelocs;

	((E32RelocSection *)section)->iSize=bytecount;

	return section;

	}

char *E32ImageFile_PE::CreateDataRelocs(TUint *relocs, TUint *relocsection, TInt nrelocs, TInt &aSize)

	{

	TInt bytecount=sizeOfDataRelocs(relocs, relocsection, nrelocs);

	aSize=0;

	if (bytecount==0)

		return NULL;

	aSize=bytecount+sizeof(E32RelocSection);

	char *section=new char [bytecount+sizeof(E32RelocSection)];

	char *data=section+sizeof(E32RelocSection);

	char *startofblock=data;

	TInt ndatarelocs=0;

	TInt page=-1;

	TInt pagesize=8;

	TInt i;

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

		{

		if ((TInt)relocsection[i]==KDataSection)

			{

			TInt p=relocs[i]&0xfffff000;

			if (page!=p)

				{

				if (pagesize%4!=0)

					{

					*(TUint16 *)data=0;

					data+=2;

					pagesize+=2;

					}

				*(TUint *)startofblock=page;

				*(TUint *)(startofblock+4)=pagesize;

				pagesize=8;

				page=p;

				startofblock=data;

				data+=8;

				}

			*(TUint16 *)data=(TUint16)((relocs[i]&0xfff)|0x3000);

			data+=2;

			pagesize+=2;

			ndatarelocs++;

			}

		}

	if (pagesize%4!=0)

		{

		*(TUint16 *)data=0;

		data+=2;

		pagesize+=2;

		}

	*(TUint *)startofblock=page;

	*(TUint *)(startofblock+4)=pagesize;

	((E32RelocSection *)section)->iNumberOfRelocs=ndatarelocs;

	((E32RelocSection *)section)->iSize=bytecount;

	return section;

	}

void checkreloc(PEFile &aPeFile, TUint va, TUint reloc)

	{

	// Allow the section find routine to use heuristics to resolve addresses

	// which have been offset by the compiler

	TInt s = aPeFile.FindSectionByVa(va, 1);

	switch(s)

		{

		case KTextSection:

		case KConstSection:

		case KDataSection:

		case KCrtSection:

		case KBssSection:

		case KImportSection:

			return;

		default:

			break;

		}

	Print(EAlways, "bad relocation:  [%08x] = %08x\n", reloc, va);

	}

void E32ImageFile_PE::FixRelocs(PEFile &aPeFile, TUint *relocation, TUint *relocsection, TInt aNumberOfRelocs)

	{

	TUint *data;

	TInt i;

#if 0

	Print(EAlways, "Linked base %08x\n", aPeFile.iLinkedBase);

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

		{

		if (!aPeFile.iSectionHeader[i])

			continue;

		TUint start = aPeFile.iSectionHeader[i]->VirtualAddress;

		TUint finish = start + aPeFile.iSectionHeader[i]->Misc.VirtualSize;

		Print(EAlways, "Section %d %08x-%08x\n", i, start, finish);

		}

#endif

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

		{

		switch (relocsection[i])

			{

		case KTextSection:

			relocation[i]-=aPeFile.iSectionHeader[KTextSection]->VirtualAddress;

			data=(TUint *)(aPeFile.iSectionData[KTextSection]+relocation[i]);

			if (!gLittleEndian) ByteSwap(*data);

			checkreloc(aPeFile, *data, relocation[i]+aPeFile.iSectionHeader[KTextSection]->VirtualAddress);

			*data=FixAddress(aPeFile, *data);

			if (!gLittleEndian) ByteSwap(*data);

			break;

		case KConstSection:

			relocation[i]-=aPeFile.iSectionHeader[KConstSection]->VirtualAddress;

			data=(TUint *)(aPeFile.iSectionData[KConstSection]+relocation[i]);

			if (!gLittleEndian) ByteSwap(*data);

			checkreloc(aPeFile, *data, relocation[i]+aPeFile.iSectionHeader[KConstSection]->VirtualAddress);

			relocation[i]+=ConstOffset();

			*data=FixAddress(aPeFile, *data);

			if (!gLittleEndian) ByteSwap(*data);

			break;

		case KCrtSection:

			relocation[i]-=aPeFile.iSectionHeader[KCrtSection]->VirtualAddress;

			data=(TUint *)(aPeFile.iSectionData[KCrtSection]+relocation[i]);

			if (!gLittleEndian) ByteSwap(*data);

			checkreloc(aPeFile, *data, relocation[i]+aPeFile.iSectionHeader[KCrtSection]->VirtualAddress);

			relocation[i]+=iCrtOffset;

			*data=FixAddress(aPeFile, *data);

			if (!gLittleEndian) ByteSwap(*data);

			break;

		case KDataSection:

			relocation[i]-=aPeFile.iSectionHeader[KDataSection]->VirtualAddress;

			data=(TUint *)(aPeFile.iSectionData[KDataSection]+relocation[i]);

			if (!gLittleEndian) ByteSwap(*data);

			checkreloc(aPeFile, *data, relocation[i]+aPeFile.iSectionHeader[KDataSection]->VirtualAddress);

			*data=FixAddress(aPeFile, *data);

			if (!gLittleEndian) ByteSwap(*data);

			break;

		default:

			Print(EWarning, "Relocation in invalid section.\n");

			break;

			}

		}

	reorderRelocs(relocation, relocsection, aNumberOfRelocs);

	}

TUint E32ImageFile_PE::FixAddress(PEFile &aPeFile, TUint va)

//

// Fix the given virtual address for the new headers

//

	{

	// Allow the section find routine to use heuristics to resolve addresses

	// which have been offset by the compiler

	TInt section=aPeFile.FindSectionByVa(va, 1);

	switch(section)

		{

		case KTextSection:

			va-=aPeFile.iLinkedBase;

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

			va+=iHdr->iCodeBase;

			break;

		case KConstSection:

			va-=aPeFile.iLinkedBase;

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

			if (gX86imp)

				{

				TUint old_iat_size=(gX86num_imports+gX86num_imp_dlls)<<2;

				if (va<old_iat_size)

					{

					TInt offset=iHdr->iTextSize;

//					fprintf(stderr,"IAT OFF %x ",va);

					va=gX86imp_relocs[va>>2]+iHdr->iCodeBase+offset;

//					fprintf(stderr,"-> %x\n",va);

					break;

					}

				}

			va+=iHdr->iCodeBase+ConstOffset();

//			fprintf(stderr,"const reloc -> %x\n",va);

			break;

		case KDataSection:

			va-=aPeFile.iLinkedBase;

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

			va+=iHdr->iDataBase; //DataOffset();

			break;

		case KCrtSection:

			va-=aPeFile.iLinkedBase;

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

			va+=iHdr->iCodeBase+iCrtOffset;

			break;

		case KBssSection:

			va-=aPeFile.iLinkedBase;

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

			va+=iHdr->iDataBase+iHdr->iDataSize;

			break;

		case KImportSection:

			va-=aPeFile.iLinkedBase;

			va=FixImportThunk(aPeFile, va-aPeFile.iSectionHeader[KImportSection]->VirtualAddress);

			va+=iHdr->iCodeBase;

			break;

		default:

			if (va < 0x10000u)

				{

				// assume it's a relocation relative to an omitted section

				break;

				}

			Print(EWarning, "Address to relocate cannot be resolved to .text, .rdata, .idata or data sections\n");

			Print(EWarning, "Problem address = %08x (section %d)\n", va, section);

			break;

		}

	// va is now an offset from the start of the text

	return va;

	}