diff -r 000000000000 -r 83f4b4db085c toolsandutils/e32tools/elftools/elftran/elf_dlld.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/toolsandutils/e32tools/elftools/elftran/elf_dlld.cpp	Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,914 @@
+// Copyright (c) 2001-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:
+// ELFDLLD.CPP
+// 
+//
+
+
+#include <string.h>
+#include <stdlib.h>
+#include <e32std.h>
+#include <e32std_private.h>
+#include <tools/elfdefs.h>
+#include "elfdll.h"
+#include "elffile.h"
+#include "h_utl.h"
+#include <e32ldr.h>
+
+ELFFile::ELFDllData::ELFDllData(ELFFile * f) :
+        iElfFile(f), iDynStrTab(0), iDynStrTabSize(0), iDynSymTab(0),
+		iSymSize(0), iRela(0), iRelaSz(0), iRelaEnt(0), 
+		iRel(0), iRelSz(0), iRelEnt(0),
+		iHashTable(0),iDllHead(0), iDllTail(0), 
+		iNumberOfImports(0), iNumberOfExports(0), iNumberOfImportDlls(0),
+		iStringTableSize(0), iNumberOfRelocs(0), iNumberOfCodeRelocs(0), 
+		iNumberOfDataRelocs(0), iNamedLookupEnabled(0), iNamedExportSymbolHead(0), 
+		iNamedExportCount(0), iSymStringTableSize(0),iStringNameOffset(0), iOrdZeroRec(0), 
+		iDepRecords(0), iDepRecordsTail(0),iNeededDllNames(0),
+		iNeededDllNamesTail(0)
+		{
+		}
+
+ELFFile::ELFDllData::~ELFDllData()
+	{
+		delete iOrdZeroRec;
+		delete iDepRecords;
+		delete iNeededDllNames;
+	}
+
+TBool ELFFile::ELFDllData::Init()
+	{
+	// process imported symbols
+	// There will be at least one relocation (assumed to be Elf32_Rel) for each such symbol.
+	// S iterate over relocations looking for DLL symbols and add them to the record of
+	// of import info.
+	TInt nrelocs = iRelSz/iRelEnt;
+	TInt SrcSegIdx = -1;
+	TInt errors = 0;
+
+	for (TInt idx = 0; idx < nrelocs; idx++)
+			{
+			Elf32_Rel * rel = &iRel[idx];
+			TUint relType = ELF32_R_TYPE(rel->r_info);
+
+			if (relType == R_ARM_ABS32)      
+					{	
+					TInt symIdx = ELF32_R_SYM(rel->r_info);
+					Elf32_Sym * sym = &iDynSymTab[symIdx];
+					DllSymbol * dllSym = DllSymbolP(sym);
+					if (dllSym) 
+							{
+							dllSym->iRel = rel;
+							dllSym->iSegment = iElfFile->GetSegment(SrcSegIdx);
+							if (!AddSymbol(dllSym)) return EFalse;
+							}
+					else errors++;
+					}
+			else if (relType == R_ARM_RABS32)
+					{
+					iNumberOfRelocs++;
+					if (iElfFile->CodeSegmentP(SrcSegIdx)) iNumberOfCodeRelocs++;
+					else iNumberOfDataRelocs++;
+					}
+			else if (relType == R_ARM_RBASE)
+				    {
+					SrcSegIdx = ELF32_R_SYM(rel->r_info);
+					if (SrcSegIdx) SrcSegIdx--;
+					}
+			else 
+				    {
+					// Gives error with all other Relocation types..
+					TInt symIdx = ELF32_R_SYM(rel->r_info);
+					Elf32_Sym * s = &iDynSymTab[symIdx];
+					char * symName = ELFADDR(char,iDynStrTab,s->st_name);
+					Print(EPeError, "Unresolved symbol: %s\n", symName);
+					errors++;
+					}
+			}
+	// Set up export info
+	if (InitExportInfo())
+	       {
+	       TText * sym = (TText *)"_E32Startup";
+	       // If _E32Startup is defined then this is not a DLL
+	       iImageIsDll = !iElfFile->SymbolPresent(sym);
+	       }
+	if (errors > 0) return EFalse;
+	return ETrue;
+	}
+
+TBool ELFFile::ELFDllData::ParseDllSymbol(Elf32_Sym * s, char *& dll, TUint& len, TInt& ord)
+    {
+	char * sym = ELFADDR(char,iDynStrTab,s->st_name);
+	if (!strncmp(sym, DLLSYMPREFIX, strlen(DLLSYMPREFIX)))
+			{
+			dll = sym + strlen(DLLSYMPREFIX);
+			TUint lim = strlen(dll);
+			TUint index = strcspn(dll, DLLSYMPREFIX0);
+			if ((index + strlen(DLLSYMSUFFIX)) < lim)
+					{
+					len = index;
+					char * dllSuffix = dll+index;
+					char * match = DLLSYMSUFFIX;
+					int suflen = strlen(DLLSYMSUFFIX);
+					if (!strncmp(dllSuffix, match, suflen))
+							{
+							char * ordString = dll+index+suflen;
+							char * final;
+							TUint X = strtoul(ordString, &final, ORDBASE);
+							if (ordString != final)
+									{
+									ord = (TInt)X;
+									return ETrue;
+									}
+			     
+							}
+					}
+			}
+	dll = 0;
+	len = 0;
+	ord = -1;
+	return EFalse;
+	}
+
+ELFFile::ELFDllData::DllSymbol * ELFFile::ELFDllData::DllSymbolP(Elf32_Sym * s)
+    {
+	char * dllName;
+	TUint nameLen;
+	TInt symOrd;
+	if (ParseDllSymbol(s, dllName, nameLen, symOrd))
+	       {
+	       DllSymbol * ds = new DllSymbol(dllName, nameLen, symOrd);
+	       if (ds) return ds;
+	       Print(EPeError, "Out of memory.\n");
+	       return NULL;
+	       }
+	// If we get here its not a valid 'dll symbol' and so it is an unresolved symbol
+	char * sym = ELFADDR(char,iDynStrTab,s->st_name);
+	Print(EPeError, "Unresolved symbol: %s\n", sym);
+    return NULL;
+	}
+
+TBool ELFFile::ELFDllData::AddSymbol(ELFFile::ELFDllData::DllSymbol * s)
+    {
+	DllRec * aDll = NULL;
+     
+	for (DllRec * r = iDllHead; r != NULL; r = r->iNext)
+			{
+			if (!strncmp(s->iDll, r->iName, s->iLen))
+					{
+					aDll = r;
+					break;
+					}
+			}
+	if (aDll)
+			{
+		    iNumberOfImports++;
+		    aDll->AddSymbol(s);
+			return ETrue;
+			}
+	else
+			{
+			aDll = new DllRec(s->iDll, s->iLen, s);
+			if (aDll)
+					{
+					if (!iDllHead) 
+							{
+							iDllHead = iDllTail = aDll;
+							}
+					else
+							{
+							iDllTail->iNext = aDll;
+							iDllTail = aDll;
+							}
+					iStringTableSize += (s->iLen + 1);
+	      			iNumberOfImportDlls++;
+					iNumberOfImports++;
+					return ETrue;
+					}
+			else
+					{
+					Print(EPeError, "Out of memory.\n");
+					return EFalse;
+					}
+			}
+	}
+
+void ELFFile::ELFDllData::DllRec::AddSymbol(ELFFile::ELFDllData::DllSymbol * s)
+	{
+	nImports++;
+    iTail->iNext = s;
+    iTail = s;
+    }
+
+static unsigned long elf_hash(const unsigned char *name)
+    {
+    unsigned long h, g;
+    for (h = 0; *name != 0; ++name)
+	        {
+			h = (h << 4) + *name;
+			g = h & 0xf0000000;
+			if (g != 0) h ^= g >> 24;
+			h &= ~g;
+			}
+	return h;
+    }
+
+Elf32_Word ELFFile::ELFDllData::FindSymbolIndex(TText * s)
+    {
+	TUint h = elf_hash(s);
+	TUint nb = iHashTable[0].nBuckets;
+	TUint probe = h%nb;
+	Elf32_Sword * bucket = ELFADDR(Elf32_Sword, iHashTable, sizeof(Elf32_HashTable));
+	Elf32_Sword * chain = ELFADDR(Elf32_Sword, bucket, nb * sizeof(Elf32_Sword));
+	Elf32_Sword idx = bucket[probe];
+
+	do 	
+			{
+			if (!strcmp(ELFADDR(char, iDynStrTab, iDynSymTab[idx].st_name), (char *)s)) return idx;
+			idx = chain[idx];
+			} while (idx > 0);
+	if (idx == 0) idx = -1;
+	return idx;
+	}
+
+TBool ELFFile::ELFDllData::InitExportInfo()
+	{
+	memset(&iSymInfoHdr, 0, sizeof(iSymInfoHdr));
+	TText * exp = (TText *)EXPORTTABLENAME;
+	if ((iExportTableSymIdx = FindSymbolIndex(exp)) != -1)
+			{
+			TText * exps = (TText *)EXPORTTABLESIZENAME;
+			iExportTableSizeSymIdx = FindSymbolIndex(exps);
+			//TUint offset = iDynSymTab[iExportTableSizeSymIdx].st_value - (TUint)code;
+			Elf32_Word * pNumberOfExports = iElfFile->CodePtrFromAddr(iDynSymTab[iExportTableSizeSymIdx].st_value);
+			iNumberOfExports = * pNumberOfExports;
+			iImageIsDll = ETrue;
+			return ETrue;
+			}
+	else iImageIsDll = EFalse;
+	return EFalse;
+	}
+
+TInt ELFFile::ELFDllData::NumberOfImports(void)
+    {
+	return iNumberOfImports;
+	}
+
+TInt ELFFile::ELFDllData::NumberOfExports(void)
+    {
+	return iNumberOfExports;
+	}
+
+TInt ELFFile::ELFDllData::NumberOfImportDlls(void)
+    {
+	return iNumberOfImportDlls;
+	}
+
+TInt ELFFile::ELFDllData::NumberOfRelocs()
+	{
+	return iNumberOfRelocs;
+	}
+
+char * ELFFile::ELFDllData::CreateImportSection(TInt &aSize)
+	{
+	if (!iNumberOfImports)
+			{
+			aSize = 0;
+			return 0;
+			}
+
+	TInt byteSize = sizeof(E32ImportSection) + 
+	                (sizeof(E32ImportBlock) * iNumberOfImportDlls) +
+					(sizeof(TUint) * iNumberOfImports) +
+					iStringTableSize;
+	if(iNamedLookupEnabled)
+	{
+		// 0th ordinal of each DLL imported from.
+		byteSize += (sizeof(TUint) * iNumberOfImportDlls);
+	}
+	char * newSection = new char[byteSize];
+
+	if (!newSection)
+	       {
+	       Print(EPeError, "Failed to allocate new import section.\n");
+	       aSize = 0;
+	       return 0;
+	       }
+
+	((E32ImportSection *)newSection)->iSize = byteSize;
+
+	// used to point to current ImportBlock
+	E32ImportBlock * bp = ELFADDR(E32ImportBlock, newSection, sizeof(E32ImportSection));
+	// used to point to current import relocation entry
+	TUint * rp;
+	// used to point to current location in string table
+	char * sp = ELFADDR(char, newSection, (byteSize - iStringTableSize));
+	OrdZeroRecord *aDep = iDepRecords;
+
+	for (DllRec * dll = iDllHead; dll != NULL ; dll = dll->iNext, bp = (E32ImportBlock *)rp )
+	        {
+			// set up the offset from E32ImportBlock.iOffsetOfDllName to the
+			// corresponding  string table location
+			bp->iOffsetOfDllName = (sp - (char *)newSection);
+			bp->iNumberOfImports = dll->nImports;
+			if(iNamedLookupEnabled)
+			{
+				bp->iNumberOfImports++;
+			}
+
+			// copy the DLL name to the string table
+			memcpy(sp , dll->iName, dll->iLen);
+			sp[dll->iLen] = 0;
+			sp = sp + dll->iLen + 1;
+
+			// sort out the import 'relocs'
+			rp = ELFADDR(TUint, bp, sizeof(E32ImportBlock));
+		
+			for (DllSymbol * sym = dll->iHead; sym != NULL; sym = sym->iNext, rp++)
+				    {
+					Elf32_Phdr * segment = sym->iSegment;
+					Elf32_Addr segBase = segment->p_vaddr;
+
+					// sanity check: segment should be the code segment
+					if (!iElfFile->CodeSegmentP(segment))
+							{
+							Print(EPeError, "Import relocation does not refer to code segment.\n");
+							aSize = 0;
+							return 0;
+							}
+
+					// This field is misnamed because it is actually given as a virtual address in 
+					// dynamic relocations
+					Elf32_Addr dynOffset = sym->iRel->r_offset;
+					//So this is the 'real' offset of the reloc in  the segment in which it occurs
+					Elf32_Addr segOffset = dynOffset - segBase;
+					TUint * relocAddr = ELFADDR(TUint, iElfFile->ELFFileBase(), (segment->p_offset + segOffset));
+					// The only non-zero reloc vals we expect are for vtables.
+					// We store there reloc offset in the top 16 bits of the 'reloc info'.
+					// NB the ELF reloc values should only ever be multiples of 4. So we could optimize here,
+					// but we won't.
+					TUint relocVal = *relocAddr;
+					TUint importOrdinal = sym->iOrd;
+					if (relocVal > 0xFFFF)
+							Print(EPeError, "ELF relocation exceeds E32Image limit of 64K.\n");
+					if (importOrdinal > 0xFFFF)
+							Print(EPeError, "Import ordinal exceeds E32Image limit of 64K.\n");
+   
+   					*rp = segOffset;
+   			
+   					// eek !! surgery on the code segment....
+					*relocAddr = (relocVal<<16) | importOrdinal;
+					}
+			
+				if(iNamedLookupEnabled)
+				{
+					aDep = FindDependency(dll->iName, dll->iLen);
+					if( aDep )
+					{
+						*rp = aDep->iOffset;
+						rp++;
+					}
+				}
+			}
+	
+	aSize = byteSize;
+	return newSection;
+	}
+
+TUint ELFFile::ELFDllData::GetExportTableOffset(void)
+    {
+	Elf32_Sym * et = &iDynSymTab[iExportTableSymIdx];
+	Elf32_Phdr * segment = iElfFile->GetSegment(et->st_shndx - 1);
+	
+	return et->st_value - segment->p_vaddr;
+	}
+
+TBool ELFFile::ELFDllData::GetRelocs(Elf32_Rel **aCodeRelocs, Elf32_Rel **aDataRelocs)
+	//	
+	// load the relocs from the reloc section into relocation and relocsection arrays
+	//
+	{
+	TInt nrelocs = iRelSz/iRelEnt;
+
+	TInt SrcSegIdx = -1;
+
+	for (TInt idx = 0, cidx = 0, didx = 0; idx < nrelocs; idx++)
+	        {
+			Elf32_Rel * rel = &iRel[idx];
+
+			if (ELF32_R_TYPE(rel->r_info) == R_ARM_RABS32)
+					{
+					if (iElfFile->CodeSegmentP(SrcSegIdx))
+							aCodeRelocs[cidx++]=rel;
+					else if (iElfFile->DataSegmentP(SrcSegIdx))
+							aDataRelocs[didx++]=rel;
+					}
+			else if (ELF32_R_TYPE(rel->r_info) == R_ARM_RBASE)
+					{
+					SrcSegIdx = ELF32_R_SYM(rel->r_info);
+					if (!(iElfFile->CodeSegmentP(SrcSegIdx-1) || iElfFile->DataSegmentP(SrcSegIdx-1)))
+							{
+							Print(EPeError, "Source segment for relocations is neither Code or Data.\n");
+							return EFalse;
+							}
+					SrcSegIdx--;
+					}
+			}
+	if(!iNamedLookupEnabled)
+		return ETrue;
+
+	// Add the 0th ordinal of this binary - The relocation info is already setup.
+	aCodeRelocs[cidx++] = &iOrdZeroRec->iReloc;
+
+	// add relocation entries for each of the symbols
+	NamedExportSymbol *aSym = iNamedExportSymbolHead;
+	while(aSym)
+	{
+		// The symbol name info is part of the code section hence all relocations
+		// are collected as part of Code relocations.
+		aCodeRelocs[cidx++] = &aSym->iReloc;
+		aSym = aSym->Next();
+	}
+
+	// Since we have added a few relocations, lets make sure
+	// they are still sorted on addresses they refer to.
+	
+	//Sorting the code relocs
+	TInt aIdx1, aIdx2;
+	Elf32_Rel *aTmp;
+	for (aIdx1 = 0; aIdx1 < cidx; aIdx1++) {
+		for (aIdx2 = aIdx1; aIdx2 < cidx; aIdx2++) {
+			if(aCodeRelocs[aIdx1]->r_offset > aCodeRelocs[aIdx2]->r_offset) {
+				aTmp = aCodeRelocs[aIdx2];
+				aCodeRelocs[aIdx2] = aCodeRelocs[aIdx1];
+				aCodeRelocs[aIdx1] = aTmp;
+			}
+		}
+	}
+	
+	//Sorting the data relocs
+	for (aIdx1 = 0; aIdx1 < didx; aIdx1++) {
+		for (aIdx2 = aIdx1; aIdx2 < didx; aIdx2++) {
+			if(aDataRelocs[aIdx1]->r_offset > aDataRelocs[aIdx2]->r_offset) {
+				aTmp = aDataRelocs[aIdx2];
+				aDataRelocs[aIdx2] = aDataRelocs[aIdx1];
+				aDataRelocs[aIdx1] = aTmp;
+			}
+		}
+	}
+
+	return ETrue;
+	}
+
+NamedExportSymbol::NamedExportSymbol(char* aName, Elf32_Addr aValue) : \
+	iSymbolName(aName), iValue(aValue), iNext(NULL)
+{
+}
+
+TBool ELFFile::ELFDllData::CreateSymLookupTable()
+{
+	if( !SetupSymbolValues() )
+		return FALSE;
+
+	if( !SetupSymbolNames() )
+		return FALSE;
+
+	return TRUE;
+}
+
+TBool ELFFile::ELFDllData::SetupSymbolValues()
+{
+	NamedExportSymbol *aSym, *aPrevSym;
+
+	if( iExportTableSymIdx == -1 || iExportTableSizeSymIdx == -1)
+		return FALSE;
+
+	// Fetch the 'export table' symbol from the dynamic symbol table.
+	Elf32_Sym *aElfExpTbl = &iDynSymTab[iExportTableSymIdx];
+
+	// Fetch the 'export table size' symbol from the dynamic symbol table.
+	Elf32_Sym *aElfExpTblSz = &iDynSymTab[iExportTableSizeSymIdx];
+
+	if((aElfExpTbl->st_value - aElfExpTblSz->st_value) != 4)
+	{
+		// Check that the word prior to the export table is not the export table size
+		// This is to make sure that there is space for the 0th ordinal and
+		// we dont overwrite the 'export table size' entry.
+		iNamedLookupEnabled = 1;
+	}
+	else 
+		return FALSE;
+
+	// Fetch the export table contents
+	Elf32_Word * aExpEntries = iElfFile->CodePtrFromAddr(aElfExpTbl->st_value);
+
+	if(!aExpEntries)
+		return FALSE;
+
+	aSym = aPrevSym = NULL;
+	TInt idx;
+	// Create symbols corresponding to export table entries.
+	for(idx = 0;  idx < iNumberOfExports; idx++)
+	{
+		//Symbols marked Absent are ignored.
+		if( aExpEntries[idx] == iElfFile->iEntryPoint)
+			continue;
+
+		aSym = new NamedExportSymbol(0, aExpEntries[idx]);
+		iNamedExportCount++;
+		if(aPrevSym)
+		{
+			aPrevSym->Next(aSym);
+		}
+		else
+		{
+			iNamedExportSymbolHead = aSym;
+		}
+
+		aPrevSym = aSym;
+	}
+
+	return TRUE;
+}
+
+TBool ELFFile::ELFDllData::SetupSymbolNames()
+{
+	char *aSymName = NULL;
+	NamedExportSymbol *aSym;
+	TUint aDynSymbolTblCount = iHashTable->nChains;
+	TInt aCount = 0;
+	TInt aCodeSegIdx = iElfFile->CodeSegmentIndex() + 1;
+	TInt aDataSegIdx = iElfFile->DataSegmentIndex() + 1;
+
+	// Traverse the dynamic symbol table
+	for(TUint idx = 0; idx < aDynSymbolTblCount; idx++)
+	{
+		//Consider only the the defined symbols
+		if( ELF32_ST_TYPE(iDynSymTab[idx].st_info) == STT_OBJECT || 
+			ELF32_ST_TYPE(iDynSymTab[idx].st_info) == STT_FUNC )
+		{
+			aSym = iNamedExportSymbolHead;
+			while(aSym)
+			{
+				// Name already set
+				if(aSym->Name())
+				{
+					aSym = aSym->Next();
+					continue;
+				}
+				Elf32_Addr aAddr = aSym->Value();
+
+				// If the exported symbol and the dynamic symbol table entry have the 
+				// same values, setup the name
+				if(iDynSymTab[idx].st_value == aAddr)
+				{
+					aSymName = ELFADDR(char, iDynStrTab, iDynSymTab[idx].st_name);
+					aSym->Name(aSymName);
+					
+					if(iElfFile->CodeSegmentP (iElfFile->GetSegmentFromAddr(aAddr)) ) {
+						aSym->iReloc.r_info = aCodeSegIdx << 8 | R_ARM_RABS32;
+						aSym->iSymRelocType = KTextRelocType;
+					}
+					else {
+						aSym->iReloc.r_info = aDataSegIdx << 8 | R_ARM_RABS32;
+						aSym->iSymRelocType = KDataRelocType;
+					}
+					
+					iNumberOfCodeRelocs++;
+					iNumberOfRelocs++;
+
+					// The offset to the name is always 4 byte aligned.
+					iStringNameOffset = iSymStringTableSize >> 2;
+					aSym->NameOffset( iSymStringTableSize );
+					// These are NULL-terminated strings
+					iSymStringTableSize += (strlen(aSymName) + 1);
+					iSymStringTableSize = ALIGN4(iSymStringTableSize);
+
+					aCount++;
+					break;
+				}
+				aSym = aSym->Next();
+			}
+		}
+	}
+
+	if(aCount != iNamedExportCount)
+		return FALSE;
+
+	// Sort symbols on their names...
+	if(iNamedExportCount > 1)
+	{
+		NamedExportSymbol **aTmpStart = &iNamedExportSymbolHead;
+		Sort(aTmpStart, iNamedExportSymbolHead);
+	}
+
+	return TRUE;
+}
+
+void ELFFile::ELFDllData::SetLookupTblBase(TInt aBaseOffset)
+{
+	Elf32_Addr	aBaseAddr = iElfFile->iLinkedBase + iElfFile->GetCodeSize();
+
+	Elf32_Addr	aAddr;
+
+	// setup relocations of each of the exported symbols.
+	aAddr = aBaseAddr + iSymInfoHdr.iSymbolTblOffset;
+	NamedExportSymbol *aSym = iNamedExportSymbolHead;
+	while(aSym)
+	{
+		aSym->iReloc.r_offset = aAddr;
+		aAddr += sizeof(Elf32_Addr);
+		aSym = aSym->Next();
+	}
+
+	// setup relocations for the 0th ordinal of this binary. 
+
+	iOrdZeroRec = new OrdZeroRecord(0);
+	Elf32_Sym * et = &iDynSymTab[iExportTableSymIdx];
+	iOrdZeroRec->iReloc.r_offset = et->st_value - 4; // The word prior ro the first entry
+											// of the export table is the 0th ordinal entry.
+
+	//At the 0th ordinal, write the address of the start of symbol info	
+	TUint32 aZeroOrdOff = et->st_value - 4 - iElfFile->iLinkedBase;
+	aZeroOrdOff += (iElfFile->GetSegment(et->st_shndx - 1))->p_offset;
+	TUint32 *aZeroOrdLocation = ELFADDR(TUint32, iElfFile->ELFFileBase(), aZeroOrdOff);
+	*aZeroOrdLocation = aBaseAddr;
+
+	iOrdZeroRec->iReloc.r_info = ELF32_R_INFO(et->st_shndx, R_ARM_RABS32);
+	iNumberOfCodeRelocs++;
+	iNumberOfRelocs++;
+
+	TInt aOffset = aBaseOffset + iSymInfoHdr.iDepDllZeroOrdTableOffset;
+
+	OrdZeroRecord *aDepRecord = iDepRecords;
+
+	while( aDepRecord )
+	{
+		// Setup the offset - This offset (relative code segment) is filled in the 
+		// import table to point to this dependency record.
+		aDepRecord->iOffset = aOffset;
+
+		aOffset += 4;
+		aDepRecord = aDepRecord->iNext;
+	}
+}
+
+TBool ELFFile::ELFDllData::AddToDependency(TUint aOff)
+{
+	// Add the name found in DT_NEEDED into a list.
+	// The dynamic string table might not have been found in dynamic table yet.
+	// So store the offset (wrt base of dynamic string table) for now.
+	NeededDLLsList *aNeeded = new NeededDLLsList(aOff);
+	if(!aNeeded)
+		return FALSE;
+
+	if ( iNeededDllNames ) {
+	 iNeededDllNamesTail->iNext= aNeeded;
+	 iNeededDllNamesTail = aNeeded; 
+	}
+	else {
+		iNeededDllNames = iNeededDllNamesTail = aNeeded;
+	}
+	
+	return TRUE;
+}
+
+TBool ELFFile::ELFDllData::CreateDependency()
+{
+	OrdZeroRecord *aDep;
+	NeededDLLsList *aNeeded = iNeededDllNames;
+	char *aDllName = NULL;
+	DllRec *aRec;
+	TInt aNeededFound;
+
+	for(aNeededFound = 0; (aNeededFound < iNumberOfImportDlls) && aNeeded;)
+	{
+		aRec = 0;
+		while(aNeeded) {
+			aDllName = iDynStrTab + aNeeded->iOffset;
+			// aNeeded is just a guess that this binary might be dependent on aDllName
+			// Search through the import table to find if the guess was correct.
+			aRec = SearchImports(aDllName);
+			if(aRec && FindDependency(aRec->iName, aRec->iLen) == NULL) {
+				// Check if aDllName is listed in import table and it
+				// not added already in the depedency records.
+				aNeededFound++;
+				break;
+			}
+			// Bad guess...go to the next aNeeded
+			aNeeded = aNeeded->iNext;
+		}
+
+		if( !aRec )
+			return FALSE;
+
+		aDep = new OrdZeroRecord(aDllName);
+		if(!iDepRecords)
+		{
+			iDepRecords = iDepRecordsTail = aDep;
+		}
+		else
+		{
+			iDepRecordsTail->iNext = aDep;
+			iDepRecordsTail = aDep;
+		}
+		aNeeded = aNeeded->iNext;
+	}
+
+	return (aNeededFound == iNumberOfImportDlls);
+}
+
+ELFFile::ELFDllData::DllRec* ELFFile::ELFDllData::SearchImports(char *aName)
+{
+	DllRec *aRec = iDllHead;
+	while (aRec)
+	{
+		if(strncmp(aRec->iName, aName, aRec->iLen) == 0)
+			return aRec;
+		aRec = aRec->iNext;
+	}
+	return NULL;
+}
+
+OrdZeroRecord* ELFFile::ELFDllData::FindDependency(char* aName, TUint aLen)
+{
+	OrdZeroRecord* aDep = iDepRecords;
+	while(aDep)
+	{
+		if(strncmp(aName, aDep->iName, aLen) == 0)
+			return aDep;
+		aDep = aDep->iNext;
+	}
+	return NULL;
+}
+
+void ELFFile::ELFDllData::GetExportSymInfoHeader(E32EpocExpSymInfoHdr& aSymInfoHdr)
+{
+	memcpy(&aSymInfoHdr, &iSymInfoHdr, sizeof(E32EpocExpSymInfoHdr));
+}
+
+void ELFFile::ELFDllData::SetExportSymInfo()
+{
+	iSymInfoHdr.iSymCount = (TUint16)iNamedExportCount;
+	iSymInfoHdr.iSymbolTblOffset = sizeof(E32EpocExpSymInfoHdr);
+	iSymInfoHdr.iStringTableSz = iSymStringTableSize;
+	TInt aSymTabSz;
+	if( iStringNameOffset > 0xffff){
+		iSymInfoHdr.iFlags = KNameLookupOffsetFlag32;  // Flag indicating 32 bit offsets 
+													   // for symbol names
+		aSymTabSz = iNamedExportCount* sizeof(TUint32);// symbol addresses
+		aSymTabSz += iNamedExportCount* sizeof(TUint32);// symbol name 32-bit offsets
+	}
+	else
+	{
+		iSymInfoHdr.iFlags &= ~KNameLookupOffsetFlag32;// Flag indicating 16-bit offsets 
+													   // for symbol names
+		aSymTabSz = iNamedExportCount* sizeof(TUint32);	// symbol addresses
+		aSymTabSz += iNamedExportCount* sizeof(TUint16);// symbol name 16-bit offsets
+		aSymTabSz = ALIGN4(aSymTabSz);
+	}
+	iSymInfoHdr.iStringTableOffset = iSymInfoHdr.iSymbolTblOffset + aSymTabSz;
+	iSymInfoHdr.iDllCount = iNumberOfImportDlls;
+	iSymInfoHdr.iDepDllZeroOrdTableOffset = iSymInfoHdr.iStringTableOffset + \
+								iSymInfoHdr.iStringTableSz;
+
+	iSymInfoHdr.iSize = iSymInfoHdr.iDepDllZeroOrdTableOffset + \
+						iSymInfoHdr.iDllCount * sizeof(Elf32_Addr);
+}
+
+TUint ELFFile::ELFDllData::GetSymLookupSection(char* aBuff)
+{
+	if( !iNamedLookupEnabled)
+		return 0;
+
+	memcpy(aBuff, &iSymInfoHdr, sizeof(iSymInfoHdr));
+	
+	// Name offsets start after the end of symbol addresses.
+	TUint32 aNameOffsetStart = iSymInfoHdr.iSymbolTblOffset + \
+								iNamedExportCount* sizeof(TUint32);
+																
+	TUint32 *aAddrPtr = (TUint32*)(aBuff + iSymInfoHdr.iSymbolTblOffset);
+	TUint32 aStringTabOff = 0;
+	char *aStringTab = aBuff + iSymInfoHdr.iStringTableOffset;//Start of the string table.
+	NamedExportSymbol *aSym = iNamedExportSymbolHead;
+	while(aSym)
+	{
+		*aAddrPtr = aSym->Value();
+		aStringTabOff = aSym->NameOffset(); // Get the offset of symbol name (which is wrt 
+											// string table base).
+		if( iSymInfoHdr.iFlags & KNameLookupOffsetFlag32 )
+		{
+			TUint32 *aNameOffPtr = (TUint32*)(aBuff + aNameOffsetStart);
+			*aNameOffPtr = (aStringTabOff >> 2);//write the offset of the name
+			strcpy(aStringTab + aStringTabOff, aSym->Name());//write the symbol name
+			aNameOffsetStart +=4;
+		}
+		else
+		{
+			TUint16 *aNameOffPtr = (TUint16*)(aBuff + aNameOffsetStart);
+			*aNameOffPtr = (TUint16)(aStringTabOff >> 2);//write the offset of the name
+			strcpy(aStringTab + aStringTabOff, aSym->Name());//write the symbol name
+			aNameOffsetStart +=2;
+		}
+		aAddrPtr++;
+		aSym = aSym->Next();
+	}
+
+	OrdZeroRecord *aRec = iDepRecords;
+	TUint32* aDepsTable = (TUint32*)(aBuff + iSymInfoHdr.iDepDllZeroOrdTableOffset);
+	while(aRec)
+	{
+		*aDepsTable++ = 0;
+		aRec = aRec->iNext;
+	}
+	return iSymInfoHdr.iSize;
+}
+
+void ELFFile::ELFDllData::Sort(NamedExportSymbol** aDstList, NamedExportSymbol* aSrcList)
+{
+	NamedExportSymbol *aSym = aSrcList;
+	NamedExportSymbol **aSymbols = new NamedExportSymbol*[iNamedExportCount];
+	
+	TInt pos;
+	for (pos = 0; pos < iNamedExportCount; pos++) {
+		aSymbols[pos] = aSym;
+		aSym = aSym->Next();
+	}
+	
+	NamedExportSymbol **aResult = new NamedExportSymbol*[iNamedExportCount];
+	MergeSort(aResult, aSymbols);
+	iNamedExportSymbolHead = aResult[0];
+	for (pos = 0; pos < iNamedExportCount; pos++) {
+		aSym = aResult[pos];
+		if( pos == iNamedExportCount-1)
+			aSym->Next(NULL);
+		else
+			aSym->Next(aResult[pos+1]);
+	}
+	*aDstList = aResult[0];
+	delete [] aResult;
+	delete [] aSymbols;
+}
+
+void ELFFile::ELFDllData::MergeSort(NamedExportSymbol** aDstList, NamedExportSymbol** aSrcList)
+{
+	MergeSort(aDstList, aSrcList, 0, iNamedExportCount);
+}
+
+void ELFFile::ELFDllData::MergeSort(NamedExportSymbol** aDstList, NamedExportSymbol** aSrcList, \
+									TUint aLeft, TUint aRight)
+{
+	if( (aRight - aLeft) <= 1)
+		return;
+
+	TUint aSize = aRight - aLeft;
+	TUint aCenter = aLeft + aSize/2;
+
+	MergeSort(aDstList, aSrcList, aLeft, aCenter);
+	MergeSort(aDstList, aSrcList, aCenter, aRight);
+
+	TUint aLPos, aRPos, aCnt;
+	aLPos = aLeft;
+	aRPos = aCenter;
+	for(aCnt = 0; aCnt < aSize; aCnt++)
+	{
+		if( (aLPos < aCenter) &&
+			(aRPos == aRight || (strcmp(aSrcList[aLPos]->Name(), aSrcList[aRPos]->Name()) < 0) )
+		  )
+		{
+			// Compare the left half with the right and add the lesser one.
+			// The comparision is done on the topmost element on each half.
+			// if aRPos is past the last element of the right half, the left element has 
+			// nothing to compare with. Just add it to the result list.
+			aDstList[aCnt] = aSrcList[aLPos];
+			aLPos++;
+		}
+		else
+		{
+			// Add the greater one into the list.
+			// if aLPos is past the element at the center, it anyway belongs to the
+			// right half. Add it to the result list.
+			aDstList[aCnt] = aSrcList[aRPos];
+			aRPos++;
+		}
+	}
+
+	// Once the sublist is sorted, put it back to the source list
+	// so that the parent has its left and right sublists are sorted.
+	for(aCnt = 0; aCnt < aSize; aCnt++)
+	{
+		aSrcList[aLeft+aCnt] = aDstList[aCnt];
+	}
+}
+