1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Implementation of e32 image creation and dump for elf2e32 tool

    15 // @internalComponent

    16 // @released

    17 // 

    18 //

    19 

    20 #include "pl_elfexecutable.h"

    21 

    22 // get E32ImageHeader class...

    23 #define INCLUDE_E32IMAGEHEADER_IMPLEMENTATION

    24 #define RETURN_FAILURE(_r) return (fprintf(stderr, "line %d\n", __LINE__),_r)

    25 //#define E32IMAGEHEADER_TRACE(_t) printf _t

    26 #include "e32imagefile.h"

    27 

    28 #include "pl_elfimportrelocation.h"

    29 #include "pl_elflocalrelocation.h"

    30 #include "pl_elfimports.h"

    31 #include "elffilesupplied.h"

    32 #include "pl_dllsymbol.h"

    33 #include "h_ver.h"

    34 #include "checksum.h"

    35 #include "errorhandler.h"

    36 

    37 #include <string>

    38 #include <vector>

    39 #include <cassert>

    40 #include <iostream>

    41 #ifndef __LINUX__ 

    42     #include <io.h>

    43 #else

    44     #include <time.h>

    45 #endif 

    46 #include <time.h>

    47 #include <stdio.h>

    48 

    49 using namespace std;

    50 

    51 template <class T> inline T Align(T v, size_t s)

    52 {

    53 	unsigned int inc = s-1;

    54 	unsigned int mask = ~inc;

    55 	unsigned int val = (unsigned int)v;

    56 	unsigned int res = (val+inc) & mask;

    57 	return (T)res;

    58 }

    59 

    60 // Need a default constructor for TVersion, but don't want all the other stuff in h_utl.cpp

    61 /**

    62 Default constructor for TVersion class.

    63 @internalComponent

    64 @released

    65 */

    66 TVersion::TVersion(){}

    67 

    68 /**

    69 Constructor for TVersion class.

    70 @internalComponent

    71 @released

    72 */

    73 TVersion::TVersion(TInt aMajor, TInt aMinor, TInt aBuild): 

    74 	iMajor((TInt8)aMajor), iMinor((TInt8)aMinor), iBuild((TInt16)aBuild)

    75 {

    76 }

    77 

    78 

    79 /**

    80 Constructor for E32ImageChunkDesc class.

    81 @internalComponent

    82 @released

    83 */

    84 E32ImageChunkDesc::E32ImageChunkDesc(char * aData, size_t aSize, size_t aOffset, char * aDoc):

    85 	iData(aData), iSize(aSize), iOffset(aOffset), iDoc(aDoc)

    86 {

    87 }

    88 

    89 /**

    90 Destructor for E32ImageChunkDesc class.

    91 @internalComponent

    92 @released

    93 */

    94 E32ImageChunkDesc::~E32ImageChunkDesc()

    95 {

    96 }

    97 

    98 /**

    99 This function writes its data in the buffer.

   100 @param aPlace - a location in the buffer

   101 @internalComponent

   102 @released

   103 */

   104 void E32ImageChunkDesc::Write(char * aPlace)

   105 {

   106 	memcpy(aPlace+iOffset, iData, iSize);

   107 }

   108 

   109 /**

   110 Constructor for E32ImageChunks class.

   111 @internalComponent

   112 @released

   113 */

   114 E32ImageChunks::E32ImageChunks(): 

   115 	iOffset(0)

   116 {

   117 }

   118 

   119 /**

   120 Destructor for E32ImageChunks class.

   121 @internalComponent

   122 @released

   123 */

   124 E32ImageChunks::~E32ImageChunks()

   125 {	

   126  	if(iChunks.size())

   127  	{

   128  		ChunkList::iterator aItr = iChunks.begin();

   129  		ChunkList::iterator last = iChunks.end();

   130  		E32ImageChunkDesc *temp;

   131  

   132  		while( aItr != last)

   133  		{

   134  			temp = *aItr;

   135  			aItr++;

   136  			delete temp;

   137  		}

   138  	}

   139 }

   140 

   141 /**

   142 This function creates and adds a chunk into a list.

   143 @param aData - input buffer

   144 @param asize - size of the input buffer

   145 @param aOffset - byte offset of this chunk from the 1 byte in e32 image file.

   146 @param aDoc - name of the chunk

   147 @internalComponent

   148 @released

   149 */

   150 void E32ImageChunks::AddChunk(char * aData, size_t aSize, size_t aOffset, char * aDoc)

   151 {

   152 	E32ImageChunkDesc * aChunk = new E32ImageChunkDesc(aData, aSize, aOffset, aDoc);

   153 	iChunks.push_back(aChunk);

   154 	iOffset += Align(aSize, sizeof(TUint32));

   155 }

   156 

   157 /**

   158 This function returns the list of chunks.

   159 @internalComponent

   160 @released

   161 */

   162 E32ImageChunks::ChunkList & E32ImageChunks::GetChunks()

   163 {

   164 	return iChunks;

   165 }

   166 

   167 /**

   168 This function returns the current offset pointing to the last chunk that

   169 was added into the list of chunks.

   170 @internalComponent

   171 @released

   172 */

   173 size_t E32ImageChunks::GetOffset()

   174 {

   175 	return iOffset;

   176 }

   177 

   178 /**

   179 This function sets the current offset pointing to the last chunk that 

   180 was added into the list of chunks.

   181 @internalComponent

   182 @released

   183 */

   184 void E32ImageChunks::SetOffset(size_t aOffset)

   185 {

   186 	iOffset = aOffset;

   187 }

   188 

   189 /**

   190 Constructor for E32ImageFile class.

   191 @internalComponent

   192 @released

   193 */

   194 E32ImageFile::E32ImageFile(const char * aFileName, ElfExecutable * aExecutable, ElfFileSupplied *aUseCase) :

   195 	iFileName(aFileName), 

   196 	iE32Image(0),

   197 	iExportBitMap(0),

   198 	iElfExecutable(aExecutable), 

   199 	iData(0),

   200 	iUseCase(aUseCase),

   201 	iHdr(0),

   202 	iHdrSize(sizeof(E32ImageHeaderV)),

   203 	iImportSection(0), 

   204 	iImportSectionSize(0),

   205 	iCodeRelocs(0), 

   206 	iCodeRelocsSize(0),

   207 	iDataRelocs(0), 

   208 	iDataRelocsSize(0),

   209 	iExportOffset(0),

   210 	iLayoutDone(false), 

   211 	iMissingExports(0),

   212 	iSymNameOffset(0)

   213 {

   214 }

   215 

   216 /**

   217 This function generates the E32 image.

   218 @internalComponent

   219 @released

   220 */

   221 void E32ImageFile::GenerateE32Image()

   222 {

   223 	if( iUseCase->GetNamedSymLookup() ){

   224 		ProcessSymbolInfo();

   225 	}

   226 	ProcessImports();

   227 	ProcessRelocations();

   228 	ConstructImage();

   229 }

   230 

   231 /**

   232 This function processes the import map by looking into the dso files

   233 from which the symbols are imported. It also fetches the ordinal numbers

   234 for the corresponding symbols.

   235 @internalComponent

   236 @released

   237 */

   238 void E32ImageFile::ProcessImports()

   239 {

   240 	string aStrTab;

   241 	vector<int> aStrTabOffsets;

   242 	int aNumDlls = 0;

   243 	int aNumImports = 0;

   244 	bool aNamedLookup = iUseCase->GetNamedSymLookup();

   245 	TUint aImportTabEntryPos = 0;

   246 

   247 	ElfImports::ImportMap aImportMap = iElfExecutable->GetImports();

   248 	ElfImports::ImportMap::iterator p;

   249 

   250 	// First set up the string table and record offsets into string table of each 

   251 	// LinkAs name.

   252 	for (p = aImportMap.begin(); p != aImportMap.end(); p++)

   253 	{

   254 		ElfImports::RelocationList & aImports = (*p).second;

   255 		char* aLinkAs = aImports[0]->iVerRecord->iLinkAs;

   256 

   257 		aStrTabOffsets.push_back(aStrTab.size()); // 

   258 		string s = aLinkAs;

   259 		aStrTab.insert(aStrTab.end(),s.begin(),s.end());

   260 		aStrTab.insert(aStrTab.end(),0);

   261 		aNumDlls++;

   262 		aNumImports += aImports.size();

   263 	}

   264 	

   265 	iNumDlls = aNumDlls;

   266 	iNumImports = aNumImports;

   267 

   268 	// Now we can figure out the size of everything

   269 	size_t aImportSectionSize = sizeof(E32ImportSection) + 

   270 								(sizeof(E32ImportBlock) * aNumDlls) +

   271 								(sizeof(unsigned int) * aNumImports);

   272  

   273 	vector<Elf32_Word> aImportSection;

   274 

   275 	// This is the 'E32ImportSection' header - fill with 0 for the moment

   276 	aImportSection.push_back(0);

   277 

   278 	if( aNamedLookup ) {

   279 		// These are the 0th ordinals imported into the import table, one

   280 		// entry for each DLL.

   281 		aImportSectionSize += (sizeof(unsigned int) * aNumDlls);

   282 	}

   283 	// Now fill in the E32ImportBlocks

   284 	int idx = 0;

   285 	char * aDsoName;

   286 	for (p = aImportMap.begin(); p != aImportMap.end(); p++, idx++)

   287 	{

   288 		ElfImports::RelocationList & aImports = (*p).second;

   289 		aDsoName = aImports[0]->iVerRecord->iSOName;

   290 

   291 		//const char * aDSO = FindDSO((*p).first);

   292 		const char * aDSO = FindDSO(aDsoName);

   293 

   294 		aImportSection.push_back(aStrTabOffsets[idx] + aImportSectionSize); 

   295 		int nImports = aImports.size();

   296 

   297 		// Take the additional 0th ordinal import into account

   298 		if( aNamedLookup )

   299 			nImports++;

   300 		aImportSection.push_back(nImports);

   301 

   302 		size_t aSize;

   303 		Elf32_Ehdr * aElfFile = 0;

   304 		ReadInputELFFile(aDSO, aSize, aElfFile);

   305 

   306 		ElfExecutable aElfExecutable(NULL);//(aElfFile, aSize);

   307 		aElfExecutable.ProcessElfFile(aElfFile);

   308 

   309 		ElfImports::RelocationList::iterator q;

   310 		for (q = aImports.begin(); q != aImports.end(); q++)

   311 		{

   312 			ElfImportRelocation * aReloc = *q;

   313 			char * aSymName = iElfExecutable->GetSymbolName(aReloc->iSymNdx);

   314 			unsigned int aOrdinal = aElfExecutable.GetSymbolOrdinal(aSymName);

   315 			

   316 			//check the reloc refers to Code Segment

   317 			try

   318 			{

   319 				if (iElfExecutable->SegmentType(aReloc->iAddr) != ESegmentRO)

   320 				{

   321 					throw ImportRelocationError(ILLEGALEXPORTFROMDATASEGMENT, aSymName, iElfExecutable->iParameterListInterface->ElfInput());

   322 				}

   323 			}

   324 			/**This catch block introduced here is to avoid deleting partially constructed object(s).

   325 			Otherwise global catch block will delete the partially constructed object(s) and the tool will crash.

   326 			*/

   327 			catch(ErrorHandler& aError)

   328 			{

   329 				aError.Report();

   330 				exit(EXIT_FAILURE);

   331 			}

   332 				

   333 			Elf32_Word aRelocOffset = iElfExecutable->GetRelocationOffset(aReloc);

   334 			aImportSection.push_back(aRelocOffset);

   335 

   336 			Elf32_Word * aRelocPlace = iElfExecutable->GetRelocationPlace(aReloc);

   337 			if (aOrdinal > 0xFFFF)

   338 			{

   339 			}

   340 			if (aReloc->iAddend > 0xFFFF)

   341 			{

   342 			}

   343 			* aRelocPlace = (aReloc->iAddend<<16) | aOrdinal;

   344 		}

   345 

   346 		if( aNamedLookup ) {

   347 			aImportTabEntryPos = aImportSection.size();

   348 			// Keep track of the location of the entry

   349 			iImportTabLocations.push_back(aImportTabEntryPos);

   350 			// Put the entry as 0 now, which shall be updated 

   351 			aImportSection.push_back(0);

   352 		}

   353 

   354 		delete [] ((char*)aElfFile);

   355 	}

   356 

   357 	assert(aImportSectionSize == aImportSection.size() * sizeof(Elf32_Word));

   358 

   359 	size_t aTotalSize = Align(aImportSectionSize + aStrTab.size(), sizeof(Elf32_Word));

   360 

   361 	// Fill in the section header now we have the correct value.

   362 	aImportSection[0] = aTotalSize;

   363 

   364 	// Now construct the unified section

   365 	iImportSectionSize = aTotalSize;

   366 	iImportSection = (uint32 *)new char[aTotalSize];

   367 	memset(iImportSection, 0, aTotalSize);

   368 	memcpy(iImportSection, aImportSection.begin(), aImportSectionSize);

   369 	char * strTab = ((char *)iImportSection) + aImportSectionSize;

   370 	memcpy(strTab, aStrTab.data(), aStrTab.size());

   371 

   372 }

   373 

   374 

   375 /**

   376 This function checks if a DSO file exists.

   377 @param aPath - DSO file name.

   378 @internalComponent

   379 @released

   380 */

   381 static bool ProbePath(string & aPath)

   382 {

   383 	ifstream aInput;

   384 	const char * p = aPath.c_str();

   385 	aInput.open(p);

   386 	if (aInput.is_open())

   387 	{

   388 		aInput.close();

   389 		return true;

   390 	}

   391 	else

   392 	{

   393 		return false;

   394 	}

   395 }

   396 

   397 /**

   398 This function allocates space for a DSO file name.

   399 @param aPath - DSO file name

   400 @internalComponent

   401 @released

   402 */

   403 const char * AllocatePath(string & aPath)

   404 {

   405 	const char * p = aPath.c_str();

   406 	size_t len = aPath.size();

   407 	char * result = new char[len+1];

   408 	strcpy(result, p);

   409 	return (const char *)result;

   410 }

   411 

   412 /**

   413 This function searches for a DSO in the libpath specified.

   414 @param aName - DSO file name

   415 @internalComponent

   416 @released

   417 */

   418 const char * E32ImageFile::FindDSO(const char * aName)

   419 {

   420 	string aDSOName(aName);

   421 	string aDSOPath(aName);

   422 

   423 	const char *aNewDsoName;

   424 

   425 	if (ProbePath(aDSOName))

   426 	{

   427 		aNewDsoName = AllocatePath(aDSOName);

   428 		cleanupStack.push_back((char*)aNewDsoName);

   429 		return aNewDsoName;

   430 	}

   431 

   432 	ParameterListInterface::LibSearchPaths & paths = iUseCase->GetLibSearchPaths();

   433 	ParameterListInterface::LibSearchPaths::iterator p = paths.begin();

   434 	for (; p != paths.end(); p++)

   435 	{

   436 		string path(*p);

   437 		char dir = iUseCase->GetDirectorySeparator();

   438 		aDSOPath.erase();

   439 		aDSOPath.insert(aDSOPath.end(), path.begin(), path.end());

   440 		aDSOPath.insert(aDSOPath.end(), dir);

   441 		aDSOPath.insert(aDSOPath.end(), aDSOName.begin(), aDSOName.end());

   442 		if (ProbePath(aDSOPath))

   443 		{

   444 			aNewDsoName = AllocatePath(aDSOPath);

   445 			cleanupStack.push_back((char*)aNewDsoName);

   446 			return aNewDsoName;

   447 		}

   448 	}

   449 	throw ELFFileError(DSONOTFOUNDERROR,(char*)aName);

   450 }

   451 

   452 void E32ImageFile::ReadInputELFFile(const char * aName, size_t & aFileSize, Elf32_Ehdr * & aELFFile )

   453 {

   454 	ifstream aInput;

   455 	aInput.open(aName, ifstream::binary|ifstream::in);

   456 	if (aInput.is_open()) 

   457 	{

   458 		aInput.seekg(0,ios::end);

   459 		aFileSize = (unsigned int) aInput.tellg();

   460 		aInput.seekg(0,ios::beg);

   461 		aELFFile = (Elf32_Ehdr *)new char [aFileSize];

   462 		aInput.read((char *)aELFFile, aFileSize);

   463 		aInput.close();

   464 	} 

   465 	else

   466 	{

   467 		throw FileError(FILEOPENERROR,(char*)aName);

   468 	}

   469 }

   470 

   471 /**

   472 This function processes relocations.

   473 @internalComponent

   474 @released

   475 */

   476 void E32ImageFile::ProcessRelocations()

   477 {

   478 	ProcessCodeRelocations();

   479 	ProcessDataRelocations();

   480 }

   481 

   482 /**

   483 This function processes Code relocations.

   484 @internalComponent

   485 @released

   486 */

   487 void E32ImageFile::ProcessCodeRelocations()

   488 {

   489 	CreateRelocations(iElfExecutable->GetCodeRelocations(), iCodeRelocs, iCodeRelocsSize);

   490 }

   491 

   492 /**

   493 This function processes Data relocations.

   494 @internalComponent

   495 @released

   496 */

   497 void E32ImageFile::ProcessDataRelocations()

   498 {

   499 	CreateRelocations(iElfExecutable->GetDataRelocations(), iDataRelocs, iDataRelocsSize);

   500 }

   501 

   502 /**

   503 This function creates Code and Data relocations from the corresponding

   504 ELF form to E32 form.

   505 @internalComponent

   506 @released

   507 */

   508 void E32ImageFile::CreateRelocations(ElfRelocations::RelocationList & aRelocList, char * & aRelocs, size_t & aRelocsSize)

   509 {

   510 	size_t rsize = RelocationsSize(aRelocList);

   511 	if (rsize)

   512 	{

   513 		aRelocsSize = Align(rsize + sizeof(E32RelocSection), sizeof(uint32));

   514 

   515 		uint32 aBase = (*aRelocList.begin())->iSegment->p_vaddr;

   516 		//add for cleanup to be done later..

   517 		cleanupStack.push_back(aRelocs);

   518 		aRelocs =	new char [aRelocsSize];

   519 		memset(aRelocs, 0, aRelocsSize);

   520 		E32RelocSection * aRelocSection = (E32RelocSection * )aRelocs;

   521 

   522 		uint16 * data = (uint16 *)(aRelocSection + 1);

   523 		E32RelocPageDesc * startofblock = (E32RelocPageDesc *)data;

   524 

   525 		int page = -1;

   526 		int pagesize = sizeof(E32RelocPageDesc);

   527 		ElfRelocations::RelocationList::iterator r;

   528 		for (r = aRelocList.begin(); r != aRelocList.end(); r++)

   529 		{

   530 			ElfLocalRelocation * aReloc = *r;

   531 			int p = aReloc->iAddr & 0xfffff000;

   532 			if (page != p)

   533 			{

   534 				if (pagesize%4 != 0)

   535 				{

   536 					*data++ = 0;

   537 					pagesize += sizeof(uint16);

   538 				}

   539 				if (page == -1) page = p;

   540 				startofblock->aOffset = page - aBase;

   541 				startofblock->aSize = pagesize;

   542 				pagesize = sizeof(E32RelocPageDesc);

   543 				page = p;

   544 				startofblock = (E32RelocPageDesc *)data;

   545 				data = (uint16 *)(startofblock + 1);

   546 			}

   547 			uint16 relocType = aReloc->Fixup();

   548 			*data++ = (uint16)((aReloc->iAddr & 0xfff) | relocType);

   549 			pagesize += sizeof(uint16);

   550 		}

   551 		if (pagesize%4 != 0)

   552 		{

   553 			*data++ = 0;

   554 			pagesize += sizeof(uint16);

   555 		}

   556 		startofblock->aOffset = page - aBase;

   557 		startofblock->aSize = pagesize;

   558 		((E32RelocSection *)aRelocs)->iNumberOfRelocs = aRelocList.size();

   559 		((E32RelocSection *)aRelocs)->iSize = rsize;

   560 

   561 	}

   562 }

   563 

   564 /**

   565 This function calculates the relocation taking into consideration

   566 the page boundaries if they are crossed. The relocations are

   567 sorted.

   568 @param aRelocList - relocations found in the Elf file.

   569 @internalComponent

   570 @released

   571 */

   572 size_t E32ImageFile::RelocationsSize(ElfRelocations::RelocationList & aRelocList)

   573 {

   574 	size_t bytecount = 0;

   575 	int page = -1;

   576 	ElfRelocations::RelocationList::iterator r;

   577 	for (r = aRelocList.begin(); r != aRelocList.end(); r++)

   578 	{

   579 		ElfLocalRelocation * aReloc = *r;

   580 		int p = aReloc->iAddr & 0xfffff000;

   581 		if (page != p)

   582 			{

   583 			if (bytecount%4 != 0)

   584 				bytecount += sizeof(uint16);

   585 			bytecount += sizeof(E32RelocPageDesc); // page, block size

   586 			page = p;

   587 			}

   588 		bytecount += sizeof(uint16);

   589 		}

   590 	if (bytecount%4 != 0)

   591 		bytecount += sizeof(uint16);

   592 	return bytecount;

   593 }

   594 

   595 /**

   596 This function returns the E32 interpretation for an Elf relocation type.

   597 @param aReloc - relocation entry.

   598 @internalComponent

   599 @released

   600 */

   601 E32ImageFile::uint16 E32ImageFile::GetE32RelocType(ElfRelocation * aReloc)

   602 {

   603 	ESegmentType aSegType = aReloc->iSegmentType; // iElfExecutable->SegmentType(aReloc->iSymbol->st_value);

   604 	switch (aSegType)

   605 	{

   606 	case ESegmentRO:

   607 		return KTextRelocType;

   608 	case ESegmentRW:

   609 		return KDataRelocType;

   610 	default:

   611 		break;

   612 	};

   613 

   614 	// maybe this should be an error

   615 	return KInferredRelocType;

   616 }

   617 

   618 /**

   619 This function constructs the E32 image.

   620 @internalComponent

   621 @released

   622 */

   623 void E32ImageFile::ConstructImage()

   624 {

   625 	InitE32ImageHeader();

   626 	ComputeE32ImageLayout();

   627 	FinalizeE32Image();

   628 	AllocateE32Image();

   629 }

   630 

   631 /**

   632 This function calculates the timestamp.

   633 @param aTime

   634 @internalComponent

   635 @released

   636 */

   637 Int64 timeToInt64(TInt aTime)

   638 {

   639 	aTime-=(30*365*24*60*60+7*24*60*60);	// seconds since midnight Jan 1st, 2000

   640 	Int64 daysTo2000AD=730497;

   641 	Int64 t=daysTo2000AD*24*3600+aTime;	// seconds since 0000

   642 	t=t+3600;								// BST (?)

   643 	return t*1000000;						// milliseconds

   644 }

   645 

   646 /**

   647 This function returns the E32 image header size.

   648 @internalComponent

   649 @released

   650 */

   651 size_t E32ImageFile::GetE32ImageHeaderSize()

   652 {

   653 	return sizeof(E32ImageHeaderV);

   654 }

   655 

   656 /**

   657 This function returns the extended E32 image header size.

   658 @internalComponent

   659 @released

   660 */

   661 size_t E32ImageFile::GetExtendedE32ImageHeaderSize()

   662 {

   663 	return iHdrSize;

   664 }

   665 

   666 /**

   667 This function sets the extended E32 image header size.

   668 @internalComponent

   669 @released

   670 */

   671 void E32ImageFile::SetExtendedE32ImageHeaderSize(size_t aSize)

   672 {

   673 	iHdrSize = aSize;

   674 }

   675 

   676 /**

   677 This function initialises the E32 image header fields.

   678 @internalComponent

   679 @released

   680 */

   681 void E32ImageFile::InitE32ImageHeader()

   682 {

   683 	iHdr = iUseCase->AllocateE32ImageHeader();

   684 	

   685 	iHdr->iUid1 = 0;

   686 	iHdr->iUid2 = 0;

   687 	iHdr->iUid3 = 0;

   688 	iHdr->iHeaderCrc = 0;

   689 	iHdr->iSignature = 0x434f5045u;

   690 	iHdr->iModuleVersion = 0x00010000u;

   691 	iHdr->iCompressionType = 0;

   692 	iHdr->iToolsVersion = TVersion(MajorVersion, MinorVersion, Build);

   693 	Int64 ltime(timeToInt64(time(0)));

   694 	iHdr->iTimeLo=(uint32)ltime;

   695 	iHdr->iTimeHi=(uint32)(ltime>>32);

   696 	iHdr->iFlags = KImageHdrFmt_V;

   697 	// Confusingly, CodeSize means everything except writable data

   698 	iHdr->iCodeSize = 0;

   699 	iHdr->iDataSize = iElfExecutable->GetRWSize();

   700 	iHdr->iHeapSizeMin = 0;

   701 	iHdr->iHeapSizeMax = 0;

   702 	iHdr->iStackSize = 0;

   703 	iHdr->iBssSize = iElfExecutable->GetBssSize();

   704 	iHdr->iEntryPoint = 0;

   705 	iHdr->iCodeBase = iElfExecutable->GetROBase();

   706 	iHdr->iDataBase = iElfExecutable->GetRWBase();

   707 	iHdr->iDllRefTableCount = iNumDlls;

   708 	iHdr->iExportDirOffset = 0;

   709 	iHdr->iExportDirCount = iUseCase->GetNumExports();

   710 	iHdr->iTextSize = iElfExecutable->GetROSize();

   711 	iHdr->iCodeOffset = 0;

   712 	iHdr->iDataOffset = 0;

   713 	iHdr->iImportOffset = 0;

   714 	iHdr->iCodeRelocOffset = 0;

   715 	iHdr->iDataRelocOffset = 0;

   716 	iHdr->iProcessPriority = (uint16)EPriorityForeground;

   717 	iHdr->iUncompressedSize = 0;

   718 	iHdr->iS.iSecureId = 0;

   719 	iHdr->iS.iVendorId = 0;

   720 	iHdr->iExceptionDescriptor = 0;

   721 	iHdr->iSpare2 = 0;

   722 

   723 	iHdr->iExportDescSize = iUseCase->GetExportDescSize();

   724 	iHdr->iExportDescType = iUseCase->GetExportDescType();

   725 	if (iHdr->iExportDescSize == 0) iHdr->iExportDesc[0] = 0;

   726 

   727 }

   728 

   729 /**

   730 This function creates the E32 image layout.

   731 @internalComponent

   732 @released

   733 */

   734 void E32ImageFile::ComputeE32ImageLayout()

   735 {

   736 	// E32Image header

   737 	iChunks.AddChunk((char *)iHdr, Align(GetExtendedE32ImageHeaderSize(), sizeof(uint32)), 0, "Image Header");

   738 

   739 	uint32 endOfHeader = iChunks.GetOffset();

   740 	

   741 		// Code section

   742 	iHdr->iCodeOffset = iChunks.GetOffset();

   743 	iChunks.AddChunk(iElfExecutable->GetRawROSegment(), iElfExecutable->GetROSize(), iHdr->iCodeOffset, "Code Section"); 

   744 	

   745 	// Exports Next - then we can set up CodeSize

   746 	// Call out to the use case so it can decide how we do this

   747 	// record exporttable offset for default case

   748 

   749 	bool aSymLkupEnabled = iUseCase->GetNamedSymLookup();

   750 	// The export table is required either when:

   751 	//	a. there are exported symbols

   752 	//	b. symbol lookup is enabled - because this table also indicates the dependencies

   753 	bool aExportTableNeeded = (iHdr->iExportDirCount || aSymLkupEnabled) ? 1 : 0;

   754 

   755 	iExportOffset = iChunks.GetOffset() + 4;

   756 	iHdr->iExportDirOffset = aExportTableNeeded ? iUseCase->GetExportOffset() : 0;

   757 	if ( aExportTableNeeded && iUseCase->AllocateExportTableP())

   758 		iChunks.AddChunk(iUseCase->GetExportTable(), iUseCase->GetExportTableSize(), iChunks.GetOffset(), "Export Table");

   759 

   760 	// Symbol info next

   761 	if( aSymLkupEnabled ){

   762 		E32EpocExpSymInfoHdr* aSymHdrInfo = (E32EpocExpSymInfoHdr*)CreateSymbolInfo(iChunks.GetOffset());

   763 		if( aSymHdrInfo )

   764 			iChunks.AddChunk( (char*)aSymHdrInfo, aSymHdrInfo->iSize, iChunks.GetOffset(), "Symbol Info" );

   765 	}

   766 

   767 	// CodeSize is current offset - endof header offset

   768 	iHdr->iTextSize = iHdr->iCodeSize = iChunks.GetOffset() - endOfHeader;

   769 

   770 	// Data section

   771 	if (iElfExecutable->GetRWSize())

   772 	{

   773 		iHdr->iDataOffset = iChunks.GetOffset();

   774 		iChunks.AddChunk(iElfExecutable->GetRawRWSegment(), iElfExecutable->GetRWSize(), iHdr->iDataOffset, "Data Section");

   775 	}

   776 	

   777 	// Import Section

   778 	if (iImportSectionSize)

   779 	{

   780 		iHdr->iImportOffset = iChunks.GetOffset();

   781 		iChunks.AddChunk((char *)iImportSection, iImportSectionSize, iHdr->iImportOffset, "Import Section");

   782 	}

   783 

   784 	// Code relocs

   785 	if (iCodeRelocsSize)

   786 	{

   787 		iHdr->iCodeRelocOffset = iChunks.GetOffset();

   788 		iChunks.AddChunk((char *)iCodeRelocs, iCodeRelocsSize, iHdr->iCodeRelocOffset, "Code Relocs");

   789 	}

   790 

   791 	// Data relocs

   792 	if (iDataRelocsSize)

   793 	{

   794 		iHdr->iDataRelocOffset = iChunks.GetOffset();

   795 		iChunks.AddChunk((char *)iDataRelocs, iDataRelocsSize, iHdr->iDataRelocOffset, "Data Relocs");

   796 	}

   797 

   798 	iLayoutDone = true;

   799 }

   800 

   801 /**

   802 This function returns the byte offset in the E32 image from where the

   803 export table starts.

   804 @internalComponent

   805 @released

   806 */

   807 size_t E32ImageFile::GetExportOffset()

   808 {

   809 	return iExportOffset;

   810 }

   811 

   812 /**

   813 This function returns E32 image size.

   814 @internalComponent

   815 @released

   816 */

   817 size_t E32ImageFile::GetE32ImageSize()

   818 {

   819 	assert(iLayoutDone);

   820 	return iChunks.GetOffset();

   821 

   822 }

   823 

   824 /**

   825 This function creates the export bitmap also replacing the absent symbols 

   826 with the entry point functions.

   827 @internalComponent

   828 @released

   829 */

   830 void E32ImageFile::CreateExportBitMap()

   831 {

   832 	int nexp = iUseCase->GetNumExports();

   833 	size_t memsz = (nexp + 7) >> 3;

   834 	iExportBitMap = new uint8[memsz];

   835 	memset(iExportBitMap, 0xff, memsz);

   836 	// skip header

   837 	uint32 * exports = ((uint32 *)iUseCase->GetExportTable()) + 1;

   838 	uint32 absentVal = EntryPointOffset() + iElfExecutable->GetROBase();

   839 	iMissingExports = 0;

   840 	for (int i=0; i<nexp; ++i)

   841 	{

   842 		if (exports[i] == absentVal)

   843 		{

   844 			iExportBitMap[i>>3] &= ~(1u << (i & 7));

   845 			++iMissingExports;

   846 		}

   847 	}

   848 }

   849 

   850 /**

   851 This function creates export desription for the absent symbols.

   852 @internalComponent

   853 @released

   854 */

   855 void E32ImageFile::AddExportDescription()

   856 {

   857 	CreateExportBitMap();

   858 	if (iMissingExports == 0)

   859 		return;	// nothing to do

   860 

   861 	int nexp = iUseCase->GetNumExports();

   862 	size_t memsz = (nexp + 7) >> 3;	// size of complete bitmap

   863 	size_t mbs = (memsz + 7) >> 3;	// size of meta-bitmap

   864 	size_t nbytes = 0;

   865 	unsigned int i;

   866 	for (i=0; i<memsz; ++i)

   867 		if (iExportBitMap[i] != 0xff)

   868 			++nbytes;				// number of groups of 8

   869 	uint8 edt = KImageHdr_ExpD_FullBitmap;

   870 	uint32 extra_space = memsz - 1;

   871 	if (mbs + nbytes < memsz)

   872 	{

   873 		edt = KImageHdr_ExpD_SparseBitmap8;

   874 		extra_space = mbs + nbytes - 1;

   875 	}

   876 	extra_space = (extra_space + sizeof(uint32) - 1) &~ (sizeof(uint32) - 1);

   877 

   878 	iHdr->iExportDescType = edt;

   879 	if (edt == KImageHdr_ExpD_FullBitmap)

   880 	{

   881 		iHdr->iExportDescSize = (uint16)memsz;

   882 		iHdr->iExportDesc[0] = iExportBitMap[0];

   883 		uint8 * aDesc = new uint8[extra_space];

   884 		memset(aDesc, 0, extra_space);

   885 		memcpy(aDesc, &iExportBitMap[1], memsz-1);

   886 		iChunks.AddChunk((char *)aDesc,extra_space, iChunks.GetOffset(), "Export Description");

   887 	}

   888 	else

   889 	{

   890 		iHdr->iExportDescSize = (uint16)(mbs + nbytes);

   891 		uint8 * aBuf = new uint8[extra_space + 1];

   892 		memset(aBuf , 0, extra_space + 1);

   893 		TUint8* mptr = aBuf;

   894 		TUint8* gptr = mptr + mbs;

   895 		for (i=0; i<memsz; ++i)

   896 		{

   897 			if (iExportBitMap[i] != 0xff)

   898 			{

   899 				mptr[i>>3] |= (1u << (i&7));

   900 				*gptr++ = iExportBitMap[i];

   901 			}

   902 		}

   903 		iHdr->iExportDesc[0] = aBuf[0];

   904 		uint8 * aDesc = new uint8[extra_space];

   905 		memcpy(aDesc, aBuf+1, extra_space);

   906 		delete[] aBuf;

   907 		iChunks.AddChunk((char *)aDesc,extra_space, iChunks.GetOffset(), "Export Description");

   908 	}

   909 }

   910 

   911 /**

   912 This function sets the fields of the E32 image.

   913 @internalComponent

   914 @released

   915 */

   916 void E32ImageFile::FinalizeE32Image()

   917 {

   918 	// Arrange a header for this E32 Image

   919 	iHdr->iCpuIdentifier = GetCpuIdentifier();

   920 	// Import format is ELF-derived

   921 	iHdr->iFlags |= KImageImpFmt_ELF;

   922 	// ABI is ARM EABI

   923 	iHdr->iFlags |= KImageABI_EABI;

   924 	iHdr->iFlags |= KImageEpt_Eka2;

   925 

   926 	bool isDllp = iUseCase->ImageIsDll();

   927 	if (isDllp)

   928 	{

   929 		iHdr->iFlags |= KImageDll;

   930 		if (iHdr->iDataSize && !iUseCase->AllowDllData())

   931 			throw ELFFileError(DLLHASINITIALISEDDATAERROR, (char*)iUseCase->InputElfFileName());

   932 

   933 		if (iHdr->iBssSize  && !iUseCase->AllowDllData())

   934 			throw ELFFileError(DLLHASUNINITIALISEDDATAERROR, (char*)iUseCase->InputElfFileName());

   935 

   936 	}

   937 

   938 	iHdr->iHeapSizeMin = iUseCase->HeapCommittedSize();

   939 	iHdr->iHeapSizeMax = iUseCase->HeapReservedSize();

   940 	iHdr->iStackSize = iUseCase->StackCommittedSize();

   941 

   942 

   943 	iHdr->iEntryPoint = EntryPointOffset();

   944 

   945 	EEntryPointStatus r = ValidateEntryPoint();

   946 	if (r == EEntryPointCorrupt)

   947 		throw ELFFileError(ENTRYPOINTCORRUPTERROR, (char*)iUseCase->InputElfFileName());

   948 	else if (r == EEntryPointNotSupported)

   949 		throw ELFFileError(ENTRYPOINTNOTSUPPORTEDERROR, (char*)iUseCase->InputElfFileName());

   950 

   951 	SetUpExceptions();

   952 	SetUids();

   953 	SetSecureId();

   954 	SetVendorId();

   955 	SetCallEntryPoints();

   956 	SetCapability();

   957 	SetPriority(isDllp);

   958 	SetFixedAddress(isDllp);

   959 	SetVersion();

   960 	SetCompressionType();

   961 	SetFPU();

   962 

   963 	SetPaged();

   964 

   965 	SetSymbolLookup();

   966 	SetDebuggable();

   967 	SetSmpSafe();

   968 	UpdateHeaderCrc();

   969 }

   970 

   971 /**

   972 This function returns the CPU identifier for the E32 image header.

   973 @internalComponent

   974 @released

   975 */

   976 E32ImageFile::uint16 E32ImageFile::GetCpuIdentifier()

   977 {

   978 	return (uint16)ECpuArmV5;

   979 }

   980 

   981 /**

   982 This function returns the entry point of the E32 image .

   983 @internalComponent

   984 @released

   985 */

   986 E32ImageFile::uint32 E32ImageFile::EntryPointOffset()

   987 {

   988 	return iElfExecutable->EntryPointOffset();

   989 }

   990 

   991 /**

   992 This function validates the entry point of the E32 image .

   993 @internalComponent

   994 @released

   995 */

   996 E32ImageFile::EEntryPointStatus E32ImageFile::ValidateEntryPoint()

   997 {

   998 	uint32 epOffset = iHdr->iEntryPoint;

   999 	if (epOffset & 3)

  1000 		return EEntryPointOK;	// if entry point not 4 byte aligned, must be old style

  1001 	uint32 fileOffset = epOffset + iElfExecutable->iCodeSegmentHdr->p_offset;

  1002 	if (fileOffset+4 > iChunks.GetOffset())

  1003 		return EEntryPointCorrupt;	// entry point is past the end of the file??

  1004 	int ept = 0;			// old style if first instruction not recognised

  1005 	uint8 * p = ELF_ENTRY_PTR(uint8, iElfExecutable->iElfHeader, fileOffset + 4);

  1006 	uint32 x = *--p;

  1007 	x<<=8;

  1008 	x|=*--p;

  1009 	x<<=8;

  1010 	x|=*--p;

  1011 	x<<=8;

  1012 	x|=*--p;

  1013 	if ((x & 0xffffff00) == 0xe31f0000)

  1014 	{

  1015 		// starts with tst pc, #n - new entry point

  1016 		ept = (x & 0xff) + 1;

  1017 	}

  1018 	if (ept>7)

  1019 		return EEntryPointNotSupported;

  1020 	iHdr->iFlags |= (ept<<KImageEptShift);

  1021 	return EEntryPointOK;

  1022 }

  1023 

  1024 /**

  1025 This function sets the exciption descriptor in the E32 image .

  1026 @internalComponent

  1027 @released

  1028 */

  1029 void E32ImageFile::SetUpExceptions()

  1030 {

  1031 	char * aExDescName = "Symbian$$CPP$$Exception$$Descriptor";

  1032 	Elf32_Sym * aSym = iElfExecutable->LookupStaticSymbol(aExDescName);

  1033 	if (aSym)

  1034 	{

  1035 		uint32 aSymVaddr = aSym->st_value;

  1036 		uint32 aROBase = iElfExecutable->GetROBase();

  1037 		uint32 aROSize = iElfExecutable->GetROSize();

  1038 		//check its in RO segment

  1039 		if (aSymVaddr < aROBase || aSymVaddr >= (aROBase + aROSize))

  1040 		{

  1041 			throw ELFFileError(EXCEPTIONDESCRIPTOROUTSIDEROERROR,(char*)iUseCase->InputElfFileName());

  1042 		}

  1043 		// Set bottom bit so 0 in header slot means an old binary.

  1044 		// The decriptor is always aligned on a 4 byte boundary.

  1045 		iHdr->iExceptionDescriptor = (aSymVaddr - aROBase) | 0x00000001;

  1046 	}	

  1047 }

  1048 

  1049 /**

  1050 This function sets the UIDs of the E32 image .

  1051 @internalComponent

  1052 @released

  1053 */

  1054 void E32ImageFile::SetUids()

  1055 {

  1056 	iHdr->iUid1=iUseCase->GetUid1();

  1057 	iHdr->iUid2=iUseCase->GetUid2();

  1058 	iHdr->iUid3=iUseCase->GetUid3();

  1059 }

  1060 

  1061 /**

  1062 This function sets the secure ID of the E32 image as passed in the command line.

  1063 @internalComponent

  1064 @released

  1065 */

  1066 void E32ImageFile::SetSecureId()

  1067 {

  1068 	if (iUseCase->GetSecureIdOption())

  1069 		iHdr->iS.iSecureId = iUseCase->GetSecureId();

  1070 	else

  1071 		iHdr->iS.iSecureId = iUseCase->GetUid3();

  1072 }

  1073 

  1074 /**

  1075 This function sets the vendor Id of the E32 image as passed in command line.

  1076 @internalComponent

  1077 @released

  1078 */

  1079 void E32ImageFile::SetVendorId()

  1080 {

  1081 	iHdr->iS.iVendorId = iUseCase->GetVendorId();

  1082 }

  1083 

  1084 /**

  1085 This function sets the call entry point of the E32 image .

  1086 @internalComponent

  1087 @released

  1088 */

  1089 void E32ImageFile::SetCallEntryPoints()

  1090 {

  1091 	if (iUseCase->GetCallEntryPoints())

  1092 		iHdr->iFlags|=KImageNoCallEntryPoint;

  1093 	else

  1094 		iHdr->iFlags&=~KImageNoCallEntryPoint;

  1095 }

  1096 

  1097 /**

  1098 This function sets the capcbility of the E32 image as specified in the command line.

  1099 @internalComponent

  1100 @released

  1101 */

  1102 void E32ImageFile::SetCapability()

  1103 {

  1104 	iHdr->iS.iCaps = iUseCase->GetCapability();

  1105 }

  1106 

  1107 /**

  1108 This function sets the priority of the E32 exe.

  1109 @internalComponent

  1110 @released

  1111 */

  1112 void E32ImageFile::SetPriority(bool isDllp)

  1113 {

  1114 	if (iUseCase->GetPriority())

  1115 	{

  1116 		if (isDllp)

  1117 		{

  1118 			cerr << "Warning: Cannot set priority of a DLL." << endl;

  1119 		}

  1120 		else

  1121 			iHdr->iProcessPriority = (unsigned short)iUseCase->GetPriority();

  1122 	}

  1123 }

  1124 

  1125 /**

  1126 This function sets the fixed address flag of the E32 image .

  1127 @internalComponent

  1128 @released

  1129 */

  1130 void E32ImageFile::SetFixedAddress(bool isDllp)

  1131 {

  1132 	if (iUseCase->GetFixedAddress())

  1133 	{

  1134 		if (isDllp)