--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/toolsandutils/e32tools/elf2e32/source/e32imagefile.cpp Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,1994 @@
+// Copyright (c) 2004-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 e32 image creation and dump for elf2e32 tool
+// @internalComponent
+// @released
+//
+//
+
+#include "pl_elfexecutable.h"
+
+// get E32ImageHeader class...
+#define INCLUDE_E32IMAGEHEADER_IMPLEMENTATION
+#define RETURN_FAILURE(_r) return (fprintf(stderr, "line %d\n", __LINE__),_r)
+//#define E32IMAGEHEADER_TRACE(_t) printf _t
+#include "e32imagefile.h"
+
+#include "pl_elfimportrelocation.h"
+#include "pl_elflocalrelocation.h"
+#include "pl_elfimports.h"
+#include "elffilesupplied.h"
+#include "pl_dllsymbol.h"
+#include "h_ver.h"
+#include "checksum.h"
+#include "errorhandler.h"
+
+#include <string>
+#include <vector>
+#include <cassert>
+#include <iostream>
+#ifndef __LINUX__
+ #include <io.h>
+#else
+ #include <time.h>
+#endif
+#include <time.h>
+#include <stdio.h>
+
+using namespace std;
+
+template <class T> inline T Align(T v, size_t s)
+{
+ unsigned int inc = s-1;
+ unsigned int mask = ~inc;
+ unsigned int val = (unsigned int)v;
+ unsigned int res = (val+inc) & mask;
+ return (T)res;
+}
+
+// Need a default constructor for TVersion, but don't want all the other stuff in h_utl.cpp
+/**
+Default constructor for TVersion class.
+@internalComponent
+@released
+*/
+TVersion::TVersion(){}
+
+/**
+Constructor for TVersion class.
+@internalComponent
+@released
+*/
+TVersion::TVersion(TInt aMajor, TInt aMinor, TInt aBuild):
+ iMajor((TInt8)aMajor), iMinor((TInt8)aMinor), iBuild((TInt16)aBuild)
+{
+}
+
+
+/**
+Constructor for E32ImageChunkDesc class.
+@internalComponent
+@released
+*/
+E32ImageChunkDesc::E32ImageChunkDesc(char * aData, size_t aSize, size_t aOffset, char * aDoc):
+ iData(aData), iSize(aSize), iOffset(aOffset), iDoc(aDoc)
+{
+}
+
+/**
+Destructor for E32ImageChunkDesc class.
+@internalComponent
+@released
+*/
+E32ImageChunkDesc::~E32ImageChunkDesc()
+{
+}
+
+/**
+This function writes its data in the buffer.
+@param aPlace - a location in the buffer
+@internalComponent
+@released
+*/
+void E32ImageChunkDesc::Write(char * aPlace)
+{
+ memcpy(aPlace+iOffset, iData, iSize);
+}
+
+/**
+Constructor for E32ImageChunks class.
+@internalComponent
+@released
+*/
+E32ImageChunks::E32ImageChunks():
+ iOffset(0)
+{
+}
+
+/**
+Destructor for E32ImageChunks class.
+@internalComponent
+@released
+*/
+E32ImageChunks::~E32ImageChunks()
+{
+ if(iChunks.size())
+ {
+ ChunkList::iterator aItr = iChunks.begin();
+ ChunkList::iterator last = iChunks.end();
+ E32ImageChunkDesc *temp;
+
+ while( aItr != last)
+ {
+ temp = *aItr;
+ aItr++;
+ delete temp;
+ }
+ }
+}
+
+/**
+This function creates and adds a chunk into a list.
+@param aData - input buffer
+@param asize - size of the input buffer
+@param aOffset - byte offset of this chunk from the 1 byte in e32 image file.
+@param aDoc - name of the chunk
+@internalComponent
+@released
+*/
+void E32ImageChunks::AddChunk(char * aData, size_t aSize, size_t aOffset, char * aDoc)
+{
+ E32ImageChunkDesc * aChunk = new E32ImageChunkDesc(aData, aSize, aOffset, aDoc);
+ iChunks.push_back(aChunk);
+ iOffset += Align(aSize, sizeof(TUint32));
+}
+
+/**
+This function returns the list of chunks.
+@internalComponent
+@released
+*/
+E32ImageChunks::ChunkList & E32ImageChunks::GetChunks()
+{
+ return iChunks;
+}
+
+/**
+This function returns the current offset pointing to the last chunk that
+was added into the list of chunks.
+@internalComponent
+@released
+*/
+size_t E32ImageChunks::GetOffset()
+{
+ return iOffset;
+}
+
+/**
+This function sets the current offset pointing to the last chunk that
+was added into the list of chunks.
+@internalComponent
+@released
+*/
+void E32ImageChunks::SetOffset(size_t aOffset)
+{
+ iOffset = aOffset;
+}
+
+/**
+Constructor for E32ImageFile class.
+@internalComponent
+@released
+*/
+E32ImageFile::E32ImageFile(const char * aFileName, ElfExecutable * aExecutable, ElfFileSupplied *aUseCase) :
+ iFileName(aFileName),
+ iE32Image(0),
+ iExportBitMap(0),
+ iElfExecutable(aExecutable),
+ iData(0),
+ iUseCase(aUseCase),
+ iHdr(0),
+ iHdrSize(sizeof(E32ImageHeaderV)),
+ iImportSection(0),
+ iImportSectionSize(0),
+ iCodeRelocs(0),
+ iCodeRelocsSize(0),
+ iDataRelocs(0),
+ iDataRelocsSize(0),
+ iExportOffset(0),
+ iLayoutDone(false),
+ iMissingExports(0),
+ iSymNameOffset(0)
+{
+}
+
+/**
+This function generates the E32 image.
+@internalComponent
+@released
+*/
+void E32ImageFile::GenerateE32Image()
+{
+ if( iUseCase->GetNamedSymLookup() ){
+ ProcessSymbolInfo();
+ }
+ ProcessImports();
+ ProcessRelocations();
+ ConstructImage();
+}
+
+/**
+This function processes the import map by looking into the dso files
+from which the symbols are imported. It also fetches the ordinal numbers
+for the corresponding symbols.
+@internalComponent
+@released
+*/
+void E32ImageFile::ProcessImports()
+{
+ string aStrTab;
+ vector<int> aStrTabOffsets;
+ int aNumDlls = 0;
+ int aNumImports = 0;
+ bool aNamedLookup = iUseCase->GetNamedSymLookup();
+ TUint aImportTabEntryPos = 0;
+
+ ElfImports::ImportMap aImportMap = iElfExecutable->GetImports();
+ ElfImports::ImportMap::iterator p;
+
+ // First set up the string table and record offsets into string table of each
+ // LinkAs name.
+ for (p = aImportMap.begin(); p != aImportMap.end(); p++)
+ {
+ ElfImports::RelocationList & aImports = (*p).second;
+ char* aLinkAs = aImports[0]->iVerRecord->iLinkAs;
+
+ aStrTabOffsets.push_back(aStrTab.size()); //
+ string s = aLinkAs;
+ aStrTab.insert(aStrTab.end(),s.begin(),s.end());
+ aStrTab.insert(aStrTab.end(),0);
+ aNumDlls++;
+ aNumImports += aImports.size();
+ }
+
+ iNumDlls = aNumDlls;
+ iNumImports = aNumImports;
+
+ // Now we can figure out the size of everything
+ size_t aImportSectionSize = sizeof(E32ImportSection) +
+ (sizeof(E32ImportBlock) * aNumDlls) +
+ (sizeof(unsigned int) * aNumImports);
+
+ vector<Elf32_Word> aImportSection;
+
+ // This is the 'E32ImportSection' header - fill with 0 for the moment
+ aImportSection.push_back(0);
+
+ if( aNamedLookup ) {
+ // These are the 0th ordinals imported into the import table, one
+ // entry for each DLL.
+ aImportSectionSize += (sizeof(unsigned int) * aNumDlls);
+ }
+ // Now fill in the E32ImportBlocks
+ int idx = 0;
+ char * aDsoName;
+ for (p = aImportMap.begin(); p != aImportMap.end(); p++, idx++)
+ {
+ ElfImports::RelocationList & aImports = (*p).second;
+ aDsoName = aImports[0]->iVerRecord->iSOName;
+
+ //const char * aDSO = FindDSO((*p).first);
+ const char * aDSO = FindDSO(aDsoName);
+
+ aImportSection.push_back(aStrTabOffsets[idx] + aImportSectionSize);
+ int nImports = aImports.size();
+
+ // Take the additional 0th ordinal import into account
+ if( aNamedLookup )
+ nImports++;
+ aImportSection.push_back(nImports);
+
+ size_t aSize;
+ Elf32_Ehdr * aElfFile = 0;
+ ReadInputELFFile(aDSO, aSize, aElfFile);
+
+ ElfExecutable aElfExecutable(NULL);//(aElfFile, aSize);
+ aElfExecutable.ProcessElfFile(aElfFile);
+
+ ElfImports::RelocationList::iterator q;
+ for (q = aImports.begin(); q != aImports.end(); q++)
+ {
+ ElfImportRelocation * aReloc = *q;
+ char * aSymName = iElfExecutable->GetSymbolName(aReloc->iSymNdx);
+ unsigned int aOrdinal = aElfExecutable.GetSymbolOrdinal(aSymName);
+
+ //check the reloc refers to Code Segment
+ try
+ {
+ if (iElfExecutable->SegmentType(aReloc->iAddr) != ESegmentRO)
+ {
+ throw ImportRelocationError(ILLEGALEXPORTFROMDATASEGMENT, aSymName, iElfExecutable->iParameterListInterface->ElfInput());
+ }
+ }
+ /**This catch block introduced here is to avoid deleting partially constructed object(s).
+ Otherwise global catch block will delete the partially constructed object(s) and the tool will crash.
+ */
+ catch(ErrorHandler& aError)
+ {
+ aError.Report();
+ exit(EXIT_FAILURE);
+ }
+
+ Elf32_Word aRelocOffset = iElfExecutable->GetRelocationOffset(aReloc);
+ aImportSection.push_back(aRelocOffset);
+
+ Elf32_Word * aRelocPlace = iElfExecutable->GetRelocationPlace(aReloc);
+ if (aOrdinal > 0xFFFF)
+ {
+ }
+ if (aReloc->iAddend > 0xFFFF)
+ {
+ }
+ * aRelocPlace = (aReloc->iAddend<<16) | aOrdinal;
+ }
+
+ if( aNamedLookup ) {
+ aImportTabEntryPos = aImportSection.size();
+ // Keep track of the location of the entry
+ iImportTabLocations.push_back(aImportTabEntryPos);
+ // Put the entry as 0 now, which shall be updated
+ aImportSection.push_back(0);
+ }
+
+ delete [] ((char*)aElfFile);
+ }
+
+ assert(aImportSectionSize == aImportSection.size() * sizeof(Elf32_Word));
+
+ size_t aTotalSize = Align(aImportSectionSize + aStrTab.size(), sizeof(Elf32_Word));
+
+ // Fill in the section header now we have the correct value.
+ aImportSection[0] = aTotalSize;
+
+ // Now construct the unified section
+ iImportSectionSize = aTotalSize;
+ iImportSection = (uint32 *)new char[aTotalSize];
+ memset(iImportSection, 0, aTotalSize);
+ memcpy(iImportSection, aImportSection.begin(), aImportSectionSize);
+ char * strTab = ((char *)iImportSection) + aImportSectionSize;
+ memcpy(strTab, aStrTab.data(), aStrTab.size());
+
+}
+
+
+/**
+This function checks if a DSO file exists.
+@param aPath - DSO file name.
+@internalComponent
+@released
+*/
+static bool ProbePath(string & aPath)
+{
+ ifstream aInput;
+ const char * p = aPath.c_str();
+ aInput.open(p);
+ if (aInput.is_open())
+ {
+ aInput.close();
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+/**
+This function allocates space for a DSO file name.
+@param aPath - DSO file name
+@internalComponent
+@released
+*/
+const char * AllocatePath(string & aPath)
+{
+ const char * p = aPath.c_str();
+ size_t len = aPath.size();
+ char * result = new char[len+1];
+ strcpy(result, p);
+ return (const char *)result;
+}
+
+/**
+This function searches for a DSO in the libpath specified.
+@param aName - DSO file name
+@internalComponent
+@released
+*/
+const char * E32ImageFile::FindDSO(const char * aName)
+{
+ string aDSOName(aName);
+ string aDSOPath(aName);
+
+ const char *aNewDsoName;
+
+ if (ProbePath(aDSOName))
+ {
+ aNewDsoName = AllocatePath(aDSOName);
+ cleanupStack.push_back((char*)aNewDsoName);
+ return aNewDsoName;
+ }
+
+ ParameterListInterface::LibSearchPaths & paths = iUseCase->GetLibSearchPaths();
+ ParameterListInterface::LibSearchPaths::iterator p = paths.begin();
+ for (; p != paths.end(); p++)
+ {
+ string path(*p);
+ char dir = iUseCase->GetDirectorySeparator();
+ aDSOPath.erase();
+ aDSOPath.insert(aDSOPath.end(), path.begin(), path.end());
+ aDSOPath.insert(aDSOPath.end(), dir);
+ aDSOPath.insert(aDSOPath.end(), aDSOName.begin(), aDSOName.end());
+ if (ProbePath(aDSOPath))
+ {
+ aNewDsoName = AllocatePath(aDSOPath);
+ cleanupStack.push_back((char*)aNewDsoName);
+ return aNewDsoName;
+ }
+ }
+ throw ELFFileError(DSONOTFOUNDERROR,(char*)aName);
+}
+
+void E32ImageFile::ReadInputELFFile(const char * aName, size_t & aFileSize, Elf32_Ehdr * & aELFFile )
+{
+ ifstream aInput;
+ aInput.open(aName, ifstream::binary|ifstream::in);
+ if (aInput.is_open())
+ {
+ aInput.seekg(0,ios::end);
+ aFileSize = (unsigned int) aInput.tellg();
+ aInput.seekg(0,ios::beg);
+ aELFFile = (Elf32_Ehdr *)new char [aFileSize];
+ aInput.read((char *)aELFFile, aFileSize);
+ aInput.close();
+ }
+ else
+ {
+ throw FileError(FILEOPENERROR,(char*)aName);
+ }
+}
+
+/**
+This function processes relocations.
+@internalComponent
+@released
+*/
+void E32ImageFile::ProcessRelocations()
+{
+ ProcessCodeRelocations();
+ ProcessDataRelocations();
+}
+
+/**
+This function processes Code relocations.
+@internalComponent
+@released
+*/
+void E32ImageFile::ProcessCodeRelocations()
+{
+ CreateRelocations(iElfExecutable->GetCodeRelocations(), iCodeRelocs, iCodeRelocsSize);
+}
+
+/**
+This function processes Data relocations.
+@internalComponent
+@released
+*/
+void E32ImageFile::ProcessDataRelocations()
+{
+ CreateRelocations(iElfExecutable->GetDataRelocations(), iDataRelocs, iDataRelocsSize);
+}
+
+/**
+This function creates Code and Data relocations from the corresponding
+ELF form to E32 form.
+@internalComponent
+@released
+*/
+void E32ImageFile::CreateRelocations(ElfRelocations::RelocationList & aRelocList, char * & aRelocs, size_t & aRelocsSize)
+{
+ size_t rsize = RelocationsSize(aRelocList);
+ if (rsize)
+ {
+ aRelocsSize = Align(rsize + sizeof(E32RelocSection), sizeof(uint32));
+
+ uint32 aBase = (*aRelocList.begin())->iSegment->p_vaddr;
+ //add for cleanup to be done later..
+ cleanupStack.push_back(aRelocs);
+ aRelocs = new char [aRelocsSize];
+ memset(aRelocs, 0, aRelocsSize);
+ E32RelocSection * aRelocSection = (E32RelocSection * )aRelocs;
+
+ uint16 * data = (uint16 *)(aRelocSection + 1);
+ E32RelocPageDesc * startofblock = (E32RelocPageDesc *)data;
+
+ int page = -1;
+ int pagesize = sizeof(E32RelocPageDesc);
+ ElfRelocations::RelocationList::iterator r;
+ for (r = aRelocList.begin(); r != aRelocList.end(); r++)
+ {
+ ElfLocalRelocation * aReloc = *r;
+ int p = aReloc->iAddr & 0xfffff000;
+ if (page != p)
+ {
+ if (pagesize%4 != 0)
+ {
+ *data++ = 0;
+ pagesize += sizeof(uint16);
+ }
+ if (page == -1) page = p;
+ startofblock->aOffset = page - aBase;
+ startofblock->aSize = pagesize;
+ pagesize = sizeof(E32RelocPageDesc);
+ page = p;
+ startofblock = (E32RelocPageDesc *)data;
+ data = (uint16 *)(startofblock + 1);
+ }
+ uint16 relocType = aReloc->Fixup();
+ *data++ = (uint16)((aReloc->iAddr & 0xfff) | relocType);
+ pagesize += sizeof(uint16);
+ }
+ if (pagesize%4 != 0)
+ {
+ *data++ = 0;
+ pagesize += sizeof(uint16);
+ }
+ startofblock->aOffset = page - aBase;
+ startofblock->aSize = pagesize;
+ ((E32RelocSection *)aRelocs)->iNumberOfRelocs = aRelocList.size();
+ ((E32RelocSection *)aRelocs)->iSize = rsize;
+
+ }
+}
+
+/**
+This function calculates the relocation taking into consideration
+the page boundaries if they are crossed. The relocations are
+sorted.
+@param aRelocList - relocations found in the Elf file.
+@internalComponent
+@released
+*/
+size_t E32ImageFile::RelocationsSize(ElfRelocations::RelocationList & aRelocList)
+{
+ size_t bytecount = 0;
+ int page = -1;
+ ElfRelocations::RelocationList::iterator r;
+ for (r = aRelocList.begin(); r != aRelocList.end(); r++)
+ {
+ ElfLocalRelocation * aReloc = *r;
+ int p = aReloc->iAddr & 0xfffff000;
+ if (page != p)
+ {
+ if (bytecount%4 != 0)
+ bytecount += sizeof(uint16);
+ bytecount += sizeof(E32RelocPageDesc); // page, block size
+ page = p;
+ }
+ bytecount += sizeof(uint16);
+ }
+ if (bytecount%4 != 0)
+ bytecount += sizeof(uint16);
+ return bytecount;
+}
+
+/**
+This function returns the E32 interpretation for an Elf relocation type.
+@param aReloc - relocation entry.
+@internalComponent
+@released
+*/
+E32ImageFile::uint16 E32ImageFile::GetE32RelocType(ElfRelocation * aReloc)
+{
+ ESegmentType aSegType = aReloc->iSegmentType; // iElfExecutable->SegmentType(aReloc->iSymbol->st_value);
+ switch (aSegType)
+ {
+ case ESegmentRO:
+ return KTextRelocType;
+ case ESegmentRW:
+ return KDataRelocType;
+ default:
+ break;
+ };
+
+ // maybe this should be an error
+ return KInferredRelocType;
+}
+
+/**
+This function constructs the E32 image.
+@internalComponent
+@released
+*/
+void E32ImageFile::ConstructImage()
+{
+ InitE32ImageHeader();
+ ComputeE32ImageLayout();
+ FinalizeE32Image();
+ AllocateE32Image();
+}
+
+/**
+This function calculates the timestamp.
+@param aTime
+@internalComponent
+@released
+*/
+Int64 timeToInt64(TInt aTime)
+{
+ aTime-=(30*365*24*60*60+7*24*60*60); // seconds since midnight Jan 1st, 2000
+ Int64 daysTo2000AD=730497;
+ Int64 t=daysTo2000AD*24*3600+aTime; // seconds since 0000
+ t=t+3600; // BST (?)
+ return t*1000000; // milliseconds
+}
+
+/**
+This function returns the E32 image header size.
+@internalComponent
+@released
+*/
+size_t E32ImageFile::GetE32ImageHeaderSize()
+{
+ return sizeof(E32ImageHeaderV);
+}
+
+/**
+This function returns the extended E32 image header size.
+@internalComponent
+@released
+*/
+size_t E32ImageFile::GetExtendedE32ImageHeaderSize()
+{
+ return iHdrSize;
+}
+
+/**
+This function sets the extended E32 image header size.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetExtendedE32ImageHeaderSize(size_t aSize)
+{
+ iHdrSize = aSize;
+}
+
+/**
+This function initialises the E32 image header fields.
+@internalComponent
+@released
+*/
+void E32ImageFile::InitE32ImageHeader()
+{
+ iHdr = iUseCase->AllocateE32ImageHeader();
+
+ iHdr->iUid1 = 0;
+ iHdr->iUid2 = 0;
+ iHdr->iUid3 = 0;
+ iHdr->iHeaderCrc = 0;
+ iHdr->iSignature = 0x434f5045u;
+ iHdr->iModuleVersion = 0x00010000u;
+ iHdr->iCompressionType = 0;
+ iHdr->iToolsVersion = TVersion(MajorVersion, MinorVersion, Build);
+ Int64 ltime(timeToInt64(time(0)));
+ iHdr->iTimeLo=(uint32)ltime;
+ iHdr->iTimeHi=(uint32)(ltime>>32);
+ iHdr->iFlags = KImageHdrFmt_V;
+ // Confusingly, CodeSize means everything except writable data
+ iHdr->iCodeSize = 0;
+ iHdr->iDataSize = iElfExecutable->GetRWSize();
+ iHdr->iHeapSizeMin = 0;
+ iHdr->iHeapSizeMax = 0;
+ iHdr->iStackSize = 0;
+ iHdr->iBssSize = iElfExecutable->GetBssSize();
+ iHdr->iEntryPoint = 0;
+ iHdr->iCodeBase = iElfExecutable->GetROBase();
+ iHdr->iDataBase = iElfExecutable->GetRWBase();
+ iHdr->iDllRefTableCount = iNumDlls;
+ iHdr->iExportDirOffset = 0;
+ iHdr->iExportDirCount = iUseCase->GetNumExports();
+ iHdr->iTextSize = iElfExecutable->GetROSize();
+ iHdr->iCodeOffset = 0;
+ iHdr->iDataOffset = 0;
+ iHdr->iImportOffset = 0;
+ iHdr->iCodeRelocOffset = 0;
+ iHdr->iDataRelocOffset = 0;
+ iHdr->iProcessPriority = (uint16)EPriorityForeground;
+ iHdr->iUncompressedSize = 0;
+ iHdr->iS.iSecureId = 0;
+ iHdr->iS.iVendorId = 0;
+ iHdr->iExceptionDescriptor = 0;
+ iHdr->iSpare2 = 0;
+
+ iHdr->iExportDescSize = iUseCase->GetExportDescSize();
+ iHdr->iExportDescType = iUseCase->GetExportDescType();
+ if (iHdr->iExportDescSize == 0) iHdr->iExportDesc[0] = 0;
+
+}
+
+/**
+This function creates the E32 image layout.
+@internalComponent
+@released
+*/
+void E32ImageFile::ComputeE32ImageLayout()
+{
+ // E32Image header
+ iChunks.AddChunk((char *)iHdr, Align(GetExtendedE32ImageHeaderSize(), sizeof(uint32)), 0, "Image Header");
+
+ uint32 endOfHeader = iChunks.GetOffset();
+
+ // Code section
+ iHdr->iCodeOffset = iChunks.GetOffset();
+ iChunks.AddChunk(iElfExecutable->GetRawROSegment(), iElfExecutable->GetROSize(), iHdr->iCodeOffset, "Code Section");
+
+ // Exports Next - then we can set up CodeSize
+ // Call out to the use case so it can decide how we do this
+ // record exporttable offset for default case
+
+ bool aSymLkupEnabled = iUseCase->GetNamedSymLookup();
+ // The export table is required either when:
+ // a. there are exported symbols
+ // b. symbol lookup is enabled - because this table also indicates the dependencies
+ bool aExportTableNeeded = (iHdr->iExportDirCount || aSymLkupEnabled) ? 1 : 0;
+
+ iExportOffset = iChunks.GetOffset() + 4;
+ iHdr->iExportDirOffset = aExportTableNeeded ? iUseCase->GetExportOffset() : 0;
+ if ( aExportTableNeeded && iUseCase->AllocateExportTableP())
+ iChunks.AddChunk(iUseCase->GetExportTable(), iUseCase->GetExportTableSize(), iChunks.GetOffset(), "Export Table");
+
+ // Symbol info next
+ if( aSymLkupEnabled ){
+ E32EpocExpSymInfoHdr* aSymHdrInfo = (E32EpocExpSymInfoHdr*)CreateSymbolInfo(iChunks.GetOffset());
+ if( aSymHdrInfo )
+ iChunks.AddChunk( (char*)aSymHdrInfo, aSymHdrInfo->iSize, iChunks.GetOffset(), "Symbol Info" );
+ }
+
+ // CodeSize is current offset - endof header offset
+ iHdr->iTextSize = iHdr->iCodeSize = iChunks.GetOffset() - endOfHeader;
+
+ // Data section
+ if (iElfExecutable->GetRWSize())
+ {
+ iHdr->iDataOffset = iChunks.GetOffset();
+ iChunks.AddChunk(iElfExecutable->GetRawRWSegment(), iElfExecutable->GetRWSize(), iHdr->iDataOffset, "Data Section");
+ }
+
+ // Import Section
+ if (iImportSectionSize)
+ {
+ iHdr->iImportOffset = iChunks.GetOffset();
+ iChunks.AddChunk((char *)iImportSection, iImportSectionSize, iHdr->iImportOffset, "Import Section");
+ }
+
+ // Code relocs
+ if (iCodeRelocsSize)
+ {
+ iHdr->iCodeRelocOffset = iChunks.GetOffset();
+ iChunks.AddChunk((char *)iCodeRelocs, iCodeRelocsSize, iHdr->iCodeRelocOffset, "Code Relocs");
+ }
+
+ // Data relocs
+ if (iDataRelocsSize)
+ {
+ iHdr->iDataRelocOffset = iChunks.GetOffset();
+ iChunks.AddChunk((char *)iDataRelocs, iDataRelocsSize, iHdr->iDataRelocOffset, "Data Relocs");
+ }
+
+ iLayoutDone = true;
+}
+
+/**
+This function returns the byte offset in the E32 image from where the
+export table starts.
+@internalComponent
+@released
+*/
+size_t E32ImageFile::GetExportOffset()
+{
+ return iExportOffset;
+}
+
+/**
+This function returns E32 image size.
+@internalComponent
+@released
+*/
+size_t E32ImageFile::GetE32ImageSize()
+{
+ assert(iLayoutDone);
+ return iChunks.GetOffset();
+
+}
+
+/**
+This function creates the export bitmap also replacing the absent symbols
+with the entry point functions.
+@internalComponent
+@released
+*/
+void E32ImageFile::CreateExportBitMap()
+{
+ int nexp = iUseCase->GetNumExports();
+ size_t memsz = (nexp + 7) >> 3;
+ iExportBitMap = new uint8[memsz];
+ memset(iExportBitMap, 0xff, memsz);
+ // skip header
+ uint32 * exports = ((uint32 *)iUseCase->GetExportTable()) + 1;
+ uint32 absentVal = EntryPointOffset() + iElfExecutable->GetROBase();
+ iMissingExports = 0;
+ for (int i=0; i<nexp; ++i)
+ {
+ if (exports[i] == absentVal)
+ {
+ iExportBitMap[i>>3] &= ~(1u << (i & 7));
+ ++iMissingExports;
+ }
+ }
+}
+
+/**
+This function creates export desription for the absent symbols.
+@internalComponent
+@released
+*/
+void E32ImageFile::AddExportDescription()
+{
+ CreateExportBitMap();
+ if (iMissingExports == 0)
+ return; // nothing to do
+
+ int nexp = iUseCase->GetNumExports();
+ size_t memsz = (nexp + 7) >> 3; // size of complete bitmap
+ size_t mbs = (memsz + 7) >> 3; // size of meta-bitmap
+ size_t nbytes = 0;
+ unsigned int i;
+ for (i=0; i<memsz; ++i)
+ if (iExportBitMap[i] != 0xff)
+ ++nbytes; // number of groups of 8
+ uint8 edt = KImageHdr_ExpD_FullBitmap;
+ uint32 extra_space = memsz - 1;
+ if (mbs + nbytes < memsz)
+ {
+ edt = KImageHdr_ExpD_SparseBitmap8;
+ extra_space = mbs + nbytes - 1;
+ }
+ extra_space = (extra_space + sizeof(uint32) - 1) &~ (sizeof(uint32) - 1);
+
+ iHdr->iExportDescType = edt;
+ if (edt == KImageHdr_ExpD_FullBitmap)
+ {
+ iHdr->iExportDescSize = (uint16)memsz;
+ iHdr->iExportDesc[0] = iExportBitMap[0];
+ uint8 * aDesc = new uint8[extra_space];
+ memset(aDesc, 0, extra_space);
+ memcpy(aDesc, &iExportBitMap[1], memsz-1);
+ iChunks.AddChunk((char *)aDesc,extra_space, iChunks.GetOffset(), "Export Description");
+ }
+ else
+ {
+ iHdr->iExportDescSize = (uint16)(mbs + nbytes);
+ uint8 * aBuf = new uint8[extra_space + 1];
+ memset(aBuf , 0, extra_space + 1);
+ TUint8* mptr = aBuf;
+ TUint8* gptr = mptr + mbs;
+ for (i=0; i<memsz; ++i)
+ {
+ if (iExportBitMap[i] != 0xff)
+ {
+ mptr[i>>3] |= (1u << (i&7));
+ *gptr++ = iExportBitMap[i];
+ }
+ }
+ iHdr->iExportDesc[0] = aBuf[0];
+ uint8 * aDesc = new uint8[extra_space];
+ memcpy(aDesc, aBuf+1, extra_space);
+ delete[] aBuf;
+ iChunks.AddChunk((char *)aDesc,extra_space, iChunks.GetOffset(), "Export Description");
+ }
+}
+
+/**
+This function sets the fields of the E32 image.
+@internalComponent
+@released
+*/
+void E32ImageFile::FinalizeE32Image()
+{
+ // Arrange a header for this E32 Image
+ iHdr->iCpuIdentifier = GetCpuIdentifier();
+ // Import format is ELF-derived
+ iHdr->iFlags |= KImageImpFmt_ELF;
+ // ABI is ARM EABI
+ iHdr->iFlags |= KImageABI_EABI;
+ iHdr->iFlags |= KImageEpt_Eka2;
+
+ bool isDllp = iUseCase->ImageIsDll();
+ if (isDllp)
+ {
+ iHdr->iFlags |= KImageDll;
+ if (iHdr->iDataSize && !iUseCase->AllowDllData())
+ throw ELFFileError(DLLHASINITIALISEDDATAERROR, (char*)iUseCase->InputElfFileName());
+
+ if (iHdr->iBssSize && !iUseCase->AllowDllData())
+ throw ELFFileError(DLLHASUNINITIALISEDDATAERROR, (char*)iUseCase->InputElfFileName());
+
+ }
+
+ iHdr->iHeapSizeMin = iUseCase->HeapCommittedSize();
+ iHdr->iHeapSizeMax = iUseCase->HeapReservedSize();
+ iHdr->iStackSize = iUseCase->StackCommittedSize();
+
+
+ iHdr->iEntryPoint = EntryPointOffset();
+
+ EEntryPointStatus r = ValidateEntryPoint();
+ if (r == EEntryPointCorrupt)
+ throw ELFFileError(ENTRYPOINTCORRUPTERROR, (char*)iUseCase->InputElfFileName());
+ else if (r == EEntryPointNotSupported)
+ throw ELFFileError(ENTRYPOINTNOTSUPPORTEDERROR, (char*)iUseCase->InputElfFileName());
+
+ SetUpExceptions();
+ SetUids();
+ SetSecureId();
+ SetVendorId();
+ SetCallEntryPoints();
+ SetCapability();
+ SetPriority(isDllp);
+ SetFixedAddress(isDllp);
+ SetVersion();
+ SetCompressionType();
+ SetFPU();
+
+ SetPaged();
+
+ SetSymbolLookup();
+ SetDebuggable();
+ SetSmpSafe();
+ UpdateHeaderCrc();
+}
+
+/**
+This function returns the CPU identifier for the E32 image header.
+@internalComponent
+@released
+*/
+E32ImageFile::uint16 E32ImageFile::GetCpuIdentifier()
+{
+ return (uint16)ECpuArmV5;
+}
+
+/**
+This function returns the entry point of the E32 image .
+@internalComponent
+@released
+*/
+E32ImageFile::uint32 E32ImageFile::EntryPointOffset()
+{
+ return iElfExecutable->EntryPointOffset();
+}
+
+/**
+This function validates the entry point of the E32 image .
+@internalComponent
+@released
+*/
+E32ImageFile::EEntryPointStatus E32ImageFile::ValidateEntryPoint()
+{
+ uint32 epOffset = iHdr->iEntryPoint;
+ if (epOffset & 3)
+ return EEntryPointOK; // if entry point not 4 byte aligned, must be old style
+ uint32 fileOffset = epOffset + iElfExecutable->iCodeSegmentHdr->p_offset;
+ if (fileOffset+4 > iChunks.GetOffset())
+ return EEntryPointCorrupt; // entry point is past the end of the file??
+ int ept = 0; // old style if first instruction not recognised
+ uint8 * p = ELF_ENTRY_PTR(uint8, iElfExecutable->iElfHeader, fileOffset + 4);
+ uint32 x = *--p;
+ x<<=8;
+ x|=*--p;
+ x<<=8;
+ x|=*--p;
+ x<<=8;
+ x|=*--p;
+ if ((x & 0xffffff00) == 0xe31f0000)
+ {
+ // starts with tst pc, #n - new entry point
+ ept = (x & 0xff) + 1;
+ }
+ if (ept>7)
+ return EEntryPointNotSupported;
+ iHdr->iFlags |= (ept<<KImageEptShift);
+ return EEntryPointOK;
+}
+
+/**
+This function sets the exciption descriptor in the E32 image .
+@internalComponent
+@released
+*/
+void E32ImageFile::SetUpExceptions()
+{
+ char * aExDescName = "Symbian$$CPP$$Exception$$Descriptor";
+ Elf32_Sym * aSym = iElfExecutable->LookupStaticSymbol(aExDescName);
+ if (aSym)
+ {
+ uint32 aSymVaddr = aSym->st_value;
+ uint32 aROBase = iElfExecutable->GetROBase();
+ uint32 aROSize = iElfExecutable->GetROSize();
+ //check its in RO segment
+ if (aSymVaddr < aROBase || aSymVaddr >= (aROBase + aROSize))
+ {
+ throw ELFFileError(EXCEPTIONDESCRIPTOROUTSIDEROERROR,(char*)iUseCase->InputElfFileName());
+ }
+ // Set bottom bit so 0 in header slot means an old binary.
+ // The decriptor is always aligned on a 4 byte boundary.
+ iHdr->iExceptionDescriptor = (aSymVaddr - aROBase) | 0x00000001;
+ }
+}
+
+/**
+This function sets the UIDs of the E32 image .
+@internalComponent
+@released
+*/
+void E32ImageFile::SetUids()
+{
+ iHdr->iUid1=iUseCase->GetUid1();
+ iHdr->iUid2=iUseCase->GetUid2();
+ iHdr->iUid3=iUseCase->GetUid3();
+}
+
+/**
+This function sets the secure ID of the E32 image as passed in the command line.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetSecureId()
+{
+ if (iUseCase->GetSecureIdOption())
+ iHdr->iS.iSecureId = iUseCase->GetSecureId();
+ else
+ iHdr->iS.iSecureId = iUseCase->GetUid3();
+}
+
+/**
+This function sets the vendor Id of the E32 image as passed in command line.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetVendorId()
+{
+ iHdr->iS.iVendorId = iUseCase->GetVendorId();
+}
+
+/**
+This function sets the call entry point of the E32 image .
+@internalComponent
+@released
+*/
+void E32ImageFile::SetCallEntryPoints()
+{
+ if (iUseCase->GetCallEntryPoints())
+ iHdr->iFlags|=KImageNoCallEntryPoint;
+ else
+ iHdr->iFlags&=~KImageNoCallEntryPoint;
+}
+
+/**
+This function sets the capcbility of the E32 image as specified in the command line.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetCapability()
+{
+ iHdr->iS.iCaps = iUseCase->GetCapability();
+}
+
+/**
+This function sets the priority of the E32 exe.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetPriority(bool isDllp)
+{
+ if (iUseCase->GetPriority())
+ {
+ if (isDllp)
+ {
+ cerr << "Warning: Cannot set priority of a DLL." << endl;
+ }
+ else
+ iHdr->iProcessPriority = (unsigned short)iUseCase->GetPriority();
+ }
+}
+
+/**
+This function sets the fixed address flag of the E32 image .
+@internalComponent
+@released
+*/
+void E32ImageFile::SetFixedAddress(bool isDllp)
+{
+ if (iUseCase->GetFixedAddress())
+ {
+ if (isDllp)
+ {
+ cerr << "Warning: Cannot set fixed address for DLL." << endl;
+ }
+ else
+ iHdr->iFlags|=KImageFixedAddressExe;
+ }
+ else
+ iHdr->iFlags&=~KImageFixedAddressExe;
+}
+
+/**
+This function sets the version of the E32 image .
+@internalComponent
+@released
+*/
+void E32ImageFile::SetVersion()
+{
+ iHdr->iModuleVersion = iUseCase->GetVersion();
+}
+
+/**
+This function sets the compression type of the E32 image .
+@internalComponent
+@released
+*/
+void E32ImageFile::SetCompressionType()
+{
+ if(iUseCase->GetCompress())
+ iHdr->iCompressionType = iUseCase->GetCompressionMethod();
+ else
+ iHdr->iCompressionType = KFormatNotCompressed;
+
+}
+
+/**
+This function sets the FPU type that the E32 image targets .
+@internalComponent
+@released
+*/
+void E32ImageFile::SetFPU()
+{
+ iHdr->iFlags &=~ KImageHWFloatMask;
+
+ if (iUseCase->GetFPU() == 1)
+ iHdr->iFlags |= KImageHWFloat_VFPv2;
+}
+
+/**
+This function sets the paging attribute in the E32 image.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetPaged()
+{
+ // Code paging.
+
+ if ( iUseCase->IsCodePaged() )
+ {
+ iHdr->iFlags |= KImageCodePaged;
+ iHdr->iFlags &= ~KImageCodeUnpaged;
+ }
+ else if ( iUseCase->IsCodeUnpaged() )
+ {
+ iHdr->iFlags |= KImageCodeUnpaged;
+ iHdr->iFlags &= ~KImageCodePaged;
+ }
+ else if ( iUseCase->IsCodeDefaultPaged() )
+ {
+ iHdr->iFlags &= ~KImageCodePaged;
+ iHdr->iFlags &= ~KImageCodeUnpaged;
+ }
+
+ // Data paging.
+
+ if ( iUseCase->IsDataPaged() )
+ {
+ iHdr->iFlags |= KImageDataPaged;
+ iHdr->iFlags &= ~KImageDataUnpaged;
+ }
+ else if ( iUseCase->IsDataUnpaged() )
+ {
+ iHdr->iFlags |= KImageDataUnpaged;
+ iHdr->iFlags &= ~KImageDataPaged;
+ }
+ else if ( iUseCase->IsDataDefaultPaged() )
+ {
+ iHdr->iFlags &= ~KImageDataPaged;
+ iHdr->iFlags &= ~KImageDataUnpaged;
+ }
+}
+
+/**
+This function sets the Debuggable attribute in the E32 image.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetDebuggable()
+{
+ if (iUseCase->IsDebuggable() == true)
+ {
+ iHdr->iFlags |= KImageDebuggable;
+ }
+ else
+ {
+ iHdr->iFlags &= ~KImageDebuggable;
+ }
+}
+
+
+void E32ImageFile::SetSmpSafe()
+{
+ if ( iUseCase->IsSmpSafe() )
+ {
+ iHdr->iFlags |= KImageSMPSafe;
+ }
+ else
+ {
+ iHdr->iFlags &= ~KImageSMPSafe;
+ }
+}
+
+/**
+This function sets the named symol-lookup attribute in the E32 image.
+@internalComponent
+@released
+*/
+void E32ImageFile::SetSymbolLookup()
+{
+ if(iUseCase->GetNamedSymLookup())
+ {
+ iHdr->iFlags |= KImageNmdExpData;
+ }
+ else
+ {
+ iHdr->iFlags &= ~KImageNmdExpData;
+ }
+}
+
+/**
+Class for Uids.
+@internalComponent
+@released
+*/
+class TE32ImageUids
+{
+public:
+ TE32ImageUids(TUint32 aUid1, TUint32 aUid2, TUint32 aUid3);
+ void Set(const TUidType& aUidType);
+ TUint Check() { return ((checkSum(((TUint8*)this)+1)<<16)|checkSum(this));}
+private:
+ TUidType iType;
+ TUint iCheck;
+
+};
+
+/**
+Constructor for TE32ImageUids.
+@internalComponent
+@released
+*/
+TE32ImageUids::TE32ImageUids(TUint32 aUid1, TUint32 aUid2, TUint32 aUid3)
+{
+ Set(TUidType(TUid::Uid(aUid1), TUid::Uid(aUid2), TUid::Uid(aUid3)));
+}
+
+/**
+This function sets the Uid.
+@internalComponent
+@released
+*/
+void TE32ImageUids::Set(const TUidType& aUidType)
+{
+ iType=aUidType;
+ iCheck=Check();
+}
+
+/**
+Default constructor for TUidType class.
+@internalComponent
+@released
+*/
+TUidType::TUidType()
+{
+ memset(this, 0, sizeof(TUidType));
+}
+
+/**
+Constructor for TUidType class.
+@internalComponent
+@released
+*/
+TUidType::TUidType(TUid aUid1,TUid aUid2,TUid aUid3)
+{
+ iUid[0]=aUid1;
+ iUid[1]=aUid2;
+ iUid[2]=aUid3;
+}
+
+// needed by E32ImageHeaderV::ValidateHeader...
+TCheckedUid::TCheckedUid(const TUidType& aUidType)
+ {
+ iType = aUidType;
+ iCheck = ((TE32ImageUids*)this)->Check();
+ }
+
+// needed by E32ImageHeaderV::ValidateHeader...
+void Mem::Crc32(TUint32& aCrc, const TAny* aPtr, TInt aLength)
+ {
+ ::Crc32(aCrc, aPtr, aLength);
+ }
+
+/**
+This function updates the CRC of the E32 Image.
+@internalComponent
+@released
+*/
+void E32ImageFile::UpdateHeaderCrc()
+{
+ TE32ImageUids u(iHdr->iUid1, iHdr->iUid2, iHdr->iUid3);
+ iHdr->iUidChecksum = u.Check();
+ TInt hdrsz = GetExtendedE32ImageHeaderSize();
+ iHdr->iUncompressedSize = iChunks.GetOffset() - Align(GetExtendedE32ImageHeaderSize(), sizeof(uint32));
+ iHdr->iHeaderCrc = KImageCrcInitialiser;
+ uint32 crc = 0;
+ Crc32(crc, iHdr, hdrsz);
+ iHdr->iHeaderCrc = crc;
+}
+
+/**
+This function creates a buffer and writes all the data into the buffer.
+@internalComponent
+@released
+*/
+void E32ImageFile::AllocateE32Image()
+{
+ size_t aImageSize = iChunks.GetOffset();
+ iE32Image = new char[aImageSize];
+ memset(iE32Image, 0, aImageSize);
+
+ E32ImageChunks::ChunkList aChunkList = iChunks.GetChunks();
+ E32ImageChunks::ChunkList::iterator p;
+ for(p = aChunkList.begin(); p != aChunkList.end(); p++)
+ {
+ (*p)->Write(iE32Image);
+ }
+
+ E32ImageHeaderV* header = (E32ImageHeaderV*)iE32Image;
+ TInt headerSize = header->TotalSize();
+ if(KErrNone!=header->ValidateWholeImage(iE32Image+headerSize,GetE32ImageSize()-headerSize))
+ throw InvalidE32ImageError(VALIDATIONERROR, (char*)iUseCase->OutputE32FileName());
+}
+
+/**
+This function deflates the compressed data.
+@param bytes
+@param size
+@param os
+@internalComponent
+@released
+*/
+void DeflateCompress(char* bytes, size_t size, ofstream & os);
+
+/**
+This function Paged Pack the compressed data.
+@param bytes
+@param size
+@param os
+@internalComponent
+@released
+*/
+void CompressPages(TUint8 * bytes, TInt size, ofstream& os);
+
+
+/**
+This function writes into the final E32 image file.
+@param aName - E32 image file name
+@internalComponent
+@released
+*/
+bool E32ImageFile::WriteImage(const char * aName)
+{
+ ofstream *os = new ofstream();
+ os->open(aName, ofstream::binary|ofstream::out);
+
+ if (os->is_open())
+ {
+ uint32 compression = iHdr->CompressionType();
+ if (compression == KUidCompressionDeflate)
+ {
+ size_t aHeaderSize = GetExtendedE32ImageHeaderSize();
+ size_t aBodySize = GetE32ImageSize() - aHeaderSize;
+ os->write(iE32Image, aHeaderSize);
+ DeflateCompress(iE32Image + aHeaderSize, aBodySize, *os);
+ }
+ else if (compression == KUidCompressionBytePair)
+ {
+ size_t aHeaderSize = GetExtendedE32ImageHeaderSize();
+ os->write(iE32Image, aHeaderSize);
+
+ // Compress and write out code part
+ int srcStart = GetExtendedE32ImageHeaderSize();
+ CompressPages( (TUint8*)iE32Image + srcStart, iHdr->iCodeSize, *os);
+
+
+ // Compress and write out data part
+ srcStart += iHdr->iCodeSize;
+ int srcLen = GetE32ImageSize() - srcStart;
+
+ CompressPages((TUint8*)iE32Image + srcStart, srcLen, *os);
+
+ }
+ else if (compression == 0)
+ {
+ os->write(iE32Image, GetE32ImageSize()); // image not compressed
+ }
+
+ }
+ else
+ {
+ throw FileError(FILEOPENERROR,(char*)aName);
+ }
+ os->close();
+ if(os!=NULL)
+ {
+ delete os;
+ os = NULL;
+ }
+ return true;
+}
+
+
+/**
+Constructor for E32ImageFile class.
+@internalComponent
+@released
+*/
+E32ImageFile::E32ImageFile(): iFileName(NULL), iE32Image(NULL),iExportBitMap(0),cleanupStack(0), iData(NULL),iHdr(NULL),iImportSection(0), iSize(0), iOrigHdr(NULL), iError(0), iSource(EE32Image), iOrigHdrOffsetAdj(0)
+{
+
+};
+
+/**
+Destructor for E32ImageFile class.
+@internalComponent
+@released
+*/
+E32ImageFile::~E32ImageFile()
+{
+ delete[] iData;
+ if (iHdr && iHdr != iOrigHdr)
+ delete iHdr;
+
+ delete [] iExportBitMap;
+ delete [] iE32Image;
+ delete [] iImportSection;
+
+ std::vector<char*>::iterator aPos;
+ char *aPtr;
+ aPos = cleanupStack.begin();
+ while( aPos != cleanupStack.end() )
+ {
+ aPtr = *aPos;
+ delete [] aPtr;
+ aPos++;
+ }
+
+}
+
+/**
+Adjust the size of allocated data and fix the member data
+@internalComponent
+@released
+*/
+void E32ImageFile::Adjust(TInt aSize, TBool aAllowShrink)
+{
+ TInt asize = ((aSize+0x3)&0xfffffffc);
+
+ if (asize == iSize)
+ return;
+
+ if (iSize == 0)
+ {
+ iSize = asize;
+ iData = new char[iSize];
+ memset(iData, 0, iSize);
+ }
+ else if (aAllowShrink || asize > iSize)
+ {
+ TInt oldsize = iSize;
+ iSize = asize;
+ iData = (char*)realloc(iData, iSize);
+
+ if (iSize > oldsize)
+ memset(iData+oldsize, 0, iSize-oldsize);
+ }
+
+ if (!iData)
+ iSize = 0;
+
+ if (iHdr && iHdr == iOrigHdr)
+ iHdr = (E32ImageHeaderV*)iData;
+
+ iOrigHdr = (E32ImageHeader*)iData;
+}
+
+/**
+Read the E32 image.
+@param is - input stream
+@internalComponent
+@released
+*/
+TInt E32ImageFile::ReadHeader(ifstream& is)
+{
+ Adjust(sizeof(E32ImageHeader), EFalse);
+ is.read(iData, sizeof(E32ImageHeader));
+ TInt hdrsz = iOrigHdr->TotalSize();
+
+ if (hdrsz > 0x10000)
+ return KErrCorrupt; // sanity check
+
+ if (hdrsz > (TInt)sizeof(E32ImageHeader))
+ {
+ Adjust(hdrsz, EFalse);
+ is.read(iData+sizeof(E32ImageHeader), hdrsz-sizeof(E32ImageHeader));
+ }
+
+ TUint32 uncompressedSize;
+ TInt r = iOrigHdr->ValidateHeader(iFileSize,uncompressedSize);
+
+ if (r != KErrNone)
+ {
+ fprintf(stderr, "Integrity check failed %d\n", r);
+ return r;
+ }
+
+ iHdr = (E32ImageHeaderV*)iOrigHdr;
+ return KErrNone;
+}
+
+/**
+Return the offset of the text section
+@internalComponent
+@released
+*/
+TUint E32ImageFile::TextOffset()
+{
+ return 0;
+}
+
+/**
+Return the offset of the data section
+@internalComponent
+@released
+*/
+TUint E32ImageFile::DataOffset()
+{
+ return iHdr->iCodeSize;
+}
+
+/**
+Return the offset of the bss section
+@internalComponent
+@released
+*/
+TUint E32ImageFile::BssOffset()
+{
+ return DataOffset()+iHdr->iDataSize;
+}
+
+
+/**
+This function creates the bitmap after reading the E32 image file
+@internalComponent
+@released
+*/
+void E32ImageFile::E32ImageExportBitMap()
+{
+ TInt nexp = iOrigHdr->iExportDirCount;
+ TInt memsz = (nexp + 7) >> 3;
+ iExportBitMap = new TUint8[memsz];
+ memset(iExportBitMap, 0xff, memsz);
+ TUint* exports = (TUint*)(iData + iOrigHdr->iExportDirOffset);
+ TUint absoluteEntryPoint = iOrigHdr->iEntryPoint + iOrigHdr->iCodeBase;
+ TUint impfmt = iOrigHdr->ImportFormat();
+ TUint hdrfmt = iOrigHdr->HeaderFormat();
+ TUint absentVal = (impfmt == KImageImpFmt_ELF) ? absoluteEntryPoint : iOrigHdr->iEntryPoint;
+ TInt i;
+ iMissingExports = 0;
+
+ for (i=0; i<nexp; ++i)
+ {
+ if (exports[i] == absentVal)
+ {
+ iExportBitMap[i>>3] &= ~(1u << (i & 7));
+ ++iMissingExports;
+ }
+ }
+
+ if (hdrfmt < KImageHdrFmt_V && iMissingExports)
+ {
+ fprintf(stderr, "Bad exports\n");
+ exit(999);
+ }
+}
+
+/**
+This function creates the export description after reading the E32 image file
+@internalComponent
+@released
+*/
+TInt E32ImageFile::CheckExportDescription()
+{
+ TUint hdrfmt = iOrigHdr->HeaderFormat();
+ if (hdrfmt < KImageHdrFmt_V && iMissingExports)
+ return KErrCorrupt;
+
+ if (iHdr->iExportDescType == KImageHdr_ExpD_NoHoles)
+ {
+ return iMissingExports ? KErrCorrupt : KErrNone;
+ }
+
+ TInt nexp = iOrigHdr->iExportDirCount;
+ TInt memsz = (nexp + 7) >> 3; // size of complete bitmap
+ TInt mbs = (memsz + 7) >> 3; // size of meta-bitmap
+ TInt eds = iHdr->iExportDescSize;
+
+ if (iHdr->iExportDescType == KImageHdr_ExpD_FullBitmap)
+ {
+ if (eds != memsz)
+ return KErrCorrupt;
+ if (memcmp(iHdr->iExportDesc, iExportBitMap, eds) == 0)
+ return KErrNone;
+ return KErrCorrupt;
+ }
+
+ if (iHdr->iExportDescType != KImageHdr_ExpD_SparseBitmap8)
+ return KErrNotSupported;
+
+ TInt nbytes = 0;
+ TInt i;
+ for (i=0; i<memsz; ++i)
+ if (iExportBitMap[i] != 0xff)
+ ++nbytes; // number of groups of 8
+
+ TInt exp_extra = mbs + nbytes;
+ if (eds != exp_extra)
+ return KErrCorrupt;
+
+ const TUint8* mptr = iHdr->iExportDesc;
+ const TUint8* gptr = mptr + mbs;
+ for (i=0; i<memsz; ++i)
+ {
+ TUint mbit = mptr[i>>3] & (1u << (i&7));
+ if (iExportBitMap[i] != 0xff)
+ {
+ if (!mbit || *gptr++ != iExportBitMap[i])
+ return KErrCorrupt;
+ }
+ else if (mbit)
+ return KErrCorrupt;
+ }
+
+ return KErrNone;
+}
+
+
+int DecompressPages(TUint8 * bytes, ifstream& is);
+
+
+/**
+This function creates the E32 image reading from the file
+@param is
+@param aImage
+@internalComponent
+@released
+*/
+ifstream& operator>>(ifstream& is, E32ImageFile& aImage)
+{
+ aImage.iError = aImage.ReadHeader(is);
+ if (aImage.iError != KErrNone)
+ return is;
+
+ E32ImageHeader* oh = aImage.iOrigHdr;
+ TInt orighdrsz = oh->TotalSize();
+ int remainder = aImage.iSize - orighdrsz;
+ TUint compression = oh->CompressionType();
+ if (compression == 0)
+ {
+ is.read(aImage.iData + orighdrsz, remainder);
+ }
+ else if (compression == KUidCompressionDeflate)
+ { //Uncompress
+ aImage.iError = KErrNoMemory;
+ unsigned int uncompsize = ((E32ImageHeaderComp*)aImage.iOrigHdr)->iUncompressedSize;
+ aImage.Adjust(uncompsize + orighdrsz);
+
+ if (aImage.iData==NULL)
+ return is;
+
+ oh = aImage.iOrigHdr;
+
+ unsigned char* compressedData = new unsigned char[remainder];
+ if (compressedData==NULL)
+ return is;
+
+ is.read(reinterpret_cast<char *>(compressedData), remainder);
+ unsigned int destsize = uncompsize;
+ InflateUnCompress( compressedData, remainder, (unsigned char*)(aImage.iData + orighdrsz), destsize);
+
+ if (destsize != uncompsize)
+ MessageHandler::GetInstance()->ReportMessage(WARNING, HUFFMANINCONSISTENTSIZEERROR);
+
+ delete [] compressedData;
+
+ if ((TUint)orighdrsz > oh->iCodeOffset)
+ {
+ // need to adjust code offsets in original
+ aImage.iOrigHdrOffsetAdj = (TUint)orighdrsz - oh->iCodeOffset;
+ aImage.OffsetAdjust(oh->iCodeOffset);
+ aImage.OffsetAdjust(oh->iDataOffset);
+ aImage.OffsetAdjust(oh->iCodeRelocOffset);
+ aImage.OffsetAdjust(oh->iDataRelocOffset);
+ aImage.OffsetAdjust(oh->iImportOffset);
+ aImage.OffsetAdjust(oh->iExportDirOffset);
+ }
+ aImage.iError = KErrNone;
+ }
+ else if(compression == KUidCompressionBytePair)
+ { // Uncompress
+ aImage.iError = KErrNoMemory;
+ unsigned int uncompsize = ((E32ImageHeaderComp*)aImage.iOrigHdr)->iUncompressedSize;
+ aImage.Adjust(uncompsize + orighdrsz);
+ if (aImage.iData==NULL)
+ return is;
+ oh = aImage.iOrigHdr;
+
+ // Read and decompress code part of the image
+
+ unsigned int uncompressedCodeSize = DecompressPages((TUint8 *) (aImage.iData + orighdrsz), is);
+
+
+ // Read and decompress data part of the image
+
+ unsigned int uncompressedDataSize = DecompressPages((TUint8 *) (aImage.iData + orighdrsz + uncompressedCodeSize), is);
+
+ if (uncompressedCodeSize + uncompressedDataSize != uncompsize)
+ MessageHandler::GetInstance()->ReportMessage(WARNING, BYTEPAIRINCONSISTENTSIZEERROR);
+
+ if ((TUint)orighdrsz > oh->iCodeOffset)
+ {
+ // need to adjust code offsets in original
+ aImage.iOrigHdrOffsetAdj = (TUint)orighdrsz - oh->iCodeOffset;
+ aImage.OffsetAdjust(oh->iCodeOffset);
+ aImage.OffsetAdjust(oh->iDataOffset);
+ aImage.OffsetAdjust(oh->iCodeRelocOffset);
+ aImage.OffsetAdjust(oh->iDataRelocOffset);
+ aImage.OffsetAdjust(oh->iImportOffset);
+ aImage.OffsetAdjust(oh->iExportDirOffset);
+ }
+ aImage.iError = KErrNone;
+ }
+ aImage.E32ImageExportBitMap();
+
+ return is;
+}
+#ifdef __LINUX__
+#include <sys/stat.h>
+/**
+Simple function uses stdlib fstat to obtain the size of the file.
+@param aFileName - e32 image file name
+@internalComponent
+@released
+*/
+int GetFileSize(const char* aFileName) {
+ // Open the file the old-fashioned way :-)
+ struct stat fileInfo;
+ if(stat(aFileName,&fileInfo)!=0) {
+ throw FileError(FILEOPENERROR,(char *)aFileName);
+ }
+ off_t fileSize = fileInfo.st_size;
+ return fileSize;
+}
+#else
+int GetFileSize(const char* aFileName) {
+ _finddata_t fileinfo;
+ int ret=_findfirst((char *)aFileName,&fileinfo);
+ if (ret==-1)
+ {
+ throw FileError(FILEOPENERROR,(char *)aFileName);
+ }
+ return fileinfo.size;
+}
+#endif
+
+
+/**
+This function opens the e32 image file.
+@param aFileName - e32 image file name
+@internalComponent
+@released
+*/
+TInt E32ImageFile::Open(const char* aFileName)
+{
+ iFileSize = GetFileSize(aFileName);
+
+ Adjust(iFileSize);
+ ifstream ifile((char *)aFileName, ios::in | ios::binary);
+ if(!ifile.is_open())
+ {
+ throw FileError(FILEOPENERROR,(char *)aFileName);
+ }
+ ifile >> *this;
+ ifile.close();
+
+ if (iError != KErrNone)
+ return iError;
+
+ return KErrNone;
+}
+
+void E32ImageFile::ProcessSymbolInfo() {
+
+ Elf32_Addr aPlace = iUseCase->GetExportTableAddress() - 4;// This location points to 0th ord.
+ // Create a relocation entry for the 0th ordinal.
+ ElfLocalRelocation *aRel = new ElfLocalRelocation(iElfExecutable, aPlace, 0, 0, R_ARM_ABS32, \
+ NULL, ESegmentRO, NULL, false);
+ aRel->Add();
+
+ aPlace += iUseCase->GetExportTableSize();// aPlace now points to the symInfo
+ uint32 *aZerothOrd = (uint32*)iUseCase->GetExportTable();
+ *aZerothOrd = aPlace;
+ aPlace += sizeof(E32EpocExpSymInfoHdr);// aPlace now points to the symbol address
+ // which is just after the syminfo header.
+ if(!iElfExecutable->iExports)
+ return;
+
+ // Donot disturb the internal list sorting.
+ ElfExports::ExportList aList = iElfExecutable->iExports->GetExports(false);
+
+ ElfExports::ExportList::iterator aIter = aList.begin();
+ DllSymbol *aSym;
+ TUint aAlign, aNameLen;
+
+
+ char aPad[] = {'\0', '\0', '\0', '\0'};
+
+
+ while ( aIter != aList.end() ) {
+ aSym = *aIter;
+ iSymAddrTab.push_back(aSym->iElfSym->st_value);
+ // The symbol names always start at a 4-byte aligned offset.
+ iSymNameOffset = iSymbolNames.size() >> 2;
+ iSymNameOffTab.push_back(iSymNameOffset);
+
+ iSymbolNames += aSym->SymbolName();
+ iSymbolNames += '\0';
+ aNameLen = iSymbolNames.size();
+ aAlign = Align(aNameLen, sizeof(int));
+ aAlign = aAlign - aNameLen;
+ if(aAlign % 4){
+ iSymbolNames.append(aPad, aAlign);
+ }
+ //Create a relocation entry...
+ aRel = new ElfLocalRelocation(iElfExecutable, aPlace, 0, 0, R_ARM_ABS32, NULL,\
+ ESegmentRO, aSym->iElfSym, false);
+ aPlace += sizeof(uint32);
+ aRel->Add();
+ aIter++;
+ }
+}
+
+char* E32ImageFile::CreateSymbolInfo(size_t aBaseOffset) {
+ E32EpocExpSymInfoHdr aSymInf;
+ uint32 aSizeofNames, aSize;
+
+ SetSymInfo(aSymInf);
+ if( aSymInf.iFlags & 1) {
+ aSizeofNames = sizeof(uint32);
+ }
+ else {
+ aSizeofNames = sizeof(uint16);
+ }
+
+ aSize = aSymInf.iSize;
+
+ char* aInfo = new char[aSize];
+ memset(aInfo, 0, aSize);
+ memcpy(aInfo, (void*)&aSymInf, sizeof(aSymInf));
+
+ TUint aPos = aSymInf.iSymbolTblOffset;
+ memcpy(aInfo+aPos, iSymAddrTab.begin(), iSymAddrTab.size()*sizeof(uint32));
+
+ aPos += iSymAddrTab.size()*aSizeofNames;
+ aPos += iSymNameOffTab.size()*aSizeofNames;
+ aPos = Align(aPos, sizeof(uint32));
+
+ std::vector<uint32>::iterator Iter = iSymNameOffTab.begin();
+ TInt aOffLen = 2;
+ if(aSymInf.iFlags & 1)
+ aOffLen=4;
+ while(Iter != iSymNameOffTab.end()){
+ memcpy( ((void*)(aInfo+aPos)), ((void*)Iter), aOffLen);
+ aPos += aOffLen;
+ Iter++;
+ }
+
+ aPos = aSymInf.iStringTableOffset;
+ memcpy(aInfo+aPos, iSymbolNames.begin(), iSymbolNames.size());
+
+ // At the end, the dependencies are listed. They remain zeroes and shall be fixed up
+ // while relocating.
+
+ // Update the import table to have offsets to ordinal zero entries
+ uint32 *aLocation, aOffset;
+ uint32 *aImportTab = iImportSection;
+
+ std::vector<int>::iterator aIter = iImportTabLocations.begin();
+ aOffset = aBaseOffset - iHdr->iCodeOffset;// This gives the offset of syminfo table base
+ // wrt the code section start
+ aOffset += aSymInf.iDepDllZeroOrdTableOffset; // This points to the ordinal zero offset table now
+ while( aIter != iImportTabLocations.end()) {
+ aLocation = (aImportTab + *aIter);
+ *aLocation = aOffset;
+ aOffset += sizeof(uint32);
+ aIter++;
+ }
+
+ return aInfo;
+}
+
+void E32ImageFile::SetSymInfo(E32EpocExpSymInfoHdr& aSymInfo)
+{
+ uint32 aSize = sizeof(E32EpocExpSymInfoHdr);
+ memset(&aSymInfo, 0, aSize);
+
+ uint16 aNSymbols = (uint16) iSymAddrTab.size();
+ aSymInfo.iSymCount = aNSymbols;
+ aSymInfo.iSymbolTblOffset = aSize;
+ aSize += aNSymbols * sizeof(uint32); // Symbol addresses
+ TUint aNameTabSz = iSymbolNames.size();
+ TInt aSizeofNames;
+
+ if( iSymNameOffset < 0xffff) {
+ aSizeofNames = sizeof(uint16);
+ aSymInfo.iFlags &= ~1;//reset the 0th bit
+ }
+ else {
+ aSizeofNames = sizeof(uint32);
+ aSymInfo.iFlags |= 1;//set the 0th bit
+ }
+ aSize += Align((aNSymbols * aSizeofNames), sizeof(uint32)); // Symbol name offsets
+ aSymInfo.iStringTableOffset = aSize;
+ aSize += aNameTabSz; // Symbol names in string tab
+ aSymInfo.iStringTableSz = aNameTabSz;
+ aSymInfo.iDepDllZeroOrdTableOffset = aSize;
+ aSymInfo.iDllCount = iNumDlls ;
+ aSize += iNumDlls * sizeof(uint32); // Dependency list - ordinal zero placeholder
+ aSymInfo.iSize = aSize;
+}
+