// Copyright (c) 2005-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 the e32 image dump for the elf2e32 tool

// @internalComponent

// @released

// 

//

#define __REFERENCE_CAPABILITY_NAMES__

#include "e32imagefile.h"

#include "pl_common.h"

#include <string.h>

#include <stdarg.h>

#include <stdio.h>

#ifdef __LINUX__ 

    #define VSNPRINTF vsnprintf

#else 

    #define VSNPRINTF _vsnprintf

#endif 

using std::cout;

const TInt KMaxStringLength=0x400;

/**

Variadic Function to print string.

@internalComponent

@released

@param aFmt

Formatted string.

*/

void PrintString(const char *aFmt,...)

{

	char imageText[KMaxStringLength];

	va_list list;

	va_start(list,aFmt);

	VSNPRINTF((char *)imageText,KMaxStringLength,aFmt,list);

	va_end(list);

	cout << imageText;

	cout.flush();

}

/**

Function to set priority.

@internalComponent

@released

@param aPri

Priority Type passed in

@param aStr

The priority value corresponding to the appropriate priority type

*/

void PriorityToStr(TProcessPriority aPri, char *aStr)

{

	if (aPri==EPrioritySupervisor)

		strcpy(aStr,"Supervisor");

	else if (aPri>EPriorityRealTimeServer)

		sprintf(aStr, "RealTime+%d", aPri-EPriorityRealTimeServer);

	else if (aPri==EPriorityRealTimeServer)

		strcpy(aStr,"RealTime");

	else if (aPri>EPriorityFileServer)

		sprintf(aStr, "FileServer+%d", aPri-EPriorityFileServer);

	else if (aPri==EPriorityFileServer)

		strcpy(aStr,"FileServer");

	else if (aPri>EPriorityWindowServer)

		sprintf(aStr, "WindowServer+%d", aPri-EPriorityWindowServer);

	else if (aPri==EPriorityWindowServer)

		strcpy(aStr,"WindowServer");

	else if (aPri>EPriorityHigh)

		sprintf(aStr, "High+%d", aPri-EPriorityHigh);

	else if (aPri==EPriorityHigh)

		strcpy(aStr,"High");

	else if (aPri>EPriorityForeground)

		sprintf(aStr, "Foreground+%d", aPri-EPriorityForeground);

	else if (aPri==EPriorityForeground)

		strcpy(aStr,"Foreground");

	else if (aPri>EPriorityBackground)

		sprintf(aStr, "Background+%d", aPri-EPriorityBackground);

	else if (aPri==EPriorityBackground)

		strcpy(aStr,"Background");

	else if (aPri>EPriorityLow)

		sprintf(aStr, "Low+%d", aPri-EPriorityLow);

	else if (aPri==EPriorityLow)

		strcpy(aStr,"Low");

	else

		sprintf(aStr, "Illegal (%d)", aPri);

}

/**

Function to dump e32 image.

@internalComponent

@released

@param aFileName

Name of the E32image to be dumped.

@param aDumpFlags

sub options passed to the 'dump' option

*/

void E32ImageFile::Dump(const char* aFileName,TInt aDumpFlags)

{

	PrintString("E32ImageFile '%s'\n", aFileName);

	DumpHeader(aDumpFlags);

	DumpData(aDumpFlags);

}

/**

Function to dump e32 image header.

@internalComponent

@released

@param aDumpFlags

The flags set based on the sub options provided to the program.

*/

void E32ImageFile::DumpHeader(TInt aDumpFlags)

{

	TUint flags = iOrigHdr->iFlags;

	TUint abi = E32ImageHeader::ABIFromFlags(flags);

	TUint hdrfmt = E32ImageHeader::HdrFmtFromFlags(flags);

	TUint impfmt = E32ImageHeader::ImpFmtFromFlags(flags);

	TUint ept = E32ImageHeader::EptFromFlags(flags);

	TBool isARM = EFalse;

	if(aDumpFlags&EDumpHeader)

	{

		PrintString("V%d.%02d(%03d)", iOrigHdr->iToolsVersion.iMajor,iOrigHdr->iToolsVersion.iMinor,iOrigHdr->iToolsVersion.iBuild);

		PrintString("\tTime Stamp: %08x,%08x\n", iOrigHdr->iTimeHi, iOrigHdr->iTimeLo);

		char sig[5];

		memcpy(sig, (const char*)&iOrigHdr->iSignature, 4);

		sig[4]=0;

		PrintString(sig);

		if (iOrigHdr->iFlags&KImageDll)

			PrintString(" Dll for ");

		else

			PrintString(" Exe for ");

		switch (iOrigHdr->CpuIdentifier())

		{

		case ECpuX86:

			PrintString("X86 CPU\n");

			break;

		case ECpuArmV4:

			isARM = ETrue;

			PrintString("ARMV4 CPU\n");

			break;

		case ECpuArmV5:

			isARM = ETrue;

			PrintString("ARMV5 CPU\n");

			break;

		case ECpuMCore:

			PrintString("M*Core CPU\n");

			break;

		case ECpuUnknown:

			PrintString("Unknown CPU\n");

			break;

		default:

			PrintString("something or other\n");

			break;

		}

		PrintString("Flags:\t%08x\n", flags);

		if (!(flags & KImageDll))

		{

			char str[80];

			PriorityToStr(iOrigHdr->ProcessPriority(), str);

			PrintString("Priority %s\n", str);

			if (flags & KImageFixedAddressExe)

				PrintString("Fixed process\n");

		}

		if (flags & KImageNoCallEntryPoint)

			PrintString("Entry points are not called\n");

		PrintString("Image header is format %d\n", hdrfmt>>24);

		TUint compression = iOrigHdr->CompressionType();

		switch (compression)

		{

		case KFormatNotCompressed:

			PrintString("Image is not compressed\n");

			break;

		case KUidCompressionDeflate:

			PrintString("Image is compressed using the DEFLATE algorithm\n");

			break;

		case KUidCompressionBytePair:

			PrintString("Image is compressed using the BYTEPAIR algorithm\n");

			break;

		default:

			PrintString("Image compression type UNKNOWN (%08x)\n", compression);

		}

		if (compression)

		{

			PrintString("Uncompressed size %08x\n", iOrigHdr->UncompressedFileSize());

		}

		TUint FPU = flags & KImageHWFloatMask;

		if (FPU == KImageHWFloat_None)

			PrintString("Image FPU support : Soft VFP\n");

		else if (FPU == KImageHWFloat_VFPv2) 

			PrintString("Image FPU support : VFPv2\n");

		else

			PrintString("Image FPU support : Unknown\n");

		// Code paging.

		if (flags & KImageCodeUnpaged)

		{

			PrintString("Code Paging : Unpaged\n");

		}

		else if (flags & KImageCodePaged)

		{

			PrintString("Code Paging : Paged\n");

		}

		else

		{

			PrintString("Code Paging : Default\n");

		}

		// Data paging.

		if (flags & KImageDataUnpaged)

		{

			PrintString("Data Paging : Unpaged\n");

		}

		else if (flags & KImageDataPaged)

		{

			PrintString("Data Paging : Paged\n");

		}

		else

		{

			PrintString("Data Paging : Default\n");

		}

		if (iOrigHdr->iFlags & KImageDebuggable)

		{

			PrintString("Debuggable : True\n");

		}

		else

		{

			PrintString("Debuggable : False\n");

		}

		if (iOrigHdr->iFlags & KImageSMPSafe)

		{

			PrintString("SMP Safe : True\n");

		}

		else

		{

			PrintString("SMP Safe : False\n");

		}

	}

	if (hdrfmt >= KImageHdrFmt_V && (aDumpFlags&(EDumpHeader|EDumpSecurityInfo)))

	{

		//

		// Important. Don't change output format of following security info

		// because this is relied on by used by "Symbian Signed".

		//

		E32ImageHeaderV* v = iHdr;

		PrintString("Secure ID: %08x\n", v->iS.iSecureId);

		PrintString("Vendor ID: %08x\n", v->iS.iVendorId);

		PrintString("Capabilities: %08x %08x\n", v->iS.iCaps[1], v->iS.iCaps[0]);

		if(aDumpFlags&EDumpSecurityInfo)

		{

			TInt i;

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

				if(v->iS.iCaps[i>>5]&(1<<(i&31)))

					PrintString("              %s\n", CapabilityNames[i]);

			PrintString("\n");

		}

	}

	if(aDumpFlags&EDumpHeader)

	{

		if (hdrfmt >= KImageHdrFmt_V)

		{

			E32ImageHeaderV* v = iHdr;

			TUint32 xd = v->iExceptionDescriptor;

			if ((xd & 1) && (xd != 0xffffffffu))

			{

				xd &= ~1;

				PrintString("Exception Descriptor Offset:  %08x\n", v->iExceptionDescriptor);

				TExceptionDescriptor * aED = (TExceptionDescriptor * )(iData + v->iCodeOffset + xd);

				PrintString("Exception Index Table Base: %08x\n", aED->iExIdxBase);

				PrintString("Exception Index Table Limit: %08x\n", aED->iExIdxLimit);

				PrintString("RO Segment Base: %08x\n", aED->iROSegmentBase);

				PrintString("RO Segment Limit: %08x\n", aED->iROSegmentLimit);

			}

			else

				PrintString("No Exception Descriptor\n");

			PrintString("Export Description: Size=%03x, Type=%02x\n", v->iExportDescSize, v->iExportDescType);

			if (v->iExportDescType != KImageHdr_ExpD_NoHoles)

			{

				TInt nb = v->iExportDescSize;

				TInt i;

				TInt j = 0;

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

				{

					if (++j == 8)

					{

						j = 0;

						PrintString("\n");

					}

					PrintString(" %02x", v->iExportDesc[i]);

				}

				PrintString("\n");

			}

			TInt r = CheckExportDescription();

			if (r == KErrNone)

				PrintString("Export description consistent\n");

			else if (r == KErrNotSupported)

				PrintString("Export description type not recognised\n");

			else

				PrintString("!! Export description inconsistent !!\n");

		}

		TUint32 mv = iOrigHdr->ModuleVersion();

		PrintString("Module Version: %d.%d\n", mv>>16, mv&0xffff);

		if (impfmt == KImageImpFmt_PE)

		{

			PrintString("Imports are PE-style\n");

		}

		else if (impfmt == KImageImpFmt_ELF)

		{

			PrintString("Imports are ELF-style\n");

		}

		else if (impfmt == KImageImpFmt_PE2)

		{

			PrintString("Imports are PE-style without redundant ordinal lists\n");

		}

		if (isARM)

		{

			if (abi == KImageABI_GCC98r2)

			{

				PrintString("GCC98r2 ABI\n");

			}

			else if (abi == KImageABI_EABI)

			{

				PrintString("ARM EABI\n");

			}

			if (ept == KImageEpt_Eka1)

			{

				PrintString("Built against EKA1\n");

			}

			else if (ept == KImageEpt_Eka2)

			{

				PrintString("Built against EKA2\n");

			}

		}

		PrintString("Uids:\t\t%08x %08x %08x (%08x)\n", iOrigHdr->iUid1, iOrigHdr->iUid2, iOrigHdr->iUid3, iOrigHdr->iUidChecksum);

		if (hdrfmt >= KImageHdrFmt_V)

			PrintString("Header CRC:\t%08x\n", iHdr->iHeaderCrc);

		PrintString("File Size:\t%08x\n", iSize);

		PrintString("Code Size:\t%08x\n", iOrigHdr->iCodeSize);

		PrintString("Data Size:\t%08x\n", iOrigHdr->iDataSize);

		PrintString("Compression:\t%08x\n", iOrigHdr->iCompressionType);

		PrintString("Min Heap Size:\t%08x\n", iOrigHdr->iHeapSizeMin);

		PrintString("Max Heap Size:\t%08x\n", iOrigHdr->iHeapSizeMax);

		PrintString("Stack Size:\t%08x\n", iOrigHdr->iStackSize);

		PrintString("Code link addr:\t%08x\n", iOrigHdr->iCodeBase);

		PrintString("Data link addr:\t%08x\n", iOrigHdr->iDataBase);

		PrintString("Code reloc offset:\t%08x\n", OrigCodeRelocOffset());

		PrintString("Data reloc offset:\t%08x\n", OrigDataRelocOffset());

		PrintString("Dll ref table count: %d\n", iOrigHdr->iDllRefTableCount);

		if (iOrigHdr->iCodeSize || iOrigHdr->iDataSize || iOrigHdr->iBssSize || iOrigHdr->iImportOffset)

			PrintString("        Offset  Size  Relocs #Relocs\n");

		PrintString("Code    %06x %06x", OrigCodeOffset(), iOrigHdr->iCodeSize);

		if (iOrigHdr->iCodeRelocOffset)

		{

			E32RelocSection *r=(E32RelocSection *)(iData + iOrigHdr->iCodeRelocOffset);

			PrintString(" %06x %06x", OrigCodeRelocOffset(), r->iNumberOfRelocs);

		}

		else

			PrintString("              ");

		PrintString("        +%06x (entry pnt)", iOrigHdr->iEntryPoint);

		PrintString("\n");

		PrintString("Data    %06x %06x", OrigDataOffset(), iOrigHdr->iDataSize);

		if (iOrigHdr->iDataRelocOffset)

		{

			E32RelocSection *r=(E32RelocSection *)(iData + iOrigHdr->iDataRelocOffset);

			PrintString(" %06x %06x", OrigDataRelocOffset(), r->iNumberOfRelocs);

		}

		PrintString("\n");

		PrintString("Bss            %06x\n", iOrigHdr->iBssSize);

		if (iOrigHdr->iExportDirOffset)

			PrintString("Export  %06x %06x                      (%d entries)\n", OrigExportDirOffset(), iOrigHdr->iExportDirCount*4, iOrigHdr->iExportDirCount);

		if (iOrigHdr->iImportOffset)

			PrintString("Import  %06x\n", OrigImportOffset());

	}

}

/**

Function to dump e32 image.

@internalComponent

@released

@param aData

Data to be dumped

@param aLength

Length of the file

*/

void dump(TUint *aData, TInt aLength)

{

	TUint *p=aData;

	TInt i=0;

	char line[256];

	char *cp=(char*)aData;

	TInt j=0;

	memset(line,' ',sizeof(line));

	while (i<aLength)

	{

		TInt ccount=0;

		char* linep=&line[8*9+2];

		PrintString("%06x:", i);

		while (i<aLength && ccount<8)

		{

			PrintString(" %08x", *p++);

			i+=4;

			ccount++;

			for (j=0; j<4; j++)

			{

				char c=*cp++;

				if (c<32 || c>127)

				{

					c = '.';

				}

				*linep++ = c;

			}

		}

		*linep='\0';

		PrintString("%s", line+(ccount*9));

		PrintString("\n");

	}

}

/**

Function to dump relocations.

@internalComponent

@released

@param aRelocs

Character pointer to relocations.

*/

void dumprelocs(char *aRelocs)

{

	TInt num=((E32RelocSection *)aRelocs)->iNumberOfRelocs;

	PrintString("%d relocs\n", num);

	aRelocs+=sizeof(E32RelocSection);

	TInt printed=0;

	while (num>0)

	{

		TInt page=*(TUint *)aRelocs;

		TInt size=*(TUint *)(aRelocs+4);

		TInt pagesize=size;

		size-=8;

		TUint16 *p=(TUint16 *)(aRelocs+8);

		while (size>0)

		{

			TUint a=*p++;

			TUint relocType = (a & 0x3000) >> 12;

			if ((relocType == 1) || (relocType == 3)) //only relocation type1 and type3

			{

				PrintString("%08x(%d) ", page + (a&0x0fff), relocType);

				printed++;

				if (printed>3)

				{

					PrintString("\n");

					printed=0;

				}

			}

			size-=2;

			num--;

		}

		aRelocs+=pagesize;

	}

	PrintString("\n");

}

/**

Function to dump e32 image data.