--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/toolsandutils/e32tools/elf2e32/source/pl_elfexecutable.cpp Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,1484 @@
+// 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 the Class ElfExecutable for the elf2e32 tool
+// @internalComponent
+// @released
+//
+//
+
+
+#include "pl_elfexecutable.h"
+#include "errorhandler.h"
+#include <stdio.h>
+#include "parameterlistinterface.h"
+#include "pl_elfimportrelocation.h"
+#include "pl_dllsymbol.h"
+#include "messagehandler.h"
+#include "pl_elflocalrelocation.h"
+
+
+/**
+Constructor for class ElfExecutable
+@param aParameterListInterface - Instance of class ParameterListInterface
+@internalComponent
+@released
+*/
+ElfExecutable::ElfExecutable(ParameterListInterface *aParameterListInterface) :\
+ iElfHeader(NULL), \
+ iEntryPoint(0),\
+ iProgHeader(NULL), \
+ iSONameOffset(0) ,\
+ iSections (NULL) , \
+ iVersionDef (NULL) , iVerDefCount(0), \
+ iVersionNeed (NULL) , iVerNeedCount(0), \
+ iVersionTbl (NULL) ,iRelSize(0),iRelEntSize(0), \
+ iNRelocs(0),
+ iRel (NULL) ,iRelaSize(0), iRelaEntSize(0), \
+ iRela(NULL),
+ iStringTable (NULL) , \
+ iSectionHdrStrTbl(NULL), \
+ iVerInfo(NULL), iElfDynSym (NULL), \
+ iSymTab (NULL), \
+ iStrTab (NULL), \
+ iLim (NULL), \
+ iNSymbols(0), \
+ iHashTbl (NULL) , \
+ iDynSegmentHdr (NULL) , \
+ iDataSegmentHdr (NULL) ,iDataSegment(NULL), iDataSegmentSize(0), iDataSegmentIdx(0), \
+ iCodeSegmentHdr (NULL) , iCodeSegment(NULL), iCodeSegmentSize(0), iCodeSegmentIdx(0), \
+ iExports (NULL), \
+ iParameterListInterface(aParameterListInterface),\
+ iPltGotBase(0), iPltGotLimit(0), iStrTabSz(0), iSymEntSz(0), \
+ iPltGot(NULL), iPltRel(NULL),iPltRelaSz(0), iPltRela(NULL), iPltRelSz(0) \
+
+{
+}
+
+
+/**
+Destructor for class ElfExecutable
+@internalComponent
+@released
+*/
+ElfExecutable::~ElfExecutable()
+{
+ delete iExports;
+ delete [] iVerInfo;
+ /*
+ all of these were getting deleted, they are not allocated by
+ ElfExecutable, they simply refer to a linear array of images
+ in an ElfImage, hence they shouldn't be de-allocated
+
+ delete iRela;
+ delete iPltRel;
+ delete iPltRela; */
+
+ iNeeded.clear();
+ iSymbolTable.clear();
+}
+
+
+/**
+Function to process Elf file
+@param aElfHdr - pointer to Elf header
+@return 0 if its valid ELF file
+@internalComponent
+@released
+*/
+PLUINT32 ElfExecutable::ProcessElfFile(Elf32_Ehdr *aElfHdr) {
+
+ iElfHeader = aElfHdr;
+ iEntryPoint = aElfHdr->e_entry;
+
+ ValidateElfFile();
+
+ /* A valid ELF file so far..*/
+
+ /* Get the Section base..*/
+ if(iElfHeader->e_shnum) {
+ iSections = ELF_ENTRY_PTR(Elf32_Shdr, iElfHeader, iElfHeader->e_shoff);
+ }
+
+ /* Get the program header..*/
+ if(iElfHeader->e_phnum) {
+ iProgHeader = ELF_ENTRY_PTR(Elf32_Phdr, iElfHeader, iElfHeader->e_phoff);
+ }
+
+ /* Get the section-header-string table..*/
+ if(iElfHeader->e_shstrndx != SHN_UNDEF) {
+
+ if(iElfHeader->e_shstrndx > iElfHeader->e_shnum ) {
+ throw ELFFormatError(ELFSHSTRINDEXERROR,iParameterListInterface->ElfInput());
+ }
+
+ iSectionHdrStrTbl = ELF_ENTRY_PTR(char, iElfHeader, iSections[iElfHeader->e_shstrndx].sh_offset);
+ }
+
+ if( iProgHeader ) {
+ PLUINT32 aIdx = 0;
+
+ while( aIdx < iElfHeader->e_phnum) {
+ switch( iProgHeader[aIdx].p_type ) {
+ case PT_DYNAMIC:
+ {
+ iDynSegmentHdr = &iProgHeader[aIdx];
+ }
+ break;
+ case PT_LOAD:
+ {
+ if( (iProgHeader[aIdx].p_flags) & (PF_X | PF_ARM_ENTRY) ) {
+ iCodeSegmentHdr = &iProgHeader[aIdx];
+ iCodeSegmentIdx = aIdx;
+ iCodeSegment = ELF_ENTRY_PTR(char, iElfHeader, iCodeSegmentHdr->p_offset);
+ iCodeSegmentSize = iCodeSegmentHdr->p_filesz;
+ }
+ else if( (iProgHeader[aIdx].p_flags) & (PF_W | PF_R) ) {
+ iDataSegmentHdr = &iProgHeader[aIdx];
+ iDataSegmentIdx = aIdx;
+ iDataSegment = ELF_ENTRY_PTR(char, iElfHeader, iDataSegmentHdr->p_offset);
+ iDataSegmentSize = iDataSegmentHdr->p_filesz;
+ }
+ }
+ break;
+ default:
+ break;
+
+ }
+ aIdx++;
+ }
+
+ if( iDynSegmentHdr ) {
+ ProcessDynamicEntries();
+ }
+
+ ProcessSymbols();
+ ProcessRelocations();
+ }
+
+ return 0;
+}
+
+/**
+Function to Find the Static Symbol Table
+@internalComponent
+@released
+*/
+void ElfExecutable::FindStaticSymbolTable()
+{
+ size_t nShdrs = iElfHeader->e_shnum;
+
+ if (nShdrs)
+ {
+ // Find the static symbol table and string table
+ for (PLUINT32 i = 0; i < nShdrs; i++)
+ {
+ if (iSections[i].sh_type == SHT_SYMTAB)
+ {
+ iSymTab = ELF_ENTRY_PTR(Elf32_Sym, iElfHeader, iSections[i].sh_offset);
+ iLim = ELF_ENTRY_PTR(Elf32_Sym, iSymTab, iSections[i].sh_size);
+ if (iStrTab) break;
+ }
+ else if (iSections[i].sh_type == SHT_STRTAB)
+ {
+ char * aSectionName = iSectionHdrStrTbl + iSections[i].sh_name;
+ if (!strcmp(aSectionName, ".strtab"))
+ {
+ iStrTab = ELF_ENTRY_PTR(char, iElfHeader, iSections[i].sh_offset);
+ if (iSymTab) break;
+ }
+ }
+ }
+ }
+}
+
+/**
+Function to Find the Comment Section
+@return aComment - Pointer to Comment Section
+@internalComponent
+@released
+*/
+char* ElfExecutable::FindCommentSection()
+{
+ size_t nShdrs = iElfHeader->e_shnum;
+ char *aCommentSection = ".comment";
+ char *aComment;
+
+ if (nShdrs)
+ {
+ // find the comment section
+ for (PLUINT32 i = 0; i < nShdrs; i++)
+ {
+ if (iSections[i].sh_type == SHT_PROGBITS)
+ {
+ char * aSectionName = iSectionHdrStrTbl + iSections[i].sh_name;
+ int length = strlen(aCommentSection);
+ if (!strncmp(aSectionName, aCommentSection, length))
+ {
+ aComment = ELF_ENTRY_PTR(char, iElfHeader, iSections[i].sh_offset);
+ return aComment;
+ }
+ }
+ }
+ }
+ return NULL;
+}
+
+/**
+Function to process the ARM to Thumb veneers
+@internalComponent
+@released
+*/
+void ElfExecutable::ProcessVeneers()
+{
+ if (iSymTab && iStrTab)
+ {
+ ElfRelocations::RelocationList & iLocalCodeRelocs = GetCodeRelocations();
+
+ Elf32_Sym *aSymTab = iSymTab;
+ int length = strlen("$Ven$AT$L$$");
+
+ // Process the symbol table to find Long ARM to Thumb Veneers
+ // i.e. symbols of the form '$Ven$AT$L$$'
+ for(; aSymTab < iLim; aSymTab++)
+ {
+ if (!aSymTab->st_name) continue;
+ char * aSymName = iStrTab + aSymTab->st_name;
+ Elf32_Sym *aSym;
+
+ if (!strncmp(aSymName, "$Ven$AT$L$$", length))
+ {
+ aSym = aSymTab;
+ Elf32_Addr r_offset = aSym->st_value;
+ Elf32_Addr aOffset = r_offset + 4;
+ Elf32_Word aInstruction = FindValueAtLoc(r_offset);
+ bool aRelocEntryFound = false;
+
+ ElfRelocations::RelocationList::iterator r;
+ for (r = iLocalCodeRelocs.begin(); r != iLocalCodeRelocs.end(); r++)
+ {
+ ElfLocalRelocation * aReloc = *r;
+ // Check if there is a relocation entry for the veneer symbol
+ if (aReloc->iAddr == aOffset)
+ {
+ aRelocEntryFound = true;
+ break;
+ }
+ }
+
+ Elf32_Word aPointer = FindValueAtLoc(aOffset);
+
+ /* If the symbol addresses a Thumb instruction, its value is the
+ * address of the instruction with bit zero set (in a
+ * relocatable object, the section offset with bit zero set).
+ * This allows a linker to distinguish ARM and Thumb code symbols
+ * without having to refer to the map. An ARM symbol will always have
+ * an even value, while a Thumb symbol will always have an odd value.
+ * Reference: Section 4.5.3 in Elf for the ARM Architecture Doc
+ * aIsThumbSymbol will be 1 for a thumb symbol and 0 for ARM symbol
+ */
+ int aIsThumbSymbol = aPointer & 0x1;
+
+ /* The relocation entry should be generated for the veneer only if
+ * the following three conditions are satisfied:
+ * 1) Check if the instruction at the symbol is as expected
+ * i.e. has the bit pattern 0xe51ff004 == 'LDR pc,[pc,#-4]'
+ * 2) There is no relocation entry generated for the veneer symbol
+ * 3) The instruction in the location provided by the pointer is a thumb symbol
+ */
+ if (aInstruction == 0xE51FF004 && !aRelocEntryFound && aIsThumbSymbol)
+ {
+ ElfLocalRelocation *aRel;
+ PLUCHAR aType = R_ARM_NONE;
+
+ aRel = new ElfLocalRelocation(this, aOffset, 0, 0, aType, NULL, ESegmentRO, aSym, false, true);
+ if(aRel)
+ {
+ aRel->Add();
+ }
+ }
+ }
+ }
+ }
+}
+
+/**
+Function to find the content of the address passed in
+@param aOffset - Address
+@return aLocVal - The content of the address, like instruction or a pointer
+@internalComponent
+@released
+*/
+Elf32_Word ElfExecutable::FindValueAtLoc(Elf32_Addr aOffset)
+{
+ Elf32_Phdr *aHdr = Segment(aOffset);
+ PLUINT32 aLoc = aHdr->p_offset + aOffset - aHdr->p_vaddr;
+ Elf32_Word *aLocVal = ELF_ENTRY_PTR(Elf32_Word, iElfHeader, aLoc);
+ return *aLocVal;
+}
+
+/**
+Function to process Elf symbols
+@internalComponent
+@released
+*/
+PLUINT32 ElfExecutable::ProcessSymbols(){
+ PLUINT32 aSymIdx = 0;
+ DllSymbol *aSymbol;
+ char *aDllName;
+ char *aSymName, *aNewSymName;
+ SymbolType aType;
+
+ while( aSymIdx < iNSymbols ) {
+
+ aSymName = ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aSymIdx].st_name );
+
+ if( ExportedSymbol( &iElfDynSym[aSymIdx] ) ){
+
+ if( FunctionSymbol( &iElfDynSym[aSymIdx] ))
+ aType = SymbolTypeCode;
+ else
+ aType = SymbolTypeData;
+
+ aSymName = ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aSymIdx].st_name );
+ aDllName = iVerInfo[iVersionTbl[aSymIdx]].iLinkAs;
+ aNewSymName = new char[strlen(aSymName)+1];
+ strcpy(aNewSymName, aSymName);
+ aSymbol = new DllSymbol( aNewSymName, aType, &iElfDynSym[aSymIdx], aSymIdx);
+ aSymbol->SetSymbolSize(iElfDynSym[aSymIdx].st_size);
+
+ //Putting the symbols into a hash table - Used later while processing relocations
+ iSymbolTable[aSymIdx] = aSymbol ;
+ if( !AddToExports( aDllName, aSymbol ))
+ {
+ //Not a valid export... delete it..
+ delete aSymbol;
+ }
+ }
+ else if( ImportedSymbol( &iElfDynSym[aSymIdx] ) ){
+
+ if( FunctionSymbol( &iElfDynSym[aSymIdx] ))
+ aType = SymbolTypeCode;
+ else
+ aType = SymbolTypeData;
+
+ aSymName = ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aSymIdx].st_name );
+
+ /*
+ * All imported symbols must be informed via the version needed information.
+ */
+ if( iVerInfo[iVersionTbl[aSymIdx]].iVerCategory != VER_CAT_NEEDED ) {
+ throw UndefinedSymbolError(UNDEFINEDSYMBOLERROR, iParameterListInterface->ElfInput(), aSymName);
+ }
+ aDllName = iVerInfo[iVersionTbl[aSymIdx]].iLinkAs;
+ //aSymbol = new DllSymbol( aSymName, aType, &iElfDynSym[aSymIdx], aSymIdx);
+
+ //Putting the symbols into a hash table
+ //iSymbolTable[aSymIdx] = aSymbol ;
+ }
+ aSymIdx++;
+ }
+
+ return 0;
+}
+
+/**
+This function Dump all the sections with their section details (i.e., the section name, type,
+size and linked section if any)
+@param aFile - ELF file name
+@internalComponent
+@released
+*/
+void ElfExecutable::DumpElfFile(char* aFile){
+ aFile = aFile;
+}
+
+
+/**
+This function adds exports into the export list
+@param aDll - Dll name
+@param aSymbol - Symbol
+@return
+@internalComponent
+@released
+*/
+DllSymbol* ElfExecutable::AddToExports(char* aDll, DllSymbol* aSymbol){
+ if( !iExports ) {
+ iExports = new ElfExports();
+ }
+ return iExports->Add( aDll, this, aSymbol );
+}
+
+
+/**
+This function adds imports into the map
+@param aReloc - Instance of class ElfImportRelocation
+@internalComponent
+@released
+*/
+void ElfExecutable::AddToImports(ElfImportRelocation* aReloc){
+ SetVersionRecord(aReloc);
+ //char *aDll = iVerInfo[iVersionTbl[aReloc->iSymNdx]].iLinkAs;
+ char *aDll = aReloc->iVerRecord->iLinkAs;
+ iImports.Add( (const char*)aDll, aReloc );
+
+}
+
+/**
+This function adds local relocation into a list
+@param aReloc - Instance of class ElfImportRelocation
+@internalComponent
+@released
+*/
+void ElfExecutable::AddToLocalRelocations(ElfRelocation* aReloc) {
+ iLocalRelocations.Add((ElfLocalRelocation*)aReloc);
+}
+
+/**
+This function records the version of an imported symbol
+@param aReloc - Instance of class ElfImportRelocation
+@internalComponent
+@released
+*/
+void ElfExecutable::SetVersionRecord( ElfRelocation* aReloc ) {
+ if( !aReloc )
+ return;
+ ((ElfImportRelocation*)aReloc)->iVerRecord = &iVerInfo[ iVersionTbl[aReloc->iSymNdx]];
+}
+
+/**
+This function validates the ELF file
+@internalComponent
+@released
+*/
+PLUINT32 ElfExecutable::ValidateElfFile() {
+
+ /*Check if the ELF-Magic is correct*/
+ if(!(iElfHeader->e_ident[EI_MAG0] == ELFMAG0) &&
+ (iElfHeader->e_ident[EI_MAG1] == ELFMAG1) &&
+ (iElfHeader->e_ident[EI_MAG2] == ELFMAG2) &&
+ (iElfHeader->e_ident[EI_MAG3] == ELFMAG3) ) {
+ throw ELFFormatError(ELFMAGICERROR, iParameterListInterface->ElfInput());
+ }
+
+ /*32-bit ELF file*/
+ if(iElfHeader->e_ident[EI_CLASS] != ELFCLASS32) {
+ throw ELFFormatError(ELFCLASSERROR, iParameterListInterface->ElfInput());
+ }
+
+ /* Check if the ELF file is in Little endian format*/
+ if(iElfHeader->e_ident[EI_DATA] != ELFDATA2LSB) {
+ throw ELFFormatError(ELFLEERROR, iParameterListInterface->ElfInput());
+ }
+
+ /* The ELF executable must be a DLL or an EXE*/
+ if( iElfHeader->e_type != ET_EXEC && iElfHeader->e_type != ET_DYN) {
+ throw ELFFormatError(ELFEXECUTABLEERROR, iParameterListInterface->ElfInput());
+ }
+
+ return 0;
+}
+
+
+/**
+This function processes the dynamic table.
+@internalComponent
+@released
+*/
+PLUINT32 ElfExecutable::ProcessDynamicEntries(){
+
+ PLUINT32 aIdx = 0;
+ bool aSONameFound = false;
+ bool aPltRelTypeSeen = false, aJmpRelSeen = false;
+ list<PLUINT32> aNeeded;
+ Elf32_Dyn *aDyn = ELF_ENTRY_PTR(Elf32_Dyn, iElfHeader, iDynSegmentHdr->p_offset);
+
+ while( aDyn[aIdx].d_tag != DT_NULL ) {
+ switch (aDyn[aIdx].d_tag) {
+ case DT_NEEDED:
+ aNeeded.push_back( aDyn[aIdx].d_val );
+ break;
+ case DT_HASH:
+ iHashTbl = ELF_ENTRY_PTR(Elf32_HashTable, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_STRTAB:
+ iStringTable = ELF_ENTRY_PTR(char, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_SYMTAB:
+ iElfDynSym = ELF_ENTRY_PTR(Elf32_Sym, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_RELA:
+ iRela = ELF_ENTRY_PTR(Elf32_Rela, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_RELASZ:
+ iRelaSize = aDyn[aIdx].d_val;
+ break;
+ case DT_RELAENT:
+ iRelaEntSize = aDyn[aIdx].d_val;
+ break;
+ case DT_SONAME:
+ aSONameFound = true;
+ iSONameOffset = aDyn[aIdx].d_val;
+ break;
+ case DT_REL:
+ iRel = ELF_ENTRY_PTR(Elf32_Rel, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_RELSZ:
+ iRelSize = aDyn[aIdx].d_val;
+ break;
+ case DT_RELENT:
+ iRelEntSize = aDyn[aIdx].d_val;
+ break;
+ case DT_VERSYM:
+ iVersionTbl = ELF_ENTRY_PTR(Elf32_Half, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_VERDEF:
+ iVersionDef = ELF_ENTRY_PTR(Elf32_Verdef, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_VERDEFNUM:
+ iVerDefCount = aDyn[aIdx].d_val;
+ break;
+ case DT_VERNEED:
+ iVersionNeed = ELF_ENTRY_PTR(Elf32_Verneed, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_VERNEEDNUM:
+ iVerNeedCount = aDyn[aIdx].d_val;
+ break;
+ case DT_STRSZ:
+ iStrTabSz = aDyn[aIdx].d_val;
+ break;
+ case DT_SYMENT:
+ iSymEntSz = aDyn[aIdx].d_val;
+ break;
+ case DT_PLTRELSZ:
+ iPltRelSz = aDyn[aIdx].d_val;
+ break;
+ case DT_PLTGOT:
+ iPltGot = ELF_ENTRY_PTR(Elf32_Word, iElfHeader, aDyn[aIdx].d_val);
+ break;
+ case DT_RPATH:
+ break;
+ case DT_SYMBOLIC:
+ break;
+ case DT_INIT:
+ break;
+ case DT_FINI:
+ break;
+ case DT_PLTREL:
+ aPltRelTypeSeen = true;
+ iPltRelType = aDyn[aIdx].d_val;
+ break;
+ case DT_DEBUG:
+ break;
+ case DT_TEXTREL:
+ break;
+ case DT_JMPREL:
+ aJmpRelSeen = true;
+ iJmpRelOffset = aDyn[aIdx].d_val;
+ break;
+ case DT_BIND_NOW:
+ break;
+ case DT_INIT_ARRAY:
+ break;
+ case DT_FINI_ARRAY:
+ break;
+ case DT_INIT_ARRAYSZ:
+ break;
+ case DT_FINI_ARRAYSZ:
+ break;
+ case DT_RELCOUNT:
+ break;
+ case DT_ARM_PLTGOTBASE:
+ iPltGotBase = aDyn[aIdx].d_val;
+ break;
+ case DT_ARM_PLTGOTLIMIT:
+ iPltGotLimit = aDyn[aIdx].d_val;
+ break;
+ case DT_ARM_SYMTABSZ:
+ iNSymbols = aDyn[aIdx].d_val;
+ break;
+ default:
+ //cout << "Unknown entry in dynamic table Tag=0x%x Value=0x%x",aDyn[aIdx].d_tag, aDyn[aIdx].d_val);
+ break;
+ }
+ aIdx++;
+ }
+
+ //String table is found, so get the strings...
+ if(aSONameFound) {
+ iSOName = ELF_ENTRY_PTR(char, iStringTable, iSONameOffset);
+ }
+
+ std::list<PLUINT32>::iterator aItr = aNeeded.begin();
+ char *aStr;
+ for( ; aItr != aNeeded.end();aItr++ ) {
+ aStr = ELF_ENTRY_PTR(char, iStringTable, *aItr);
+ iNeeded.push_back( aStr );
+ }
+
+ if(iVerNeedCount || iVerDefCount) {
+ ProcessVerInfo();
+ }
+
+ if(iHashTbl)
+ {
+ //The number of symbols should be same as the number of chains in hashtable
+ if (iNSymbols && (iNSymbols != iHashTbl->nChains))
+ throw ELFFormatError(SYMBOLCOUNTMISMATCHERROR,(char*)iParameterListInterface->ElfInput());
+ else
+ //The number of symbols is same as the number of chains in hashtable
+ iNSymbols = iHashTbl->nChains;
+ }
+
+ if( aPltRelTypeSeen && aJmpRelSeen) {
+
+ if (iPltRelType == DT_REL)
+ {
+ iPltRel = ELF_ENTRY_PTR(Elf32_Rel, iElfHeader, iJmpRelOffset);
+ // check to see if PltRels are included in iRel. If they are
+ // ignore them since we don't care about the distinction
+ if (iRel <= iPltRel && iPltRel < ELF_ENTRY_PTR(Elf32_Rel, iRel, iRelSize))
+ iPltRel = 0;
+ }
+ else
+ {
+ iPltRela = ELF_ENTRY_PTR(Elf32_Rela, iElfHeader, iJmpRelOffset);
+ // check to see if PltRels are included in iRel. If they are
+ // ignore them since we don't care about the distinction
+ if (iRela <= iPltRela && iPltRela < ELF_ENTRY_PTR(Elf32_Rela, iRela, iRelaSize))
+ iPltRela = 0;
+ }
+ }
+
+ return 0;
+}
+
+/**
+This function processes version information
+@internalComponent
+@released
+*/
+void ElfExecutable::ProcessVerInfo() {
+ PLUINT32 aSz = iVerNeedCount + iVerDefCount + 1;
+ iVerInfo = new VersionInfo[aSz];
+
+ Elf32_Verdef *aDef;
+ Elf32_Verdaux *aDaux;
+ Elf32_Verneed *aNeed;
+ Elf32_Vernaux *aNaux;
+ char *aSoName;
+ char *aLinkAs;
+
+ aDef = iVersionDef;
+
+ while( aDef ) {
+ aDaux = ELF_ENTRY_PTR( Elf32_Verdaux, aDef, aDef->vd_aux);
+ aLinkAs = ELF_ENTRY_PTR(char, iStringTable, aDaux->vda_name );
+ aSoName = iSOName;
+ iVerInfo[aDef->vd_ndx].iLinkAs = aLinkAs;
+ iVerInfo[aDef->vd_ndx].iSOName = aSoName;
+ iVerInfo[aDef->vd_ndx].iVerCategory = VER_CAT_DEFINED;
+
+ if( !aDef->vd_next ) {
+ break;
+ }
+ aDef = ELF_ENTRY_PTR(Elf32_Verdef, aDef, aDef->vd_next);
+ }
+
+ aNeed = iVersionNeed;
+
+ while( aNeed ) {
+ aNaux = ELF_ENTRY_PTR(Elf32_Vernaux, aNeed, aNeed->vn_aux);
+ aLinkAs = ELF_ENTRY_PTR(char, iStringTable, aNaux->vna_name);
+ aSoName = ELF_ENTRY_PTR(char, iStringTable, aNeed->vn_file);
+
+ iVerInfo[aNaux->vna_other].iLinkAs = aLinkAs;
+ iVerInfo[aNaux->vna_other].iSOName = aSoName;
+ iVerInfo[aNaux->vna_other].iVerCategory = VER_CAT_NEEDED;
+
+ if( !aNeed->vn_next ) {
+ break;
+ }
+ aNeed = ELF_ENTRY_PTR(Elf32_Verneed, aNeed, aNeed->vn_next);
+ }
+}
+
+/**
+This function processes Elf relocations
+@internalComponent
+@released
+*/
+void ElfExecutable::ProcessRelocations(){
+ ProcessRelocations(iRel, iRelSize);
+ ProcessRelocations(iRela, iRelaSize);
+ ProcessRelocations(iPltRel, iPltRelSz);
+ ProcessRelocations(iPltRela, iPltRelaSz);
+}
+
+/**
+Template Function to process relocations
+@param aElfRel - relocation table
+@param aSize - relocation table size
+@internalComponent
+@released
+*/
+template <class T>
+void ElfExecutable::ProcessRelocations(T *aElfRel, size_t aSize){
+ if( !aElfRel )
+ return;
+
+ T * aElfRelLimit = ELF_ENTRY_PTR(T, aElfRel, aSize);
+
+ PLUINT32 aSymIdx;
+ PLUCHAR aType;
+ ElfRelocation *aRel;
+ bool aImported;
+ Elf32_Word aAddend;
+
+ while( aElfRel < aElfRelLimit) {
+
+ aType = ELF32_R_TYPE(aElfRel->r_info );
+
+ if(ElfRelocation::ValidRelocEntry(aType)) {
+
+ aSymIdx = ELF32_R_SYM(aElfRel->r_info);
+ aImported = ImportedSymbol( &iElfDynSym[aSymIdx] );
+ aAddend = Addend(aElfRel);
+ aRel = ElfRelocation::NewRelocEntry(this, aElfRel->r_offset, aAddend, \
+ aSymIdx, aType, aElfRel, aImported);
+
+ if(aRel) {
+ aRel->Add();
+ }
+ }
+ aElfRel++;
+ }
+}
+
+/**
+This function finds the addend associated with a relocation entry.
+@param aRel - relocation entry
+@return location in the elf image
+@internalComponent
+@released
+*/
+Elf32_Word ElfExecutable::Addend(Elf32_Rel* aRel) {
+ PLUINT32 aOffset;
+ Elf32_Word *aAddendPlace;
+ Elf32_Phdr *aHdr = Segment(aRel->r_offset);
+ aOffset = aHdr->p_offset + aRel->r_offset - aHdr->p_vaddr;
+ aAddendPlace = ELF_ENTRY_PTR(Elf32_Word, iElfHeader, aOffset);
+ return *aAddendPlace;
+}
+
+/**
+This function returns the addend for a relocation entry
+@param aRel - relocation entry
+@return location in the elf image
+@internalComponent
+@released
+*/
+Elf32_Word ElfExecutable::Addend(Elf32_Rela* aRel) {
+ return aRel->r_addend;
+}
+
+/**
+This function gets the version info at an index
+@param aIndex - index into the version table
+@return version record
+@internalComponent
+@released
+*/
+VersionInfo* ElfExecutable::GetVersionInfo(PLUINT32 aIndex){
+ return &iVerInfo[ iVersionTbl[aIndex]];
+}
+
+
+/**
+This function returns the Dll name in which an imported symbol is
+defined by looking in the version required section.
+@param aSymbolIndex - Index of symbol
+@return Dll name
+@internalComponent
+@released
+*/
+char* ElfExecutable::SymbolDefinedInDll(PLUINT32 aSymbolIndex){
+
+ VersionInfo *aVInfo = GetVersionInfo(aSymbolIndex);
+ return aVInfo ? aVInfo->iLinkAs : NULL;
+}
+
+/**
+This function returns the DSO(import library) name where the Symbol information can be found.
+This DSO is then looked up for the ordinal number of this symbol.
+@param aSymbolIndex - Index of symbol
+@return DSO name
+@internalComponent
+@released
+*/
+char* ElfExecutable::SymbolFromDSO(PLUINT32 aSymbolIndex){
+
+ VersionInfo *aVInfo = GetVersionInfo(aSymbolIndex);
+ return aVInfo ? aVInfo->iSOName : NULL;
+}
+
+/**
+This function returns the segment type
+@param aAddr - Address
+@return Segment type
+@internalComponent
+@released
+*/
+ESegmentType ElfExecutable::SegmentType(Elf32_Addr aAddr) {
+
+ try {
+ Elf32_Phdr *aHdr = Segment(aAddr);
+ if( !aHdr )
+ return ESegmentUndefined;
+
+ if( aHdr == iCodeSegmentHdr)
+ return ESegmentRO;
+ else if(aHdr == iDataSegmentHdr)
+ return ESegmentRW;
+ else
+ return ESegmentUndefined;
+ }
+ catch(...)
+ {
+ }
+
+ return ESegmentUndefined;
+}
+
+/**
+This function returns the segment type
+@param aType
+@return Segment header
+@internalComponent
+@released
+*/
+Elf32_Phdr* ElfExecutable::Segment(ESegmentType aType) {
+
+ switch(aType)
+ {
+ case ESegmentRO:
+ return iCodeSegmentHdr;
+ case ESegmentRW:
+ return iDataSegmentHdr;
+ default:
+ return NULL;
+ }
+}
+
+/**
+Function to get segment header
+@param aAddr - Address
+@return Segment header
+@internalComponent
+@released
+*/
+Elf32_Phdr* ElfExecutable::Segment(Elf32_Addr aAddr) {
+
+ if(iCodeSegmentHdr) {
+ PLUINT32 aBase = iCodeSegmentHdr->p_vaddr;
+ if( aBase <= aAddr && aAddr < (aBase + iCodeSegmentHdr->p_memsz) ) {
+ return iCodeSegmentHdr;
+ }
+ }
+ if(iDataSegmentHdr) {
+ PLUINT32 aBase = iDataSegmentHdr->p_vaddr;
+ if( aBase <= aAddr && aAddr < (aBase + iDataSegmentHdr->p_memsz) ) {
+ return iDataSegmentHdr;
+ }
+ }
+
+ throw int(0);
+}
+
+/**
+Thsi function returns the segment header to which the address refers.
+@param aAddr - location
+@return Segment header.
+@internalComponent
+@released
+*/
+Elf32_Phdr* ElfExecutable::SegmentFromAbs(Elf32_Addr aAddr) {
+
+ if(iCodeSegmentHdr) {
+ PLUINT32 aBase = iCodeSegmentHdr->p_vaddr;
+ if( aBase <= aAddr && aAddr <= (aBase + iCodeSegmentHdr->p_memsz) ) {
+ return iCodeSegmentHdr;
+ }
+ }
+ if(iDataSegmentHdr) {
+ PLUINT32 aBase = iDataSegmentHdr->p_vaddr;
+ if( aBase <= aAddr && aAddr <= (aBase + iDataSegmentHdr->p_memsz) ) {
+ return iDataSegmentHdr;
+ }
+ }
+ return NULL;
+}
+
+/**
+This function says if the symbol is global.
+@param aSym - Symbol
+@return True if symbol is global, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::GlobalSymbol(Elf32_Sym* aSym)
+{
+ return (ELF32_ST_BIND(aSym->st_info) == STB_GLOBAL);
+}
+
+/**
+This function says if the symbol is exported.
+@param aSym - Symbol
+@return True if symbol is exported, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::ExportedSymbol(Elf32_Sym* aSym)
+{
+ PLUINT32 aIdx = aSym->st_shndx;
+
+ if(GlobalSymbol(aSym) && VisibleSymbol(aSym) && DefinedSymbol(aSym) && \
+ (aIdx != SHN_UNDEF) && (FunctionSymbol(aSym) || DataSymbol(aSym) ) && aIdx < SHN_ABS )
+ return true;
+ return false;
+}
+
+/**
+This function says if the symbol is imported.
+@param aSym - Symbol
+@return True if symbol is imported, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::ImportedSymbol(Elf32_Sym* aSym)
+{
+ PLUINT32 aIdx = aSym->st_shndx;
+
+ if( (aIdx == SHN_UNDEF) && GlobalSymbol(aSym) && VisibleSymbol(aSym) && (!DefinedSymbol(aSym)) )
+ return true;
+ return false;
+}
+
+/**
+This function says if the symbol refers to code or data.
+@param aSym - Symbol
+@return True if symbol refers to code, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::FunctionSymbol(Elf32_Sym* aSym)
+{
+ return (STT_FUNC == ELF32_ST_TYPE(aSym->st_info));
+}
+
+/**
+This function says if the symbol refers to code or data.
+@param aSym - Symbol
+@return True if symbol refers to data, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::DataSymbol(Elf32_Sym* aSym)
+{
+ return (STT_OBJECT == ELF32_ST_TYPE(aSym->st_info));
+}
+
+/**
+This function says if the symbol is defined in the Elf executable.
+@param aSym - Symbol
+@return True if symbol is defined, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::DefinedSymbol(Elf32_Sym* aSym)
+{
+ if( aSym->st_shndx == SHN_UNDEF )
+ return false;
+ ESegmentType aType = SegmentType(aSym->st_value);
+ return ((aType == ESegmentRO) || (aType == ESegmentRW));
+}
+
+/**
+This function says if the visibility of the symbol is default.
+@param aSym - Symbol
+@return True if symbol has default visibility, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::VisibleSymbol(Elf32_Sym* aSym)
+{
+ return (STV_DEFAULT == ELF32_ST_VISIBILITY(aSym->st_other) || STV_PROTECTED == ELF32_ST_VISIBILITY(aSym->st_other));
+}
+
+/**
+This function finds symbol using the hash table
+@param aName - Symbol name
+@return elf symbol.
+@internalComponent
+@released
+*/
+Elf32_Sym* ElfExecutable::FindSymbol(char* aName) {
+ if(!aName )
+ return NULL;
+
+ PLULONG aHashVal = Util::elf_hash((const PLUCHAR*) aName );
+
+ Elf32_Sword* aBuckets = ELF_ENTRY_PTR(Elf32_Sword, iHashTbl, sizeof(Elf32_HashTable) );
+ Elf32_Sword* aChains = ELF_ENTRY_PTR(Elf32_Sword, aBuckets, sizeof(Elf32_Sword)*(iHashTbl->nBuckets) );
+
+ Elf32_Sword aIdx = aHashVal % iHashTbl->nBuckets;
+ aIdx = aBuckets[aIdx];
+
+ char *aSymName;
+ do {
+ aSymName = ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aIdx].st_name);
+ if( !strcmp(aSymName, aName) ) {
+ return &iElfDynSym[aIdx];
+ }
+ aIdx = aChains[aIdx];
+ }while( aIdx > 0 );
+
+ return NULL;
+}
+
+/**
+Function to get symbol name
+@param aSymIdx - Index of symbol
+@return Symbol name
+@internalComponent
+@released
+*/
+char* ElfExecutable::GetSymbolName( PLUINT32 aSymIdx) {
+ return ELF_ENTRY_PTR(char, iStringTable, iElfDynSym[aSymIdx].st_name);
+}
+
+/**
+Function to get symbol ordinal
+@param aSymName - Symbol name
+@return Symbol ordinal
+@internalComponent
+@released
+*/
+PLUINT32 ElfExecutable::GetSymbolOrdinal( char* aSymName) {
+ Elf32_Sym *aSym = FindSymbol(aSymName);
+ if( !aSym )
+ return (PLUINT32)-1;
+ return GetSymbolOrdinal( aSym );
+
+}
+
+/**
+Function to get symbol ordinal
+@param aSym - Symbol
+@return Symbol ordinal
+@internalComponent
+@released
+*/
+PLUINT32 ElfExecutable::GetSymbolOrdinal( Elf32_Sym* aSym) {
+ PLUINT32 aOrd = (PLUINT32)-1;
+ if( aSym->st_shndx == ESegmentRO) {
+ Elf32_Word *aLocation, aOffset;
+
+ aOffset = iCodeSegmentHdr->p_offset + aSym->st_value - iCodeSegmentHdr->p_vaddr;
+ aLocation = ELF_ENTRY_PTR(Elf32_Word, iElfHeader, aOffset);
+ aOrd = *aLocation;
+ }
+ return aOrd;
+}
+
+/**
+Function to get relocation offset
+@param aReloc - Instance of class ElfRelocation
+@return offset
+@internalComponent
+@released
+*/
+Elf32_Word ElfExecutable::GetRelocationOffset(ElfRelocation * aReloc)
+{
+ Elf32_Phdr * aHdr = Segment(aReloc->iAddr);
+ unsigned int aOffset = aReloc->iAddr - aHdr->p_vaddr;
+ return aOffset;
+}
+
+/**
+Function to get relocation place address
+@param aReloc - Instance of class ElfRelocation
+@return address to place relocation
+@internalComponent
+@released
+*/
+Elf32_Word * ElfExecutable::GetRelocationPlace(ElfRelocation * aReloc)
+{
+ Elf32_Phdr * aHdr = Segment(aReloc->iAddr);
+ unsigned int aOffset = aHdr->p_offset + aReloc->iAddr - aHdr->p_vaddr;
+ Elf32_Word * aPlace = ELF_ENTRY_PTR(Elf32_Word, iElfHeader, aOffset);
+ return aPlace;
+}
+
+/**
+Function to get local relocation
+@return local relocation
+@internalComponent
+@released
+*/
+ElfRelocations& ElfExecutable::GetLocalRelocations()
+{
+ return iLocalRelocations;
+}
+
+/**
+Function to get code relocation
+@return code relocation list
+@internalComponent
+@released
+*/
+ElfRelocations::RelocationList & ElfExecutable::GetCodeRelocations()
+{
+ return GetLocalRelocations().GetCodeRelocations();
+}
+
+/**
+Function to get data relocation
+@return data relocation list
+@internalComponent
+@released
+*/
+ElfRelocations::RelocationList & ElfExecutable::GetDataRelocations()
+{
+ return GetLocalRelocations().GetDataRelocations();
+}
+
+/**
+Function to get RO base address
+@return RO base virtual address
+@internalComponent
+@released
+*/
+Elf32_Word ElfExecutable::GetROBase()
+{
+ if (iCodeSegmentHdr) return iCodeSegmentHdr->p_vaddr;
+ return 0;
+}
+
+/**
+Function to get RO segment
+@return code segment
+@internalComponent
+@released
+*/
+MemAddr ElfExecutable::GetRawROSegment()
+{
+ return iCodeSegment;
+}
+
+/**
+Function to get RW segment virtual address
+@return RW base address
+@internalComponent
+@released
+*/
+Elf32_Word ElfExecutable::GetRWBase()
+{
+ if (iDataSegmentHdr) return iDataSegmentHdr->p_vaddr;
+ return 0;
+}
+
+/**
+Function to get Raw RW segment
+@return data segment address
+@internalComponent
+@released
+*/
+MemAddr ElfExecutable::GetRawRWSegment()
+{
+ return iDataSegment;
+}
+
+/**
+Function to get RO segment size
+@return code segment size
+@internalComponent
+@released
+*/
+size_t ElfExecutable::GetROSize()
+{
+ return iCodeSegmentHdr->p_filesz;
+}
+
+/**
+Function to get RW segment size
+@return data segment size
+@internalComponent
+@released
+*/
+size_t ElfExecutable::GetRWSize()
+{
+ if (iDataSegmentHdr)
+ return iDataSegmentHdr->p_filesz;;
+ return 0;
+}
+
+/**
+Function to get Bss segment size
+@return Bss segment size, if data segment, otherwise 0
+@internalComponent
+@released
+*/
+size_t ElfExecutable::GetBssSize()
+{
+ if (iDataSegmentHdr)
+ return iDataSegmentHdr->p_memsz - iDataSegmentHdr->p_filesz;
+ return 0;
+}
+
+/**
+Function returns entry point location in Elf image.
+@return entry point offset if valid, warning if undefined, otherwise throw error
+@internalComponent
+@released
+*/
+Elf32_Word ElfExecutable::EntryPointOffset()
+{
+ if (!(iElfHeader->e_entry) && !(iCodeSegmentHdr->p_vaddr))
+ {
+ MessageHandler::GetInstance()->ReportMessage(WARNING, UNDEFINEDENTRYPOINTERROR,(char*)iParameterListInterface->ElfInput());
+ return 0;
+ }
+ else if (!(iElfHeader->e_entry))
+ throw ELFFormatError(ENTRYPOINTNOTSETERROR, (char*)iParameterListInterface->ElfInput());
+ else
+ return iElfHeader->e_entry - iCodeSegmentHdr->p_vaddr;
+}
+
+/**
+Function to check exception is present in the Elf image.
+@return True if exception present, otherwise false
+@internalComponent
+@released
+*/
+bool ElfExecutable::ExeceptionsPresentP()
+{
+ size_t nShdrs = iElfHeader->e_shnum;
+ if (nShdrs)
+ {
+ // Find the exception index table section
+ Elf32_Shdr * aShdr = ELF_ENTRY_PTR(Elf32_Shdr, iElfHeader, iElfHeader->e_shoff);
+ char * aShStrTab = ELF_ENTRY_PTR(char, iElfHeader, aShdr[iElfHeader->e_shstrndx].sh_offset);
+
+ for (PLUINT32 i = 0; i < nShdrs; i++)
+ {
+ if (aShdr[i].sh_type == SHT_ARM_EXIDX)
+ {
+ char * aSectionName = aShStrTab + aShdr[i].sh_name;
+ if (!strcmp(aSectionName, ".ARM.exidx"))
+ {
+ return true;
+ }
+ }
+ }
+
+ }
+ else
+ throw ELFFileError(NEEDSECTIONVIEWERROR, (char*)iParameterListInterface->ElfInput());
+
+ return false;
+}
+
+/**
+Function to get the exports in ordinal number order.
+@return ordered exports
+@internalComponent
+@released
+*/
+ElfExports::ExportList &ElfExecutable::GetExportsInOrdinalOrder() {
+ return iExports->GetExportsInOrdinalOrder();
+}
+
+/**
+This function looks up for a symbol in the static symbol table.
+@return Elf symbol.
+@internalComponent
+@released
+*/
+Elf32_Sym * ElfExecutable::LookupStaticSymbol(char * aName) {
+ size_t nShdrs = iElfHeader->e_shnum;
+ if (nShdrs)
+ {
+ // find the static symbol table and string table
+ Elf32_Shdr * aShdr = ELF_ENTRY_PTR(Elf32_Shdr, iElfHeader, iElfHeader->e_shoff);
+ char * aShStrTab = ELF_ENTRY_PTR(char, iElfHeader, aShdr[iElfHeader->e_shstrndx].sh_offset);
+ Elf32_Sym * aSymTab = 0;
+ Elf32_Sym * aLim = 0;
+ char * aStrTab = 0;
+ for (PLUINT32 i = 0; i < nShdrs; i++)
+ {
+ if (aShdr[i].sh_type == SHT_SYMTAB)
+ {
+ aSymTab = ELF_ENTRY_PTR(Elf32_Sym, iElfHeader, aShdr[i].sh_offset);
+ aLim = ELF_ENTRY_PTR(Elf32_Sym, aSymTab, aShdr[i].sh_size);
+ if (aStrTab) break;
+ }
+ else if (aShdr[i].sh_type == SHT_STRTAB)
+ {
+ char * aSectionName = aShStrTab + aShdr[i].sh_name;
+ if (!strcmp(aSectionName, ".strtab"))
+ {
+ aStrTab = ELF_ENTRY_PTR(char, iElfHeader, aShdr[i].sh_offset);
+ if (aSymTab) break;
+ }
+ }
+ }
+
+ /*if(aHashTbl && aSymTab && aStrTab)
+ {
+ PLULONG aHashVal = Util::elf_hash((const PLUCHAR*)aName);
+ Elf32_Sword* aBuckets = ELF_ENTRY_PTR(Elf32_Sword, aHashTbl, sizeof(Elf32_HashTable) );
+ Elf32_Sword* aChains = ELF_ENTRY_PTR(Elf32_Sword, aBuckets, sizeof(Elf32_Sword)*(aHashTbl->nBuckets) );
+
+ PLUINT32 aIdx = aHashVal % aHashTbl->nBuckets;
+ aIdx = aBuckets[aIdx];
+
+ char *aSymName;
+ do {
+ aSymName = ELF_ENTRY_PTR(char, aStrTab, aSymTab[aIdx].st_name);
+ if( !strcmp(aSymName, aName) ) {
+ return &aSymTab[aIdx];
+ }
+ aIdx = aChains[aIdx];
+ }while( aIdx > 0 );
+
+ return NULL;
+ }
+ else */
+
+ if (aSymTab && aStrTab)
+ {
+ for(; aSymTab < aLim; aSymTab++)
+ {
+ if (!aSymTab->st_name) continue;
+ char * aSymName = aStrTab + aSymTab->st_name;
+ if (!strcmp(aSymName, aName))
+ return aSymTab;
+ }
+ return 0;
+ }
+ else
+ {
+ throw ELFFileError(NOSTATICSYMBOLSERROR, (char*)iParameterListInterface->ElfInput());
+ }
+ }
+ else
+ {
+ throw ELFFileError(NOSTATICSYMBOLSERROR, (char*)iParameterListInterface->ElfInput());
+ }
+}
+
+/**
+Function to get imports
+@return imports
+@internalComponent
+@released
+*/
+ElfImports::ImportMap ElfExecutable::GetImports() {
+ return iImports.GetImports();
+}
+
+/**
+Function to get exports
+@return exports
+@internalComponent
+@released
+*/
+ElfExports* ElfExecutable::GetExports() {
+ return iExports;
+}
+
+/**
+Function to get fixup location
+@param aReloc - Instance of class ElfLocalRelocation
+@param aPlace -
+@return addres of position for relocation
+@internalComponent
+@released
+*/
+Elf32_Word* ElfExecutable::GetFixupLocation(ElfLocalRelocation* aReloc, Elf32_Addr aPlace)
+{
+ Elf32_Phdr * aPhdr = aReloc->ExportTableReloc() ?
+ iCodeSegmentHdr :
+ Segment(aPlace);
+ Elf32_Word offset = aPhdr->p_offset + aPlace - aPhdr->p_vaddr;
+ return ELF_ENTRY_PTR(Elf32_Word, iElfHeader, offset);
+}
+
+/**
+Function to get the segment type
+@param aSym - Symbol
+@return Segment type
+@internalComponent
+@released
+*/
+ESegmentType ElfExecutable::Segment(Elf32_Sym *aSym)
+{
+ Elf32_Phdr * aHdr;
+
+ try {
+
+ bool limitSymbolFound = false;
+
+ // If Symbol is absolute then assume it came from linker and is a
+ // limit symbol.
+ if (aSym->st_shndx == SHN_ABS)
+ {
+ aHdr = SegmentFromAbs(aSym->st_value);
+ }
+ else
+ {
+ if( (iCodeSegmentHdr && aSym->st_value == (iCodeSegmentHdr->p_vaddr + iCodeSegmentHdr->p_memsz)) ||
+ (iDataSegmentHdr && aSym->st_value == (iDataSegmentHdr->p_vaddr + iDataSegmentHdr->p_memsz)) )
+ {
+ //If Symbol is a $$Limit symbol, then consider the open boundary.
+ String limitstr = iStringTable + aSym->st_name;
+ if (limitstr.rfind("$$Limit",limitstr.length()) != String::npos)
+ {
+ aHdr = SegmentFromAbs(aSym->st_value);
+ limitSymbolFound = true;
+ }
+ }
+
+ if(!limitSymbolFound )
+ {
+ aHdr = Segment(aSym->st_value);
+ }
+
+ }
+
+ if (aHdr == iCodeSegmentHdr)
+ {
+ return ESegmentRO;
+ }
+ else if (aHdr == iDataSegmentHdr)
+ {
+ return ESegmentRW;
+ }
+ }
+ catch(...)
+ {
+ }
+ return ESegmentUndefined;
+}
+