// Copyright (c) 1995-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:
//

#ifndef __R_ROM_H__
#define __R_ROM_H__

#include "e32image.h"
#include <e32rom.h>

#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
#include <fstream>
#else //!__MSVCDOTNET__
#include <fstream.h>
#endif //__MSVCDOTNET__

#include "h_utl.h"
#include "r_mromimage.h"
#include <malloc.h>


//
const TUint KRomWrapperSize = 0x100;
const TUint KRomNameSize = 16;
//
const TUint KOverrideStack = 0x01;
const TUint KOverrideHeapMin = 0x02;
const TUint KOverrideHeapMax = 0x04;
const TUint KOverrideAddress = 0x08;
const TUint KOverrideUid1 = 0x10;
const TUint KOverrideUid2 = 0x20;
const TUint KOverrideUid3 = 0x40;
const TUint KOverrideCallEntryPoint = 0x80;
const TUint KOverrideNoCallEntryPoint = 0x100;
const TUint KOverridePriority = 0x200;
const TUint KOverrideStackReserve = 0x400;
const TUint KOverrideKeepIAT = 0x800;
const TUint KOverrideCapability = 0x1000;
const TUint KOverrideCodeUnpaged = 0x2000;
const TUint KOverrideCodePaged = 0x4000;
const TUint KOverrideDataUnpaged = 0x8000;
const TUint KOverrideDataPaged = 0x10000;
const TUint KOverrideHCRData = 0x20000 ;

enum TKernelModel {ESingleKernel, EMultipleKernels};
enum TMemModel {E_MM_Moving, E_MM_Direct, E_MM_Multiple, E_MM_Flexible};

const TUint KVariantIndependent = 0x01000000;

extern TInt CompareCapabilities(const TUint32* aSubCaps, const TUint32* aSuperCaps, const char* aSubName, const char* aSuperName);

class THardwareVariant
	{
public:
	enum THardwareVariantOrder
		{
		EUnordered=0,
		ELess=1,
		EEqual=2,
		EGreater=4,
		};
public:
	THardwareVariant() {iVariant=KVariantIndependent;}
	THardwareVariant(TUint aVariant) {iVariant=aVariant;}
	operator TUint() const {return iVariant;}
	TBool MutuallyExclusive(THardwareVariant aHardwareVariant) const;
	TInt Compare(THardwareVariant aHardwareVariant) const;
	TBool operator<(THardwareVariant a) const { return ((Compare(a)&ELess)!=0); }
	TBool operator==(THardwareVariant a) const { return ((Compare(a)&EEqual)!=0); }
	TBool operator>(THardwareVariant a) const { return ((Compare(a)&EGreater)!=0); }
	TBool operator<=(THardwareVariant a) const { return ((Compare(a)&(ELess|EEqual))!=0); }
	TBool operator>=(THardwareVariant a) const { return ((Compare(a)&(EGreater|EEqual))!=0); }
	TBool IsIndependent() const {return Layer()<=3;}
	TBool IsCpu() const {return Parent()==3; }
	TBool IsVariant() const;
	TUint32 ReturnVariant() const {return iVariant;} 
	TUint Layer() const {return iVariant>>24;}
	TUint Parent() const {return (iVariant>>16)&0xff;}
	TUint VMask() const {return iVariant&0xffff;}
private:
	TUint32 iVariant;
	};

class TRomLoad
	{
public:
	TText name[KRomNameSize];
	TText versionStr[4];
	TText buildNumStr[4];
	TUint romSize;
	TUint wrapSize;
	};
//

// representation of a relocation record for areas.
class TReloc
	{
public:
	TInt iLength;
	TUint iSrc;
	TUint iDest;
	};

// thing for tracking the various addresses at which to find something

class TAddressRange
	{
public:
	TAddressRange();

	void Append(TAddressRange& aRange);
	void Extend(TInt aOffset);
	void Move(TInt aOffset);

public:
	TAny*	iImagePtr;			// data in the ROM image buffer
	TUint32	iImageAddr;			// address in the ROM image 
	TUint32 iRunAddr;			// runtime address, usually the same as the iImageAddr
	TUint   iSize;				// size of this section
	};


class TImageSection : public TAddressRange
	{
public:
	TImageSection() : TAddressRange(), iFilePtr(0) {}

	TAny* iFilePtr;		// original data in the E32Image file

	void Load() const;	// copy the file data into the image, if needed
	};

//
const TUint KFillSize = KRomWrapperSize-sizeof(TRomLoad);
class CObeyFile;
class TRomLoaderHeader
	{
public:
	void SetUp(CObeyFile *aObey);
private:
	TRomLoad r;
	TUint8 filler[KFillSize];
	};
//
class TRomBuilderEntry;
class TRomNode;
class TRomFile;
class TDllFindInfo
	{
public:
	TDllFindInfo(const char* aImportName, const TRomBuilderEntry* aEntry);
	~TDllFindInfo();
public:
	const char* iBareName;		// filename+extension to find, not including path UID or version
	TUint32 iUid3;				// requested UID3 - 0 if don't care
	TUint32 iModuleVersion;		// requested version
	TUint32 iHwVariant;			// requested hardware variant
	};

class TAutoFree
	{
public:
	TAutoFree(void* aPtr) {iPtr=aPtr;}
	~TAutoFree() {free(iPtr);}
private:
	void* iPtr;
	};

#define AUTO_FREE(p)	TAutoFree _auto_free_##p(p)

class TModuleName
	{
public:
	TModuleName(const TRomBuilderEntry* aEntry);
	TModuleName(const TDllFindInfo& aInfo);
	TModuleName(const TRomNode& aNode);
	TModuleName(const TRomFile& aFile, const TRomNode* aRootDir);
	~TModuleName();
	operator const char* () {return iName;}
private:
	char* iName;
	};

// class representing a file (or directory) in the ROM
class TRomFile
	{
public:
	TRomFile();
	~TRomFile();
	TInt AddressFromOrdinal(TLinAddr& aEDataAddr,TLinAddr& aExport, TUint aOrdinal);
	void Finalise(TInt aSize);

	void Close() { if (--iRefCount<=0) delete this; };
	void Open() {iRefCount++; };

	TInt MarkDeps();
	TInt FindRouteTo(TRomFile* aDest, TRomFile** aStack, TInt aIndex);
	TRomEntry* RomEntry() const {return iRomEntry;}
	void SetRomEntry(TRomEntry* aEntry);

	TAddressRange iAddresses;

	inline TRomImageHeader* RomImgHdr() const
		{return (TRomImageHeader*)iAddresses.iImagePtr;}

	TAddressRange iExportDir;
	TRomBuilderEntry* iRbEntry;	// only until Layout stage
	TBool iDir;
	TBool iFinal;
	THardwareVariant iHwvd;
	TRomEntry* iRomEntry;		// in ROM image buffer
	friend class FileEntry;

	TInt iDataBssOffsetInExe;	// for allocating DLL data in process data section

	// dependence graph
	TInt iNumDeps;
	TRomFile** iDeps;
	TInt iNumPDeps;
	TRomFile** iPDeps;
	TInt iMark;
	TRomFile* iAttachProcess;
	TInt iTotalDataBss;

	// Data used when computing SMP properties.
	struct TSmpInfo
		{
		TSmpInfo() : isInit(0), isActive(0), isSafe(0) {}
		bool isInit;
		bool isActive;
		bool isSafe;
		} iSmpInfo;

	bool ComputeSmpSafe(const TRomBuilderEntry*);
public:
	TUint32 Uid3() const;
	TUint32 ModuleVersion() const;
	THardwareVariant HardwareVariant() const;
	TUint32 ABI() const;
	TInt ExportDirCount() const;
	TUint32 RomImageFlags() const;
	TLinAddr DataBssLinearBase() const;
	const SSecurityInfo& SecurityInfo() const;
private:
	TInt iRefCount;
	};
//
class TRomBuilderEntry;
class RomFileStructure;

// class representing a directory entry in the ROM file system
class TRomNode
	{
public:
	TRomNode(const TText* aName, TRomBuilderEntry* aEntry=0);
	TRomNode(const TText* aName, TRomNode* aNode);
private:
	TRomNode(const TRomNode& aNode);
public:
	~TRomNode();
	void Destroy();

	TInt SetAtt(TText *anAttWord);
	TInt NameCpy(char* aDest); // returns the length of aDest (in UTF-16 characters for Unicode, not bytes)
	TInt SetBareName();

	TRomNode* NewSubDir(const TText* aName);
	void AddFile(TRomNode *aChild);
	TInt Rename(TRomNode *aOldParent, TRomNode* aNewParent, TText* aNewName);
	TRomNode* FindInDirectory(const TText* aName);
	TRomNode* FindInDirectory(const TText* aName, THardwareVariant aVariant , TBool aPatchDataFlag=FALSE);

	TRomEntry* RomEntry() const {return iRomFile->RomEntry();}
	void Finalise(TInt aSize);

	void CountDirectory(TInt& aFileCount, TInt& aDirCount);
	TInt ProcessDirectory(RomFileStructure* aRFS);

	static void AddExecutableFile(TRomNode*& aLast, TRomNode* aNode);
	TRomNode* FindImageFileByName(const TDllFindInfo& aInfo, TBool aPrintDiag, TBool& aFallBack);
	TInt CheckForVersionConflicts(const TRomBuilderEntry* a);

	TRomNode* CopyDirectory(TRomNode*& aLastExecutable, TRomNode* aParent);
	TInt Alias(TRomNode* aNode, TRomNode*& aLastExecutable);
public:
	char* BareName() const;
	TUint32 Uid3() const;
	TUint32 ModuleVersion() const;
	THardwareVariant HardwareVariant() const;
	TUint32 ABI() const;
	TInt FullNameLength(TBool aIgnoreHiddenAttrib = EFalse) const;
	TInt GetFullName(char* aBuf, TBool aIgnoreHiddenAttrib = EFalse) const;

	void Add(TRomNode* aChild);
	void Remove(TRomNode* aChild);

	static TInt Count;			// seed for unique identifiers

	TRomNode* iSibling;
	TRomNode* iChild;
	TRomNode* iParent;
	TRomNode* iNextExecutable;

protected:
	TInt iIdentifier;
	friend class FileEntry;

public:
	TRomFile* iRomFile;
	TText* iName;
	char* iBareName;		// name including extension but without UID or version
	TUint8 iAtt;
	TBool iHidden;
	};

class E32Rom;
class Area;
class TRomBuilderEntry : public E32ImageFile
	{
public:
	TRomBuilderEntry(const char *aFileName, TText *aName);
	~TRomBuilderEntry();
	TInt SetCodeAlignment(TText *aStr);
	TInt SetDataAlignment(TText *aStr);
	TInt SetRelocationAddress(TText *aStr);
	TInt SetStackReserve(TText *aStr);
	TInt SetStackSize(TText *aStr);
	TInt SetHeapSizeMin(TText *aStr);
	TInt SetHeapSizeMax(TText *aStr);
	TInt SetCapability(TText *aStr);
	TInt SetUid1(TText *aStr);
	TInt SetUid2(TText *aStr);
	TInt SetUid3(TText *aStr);
	TInt SetCallEntryPoint(TBool aState);
	TInt SetPriority(TText *aStr);
	TInt SetAttachProcess(TText *aStr);
	TInt OpenImageFile();
	TInt SizeInRom();
	void SizeInSections(TInt& aSize1, TInt& aSize2);
	void LoadToRom();
	TInt FixupImports(E32Rom& aRom);
	TInt ResolveDllRefTable(E32Rom& aRom);
	TInt BuildDependenceGraph(E32Rom& aRom);
	TInt FindAttachProcess(E32Rom& aRom);
	const char* GetDefaultAttachProcess();
	void SetRomNode(TRomNode* aNode);
	void FixupRomEntries(TInt aSize);
	TRomEntry* RomEntry() const {return iRomNode->RomEntry(); };
	void DisplaySize(TPrintType aWhere);
public:
	inline TBool Primary() const
		{return iRomImageFlags & KRomImageFlagPrimary;}
	inline TBool Variant() const
		{return iRomImageFlags & KRomImageFlagVariant;}
	inline TBool Extension() const
		{return iRomImageFlags & KRomImageFlagExtension;}
	inline TBool Device() const
		{return iRomImageFlags & KRomImageFlagDevice;}
	inline TBool Secondary() const
		{return iRomImageFlags & KRomImageFlagSecondary;}
	inline TBool HCRDataFile() const 
		{ return iOverrideFlags & KOverrideHCRData ;}
private:
	TRomBuilderEntry();
	TRomBuilderEntry(const TRomBuilderEntry&);
	const TRomBuilderEntry& operator=(const TRomBuilderEntry &);
	void Relocate();
public:
	TText *iName;
	TBool iResource;
	TBool iNonXIP;
	TBool iPreferred;
	TUint iCompression;
	TBool iPatched;
	Area* iArea;
	TInt  iRomSectionNumber;
	TUint iOverrideFlags;
	TUint32 iRelocationAddress;
	TInt iAlignment;
	TInt iCodeAlignment;
	TInt iDataAlignment;
	TInt iStackSize;
	TInt iHeapSizeMin;
	TInt iHeapSizeMax;
	TProcessPriority iPriority;
	TUint iUid1;
	TUint iUid2;
	TUint iUid3;
	TLinAddr iDataBssLinearBase;
	SSecurityInfo iS;
	char* iBareName;			// EPOC name+extension but without path or version
	TUint32 iVersionInName;
	TUint32 iVersionPresentInName;

	THardwareVariant iHardwareVariant;
	TUint iDataBssOffset;
	TInt iStackReserve;

	TRomImageHeader* iRomImageHeader;

	TAddressRange iHeaderRange;
	TImageSection iCodeSection;
	TImageSection iImportAddressTableSection;
	TImageSection iExportDirSection;
	TImageSection iDataSection;
	TAddressRange iDllRefTableRange;

	TLinAddr**  iIATRefs;	// image addresses of pointers to IAT

	TRomBuilderEntry* iNext;
	TRomBuilderEntry* iNextInArea;

	TUint32 iRomImageFlags;
	TText* iProcessName;

	// Used by the collapse routines
	TInt iImportCount;
	TUint32 iImportBlockStartAddress;
	TUint32 iImportBlockEndAddress;
	TRomNode *iRomNode;
	};
//
class ImpTRomHeader	: public TRomHeader
	{
public:
	void Display();
	void SetUp(CObeyFile *aObey);
	void CheckSum(TUint32 aTargetValue);
	};
//
class COrderedFileList
	{
public:
	static COrderedFileList* New(TInt aMaxFiles);
	~COrderedFileList();
	void Add(TRomBuilderEntry* anEntry);
	TInt Count() {return iCount;}
	TRomBuilderEntry* operator[](TInt anIndex) {return iOrderedFiles[anIndex];}
private:
	COrderedFileList(TInt aMaxFiles);
private:
	TInt iCount;
	TInt iMaxFiles;
	TRomBuilderEntry **iOrderedFiles;
	};
//
class CObeyFile;
class Area;
class Memmap;
class E32Rom : public MRomImage
	{
public:
	E32Rom(CObeyFile *aObey);
	~E32Rom();
	TInt Create();
	TInt CreateExtension(MRomImage* aKernelRom);
	TInt Align(TInt aVal);
	void DisplaySizes(TPrintType aWhere);
	TInt WriteImages(TInt aHeaderType);
	TInt Compare(char* anImage, TInt aHeaderType);
	//
	//
	char *RomToActualAddress(TUint aPtr);
	TUint ActualToRomAddress(TAny *aPtr);
	void Display(TRomImageHeader *aHdr);
	TRomNode* FindImageFileByName(const TDllFindInfo& aInfo, TBool aPrintDiag, TBool& aFallBack);
	TInt CheckForVersionConflicts(const TRomBuilderEntry* a);
	TRomNode* CopyDirectory(TRomNode*& aLastExecutable);

	TRomNode* RootDirectory();
	TText* RomFileName();
	TUint32 RomBase();
	TUint32 RomSize();
	TVersion Version();
	TInt64 Time();
	TUint32 CheckSum();
	TUint32 DataRunAddress();
	TUint32 RomAlign();

private:
	void CalculateDataAddresses();
	void CalculateDataAddress(TRomBuilderEntry *aFile);
	char *LayoutRom(char *anAddr);
	char *ReserveRomExceptionSearchTable(char *anAddr, TRomExceptionSearchTable*& exceptionSearchTable);
	void ConstructRomExceptionSearchTable(TRomExceptionSearchTable* exceptionSearchTable);
	void LayoutFile(TRomBuilderEntry*, TAddressRange& aMain, TAddressRange* aSecond, CBytePair* aBPE);
	void NextRom(TAddressRange* aFirst, TAddressRange* aSecond);
	TInt TranslateFiles();
	void EnumerateVariants();
	TUint32 AlignToChunk(TUint32 anAddr);
	TUint32 AlignToPage(TUint32 anAddr);
	TUint32 AllocVirtual(TUint32 aAddr,TUint aSize);
	TInt LoadDataToRom(TRomBuilderEntry *aFile, TAddressRange& aAddress, CBytePair* aBPE);
	void LoadFileToRom(TRomBuilderEntry *aFile);

	void Write(ofstream &of, TInt aHeaderType);		// main ROM image
	void WriteOdd(ofstream &of);					// odd halfwords
	void WriteEven(ofstream &of);					// even halfwords
	void WriteSRecord(ofstream &of);				// SREC or S19 format

	TInt LoadContents(char*& anAddr, TRomHeader* aHeader);
	TInt BuildDependenceGraph();
	TInt ResolveDllRefTables();
	TInt ResolveImports();
	TInt CreateExportDirectory();
	char *WriteDirectory(char *aAddr, TRomHeader* aHeader);
	TInt WriteHeadersToRom(char *anAddr);
	TInt RequiredSize();
	void SetCompressionInfo(TUint aCompressionType, TUint aCompressedSize, TUint aUncompressedSize);
	void FinaliseSectionHeader();
	void FinaliseExtensionHeader(MRomImage* aKernelRom);
	void DisplayExtensionHeader();
	void SetImageAddr(TAddressRange& aSet, TAny* aPtr, TUint32 aRunOffset=0);
	void SetImageAddr(TAddressRange& aSet, TUint aAddr, TUint32 aRunOffset=0);
	TInt CollapseImportThunks();
	TInt CollapseImportThunks(TRomBuilderEntry* aFile);
	TInt CollapseBranches();
	TInt CollapseBranches(TRomBuilderEntry* aFile);
	TUint32 FindFinalJumpDestination(TUint32 ja);

	char* AllocateRelocationTable(char* aAddr, TReloc*& aRelocTable);
	void FillInRelocationTable(TReloc* aRelocTable);

	void LinkKernelExtensions(TRomBuilderEntry* aExtArray[], TInt aExtCount);
	void FillInCrcs();
	void ProcessDllData();

	void CreatePageIndex(char*& aAddr);
	TInt CompressPages();
	TInt CompressPage(SRomPageInfo& aPageInfo, TInt aOutOffset, CBytePair * aBPE);

	// dependence graph
	void UnmarkGraph(TInt aMark=0xffffffff);
	void FindMarked(TInt aMarkMask, TInt aMark, TRomFile**& aList);
	TInt ProcessDependencies();
	void ListRouteTo(TRomFile* aStart, TRomFile* aDest, TInt aNDeps);

	void SetSmpFlags();
	
	// Check if the unpaged memory size overflows. For page enabled ROM only.
	TInt CheckUnpagedMemSize();
	
	// Initialize the page info prior to compression
	TInt SetupPages();

	Memmap *iImageMap;
public:
	char* iData;
	TInt iSize;
	TRomLoaderHeader *iLoaderHeader;
	TRomHeader *iHeader;
	TExtensionRomHeader *iExtensionRomHeader;		// NULL if not extension ROM
	//
	CObeyFile *iObey;

	char *iSectionPtr;
	
	//
	TInt iSizeUsed;
	TInt iUncompressedSize;
	TInt iOverhead;
	TInt iDirectorySize;
	TInt iImportsFixedUp;
	TInt iBranchesFixedUp;
	TInt iVtableEntriesFixedUp;
	//
	TUint32 iNextDataChunkBase;
	TUint32 iTotalSvDataSize;
	TUint32 iNextDllDataAddr;
	char* iPrevPrimaryAddress;
	char* iPrevVariantAddress;
	COrderedFileList** iVariantFileLists;
	TRomBuilderEntry** iPeFiles;
	};


#endif
