--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/toolsandutils/e32tools/elf2e32/source/pl_elfproducer.cpp Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,688 @@
+// 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 ElfProducer for the elf2e32 tool
+// @internalComponent
+// @released
+//
+//
+
+#include "pl_elfproducer.h"
+#include "pl_dllsymbol.h"
+#include <stdio.h>
+#include <string>
+#include "errorhandler.h"
+
+/**
+ * Following array is indexed on the SECTION_INDEX enum
+ */
+char* SECTION_NAME[] = {
+ "",
+ "ER_RO",
+ ".dynamic",
+ ".hash",
+ ".version_d",
+ ".version",
+ ".strtab",
+ ".dynsym",
+ ".shstrtab"
+};
+
+
+/**
+Constructor for class ElfProducer
+@param aParameterListInterface - instance of class ParameterListInterface
+@internalComponent
+@released
+*/
+ElfProducer::ElfProducer(ParameterListInterface *aParameterListInterface): ElfExecutable(aParameterListInterface) , \
+ iDSONameOffset(0),\
+ iLinkAsOffset(0),\
+ iSymbolsList(NULL),
+ iDSODaux(NULL), \
+ iDSOBuckets(NULL), \
+ iDSOChains(NULL),\
+ iCodeSectionData(NULL),\
+ iElfFileOffset(0)
+{
+}
+
+
+
+/**
+Destructor for class ElfProducer to release allocated memory
+@internalComponent
+@released
+*/
+ElfProducer::~ElfProducer(){
+ Cleanup();
+}
+
+
+/**
+This function sets the export Symbol list
+@internalComponent
+@released
+@param aSymbolList The export Symbol list.
+*/
+void ElfProducer::SetSymbolList(SymbolList& aSymbolList){
+ iSymbolsList = &aSymbolList;
+ if (iSymbolsList)
+ {
+ SymbolList::iterator aPos, aEnd;
+ aPos = iSymbolsList->begin();
+ aEnd = iSymbolsList->end();
+ char *aAbsentSymbol = "_._.absent_export_";
+ int length = strlen(aAbsentSymbol);
+ while(aPos != aEnd)
+ {
+ /* If a symbol is marked as Absent in the DEF file, replace the
+ * symbol name with "_._.absent_export_<Ordinal Number>"
+ */
+ if((*aPos)->Absent())
+ {
+ int aOrdinalNo = (*aPos)->OrdNum();
+ // Ordinal Number can be upto 0xffff which is 6 digits
+ char * aSymName = new char[length+7];
+ sprintf(aSymName, "_._.absent_export_%d", aOrdinalNo);
+ (*aPos)->SetSymbolName(aSymName);
+ delete[] aSymName;
+ }
+ aPos++;
+ }
+ }
+ iNSymbols = iSymbolsList->size() + 1;
+}
+
+/**
+This function takes the file names and generates the proxy dso library.
+@internalComponent
+@released
+@param aDsoFullName The full path and proxy-dso file name
+@param aDsoFileName The proxy-dso file name
+@param aLinkAs The DLL that defines the export Symbols
+*/
+void ElfProducer::WriteElfFile(char* aDsoFullName, char* aDsoFileName , char* aLinkAs){
+
+ //This includes the full path followed by the file name
+ iDsoFullName = aDsoFullName;
+
+ iDSOName = aDsoFileName;
+ iLinkAs = aLinkAs;
+
+ InitElfContents();
+
+ WriteElfContents();
+}
+
+/**
+This function initializes the Elf members
+@internalComponent
+@released
+*/
+void ElfProducer::InitElfContents() {
+
+ iElfHeader = new Elf32_Ehdr;
+ iSections = new Elf32_Shdr[MAX_SECTIONS+1];
+
+ iElfDynSym = new Elf32_Sym[iNSymbols];
+ iVersionTbl = new Elf32_Half[iNSymbols];
+ iVersionDef = new Elf32_Verdef[2];
+ iDSODaux = new Elf32_Verdaux[2];
+
+ iProgHeader = new Elf32_Phdr[2];
+ iCodeSectionData = new PLUINT32[iNSymbols];
+
+ iHashTbl = new Elf32_HashTable;
+
+ //premeditated
+ iHashTbl->nBuckets = (iNSymbols /3) + (iNSymbols % 0x3);
+
+ iHashTbl->nChains = iNSymbols;
+
+ iDSOBuckets = new Elf32_Sword[iHashTbl->nBuckets];
+ iDSOChains = new Elf32_Sword[iHashTbl->nChains];
+
+ Elf32_Sword aNullPtr = 0;
+
+ memset(iDSOBuckets, aNullPtr, sizeof(Elf32_Sword)*iHashTbl->nBuckets);
+ memset(iDSOChains, aNullPtr, sizeof(Elf32_Sword)*iHashTbl->nChains);
+ memset(iCodeSectionData, 0, sizeof(PLUINT32)*iNSymbols);
+
+ CreateElfHeader();
+
+ SymbolList::iterator aItr = iSymbolsList->begin();
+ SymbolList::iterator aEnd = iSymbolsList->end();
+ Symbol *aSym;
+ PLUINT32 aIdx = 1;
+
+ memset( &iElfDynSym[0], 0, sizeof(Elf32_Sym));
+ iDSOSymNameStrTbl.insert(iDSOSymNameStrTbl.end(), 0);
+
+ while(aItr != aEnd) {
+ String aSymName("");
+ aSym = *aItr;
+ aSymName = aSym->SymbolName();
+ //set symbol info..
+ iElfDynSym[aIdx].st_name = iDSOSymNameStrTbl.size();
+
+ iDSOSymNameStrTbl.insert(iDSOSymNameStrTbl.end(), aSymName.begin(), aSymName.end() );
+ iDSOSymNameStrTbl.insert(iDSOSymNameStrTbl.end(), 0);
+
+ SetSymolFields( aSym, &iElfDynSym[aIdx], aIdx);
+
+ //set version table info...
+ iVersionTbl[aIdx] = DEFAULT_VERSION;
+ AddToHashTable(aSym->SymbolName(), aIdx);
+ aItr++;aIdx++;
+ }
+
+ CreateVersionTable();
+
+ //Fill section headers...
+ CreateSections();
+
+ //Copy dyn entries..
+ CreateDynamicEntries();
+
+ //create code section data - this has the ordinal numbers...
+ CreateProgHeader();
+}
+
+/**
+This function creates the version definition table
+@internalComponent
+@released
+*/
+void ElfProducer::CreateVersionTable()
+{
+ //Fill verdef table...
+ iVersionDef[0].vd_ndx = 1;
+ iVersionDef[0].vd_cnt = 1;
+ iVersionDef[0].vd_flags = 1;
+ iVersionDef[0].vd_hash = Util::elf_hash((const PLUCHAR*) iDSOName.c_str());
+ iVersionDef[0].vd_version = 1;
+
+ iVersionDef[0].vd_aux = sizeof(Elf32_Verdef);
+ iVersionDef[0].vd_next = sizeof(Elf32_Verdef) + sizeof(Elf32_Verdaux);
+
+ iDSONameOffset = iDSOSymNameStrTbl.size();
+
+ iDSOSymNameStrTbl.insert(iDSOSymNameStrTbl.end(),iDSOName.begin(), iDSOName.end());
+ iDSOSymNameStrTbl.insert(iDSOSymNameStrTbl.end(), 0);
+
+ iDSODaux[0].vda_name = iDSONameOffset;
+ iDSODaux[0].vda_next = 0;
+
+ iVersionDef[1].vd_ndx = DEFAULT_VERSION;
+ iVersionDef[1].vd_cnt = 1;
+ iVersionDef[1].vd_flags = 0;
+ iVersionDef[1].vd_hash = Util::elf_hash((const PLUCHAR*)iLinkAs.c_str());
+ iVersionDef[1].vd_version = 1;
+
+ iVersionDef[1].vd_aux = sizeof(Elf32_Verdef);
+ iVersionDef[1].vd_next = 0;
+
+ iLinkAsOffset = iDSOSymNameStrTbl.size();
+ iDSOSymNameStrTbl.insert(iDSOSymNameStrTbl.end(),iLinkAs.begin(), iLinkAs.end());
+ iDSOSymNameStrTbl.insert(iDSOSymNameStrTbl.end(), 0);
+
+ iDSODaux[1].vda_name = iLinkAsOffset;
+ iDSODaux[1].vda_next = 0;
+
+}
+
+/**
+This function sets the Elf Symbol fields
+@internalComponent
+@released
+@param aSym The Symbol representation
+@param aElfSym The Elf Symbol
+@param aCodeIndex The index at which this Symbol refers to in the code section where, we have the ordinal number
+*/
+void ElfProducer::SetSymolFields(Symbol *aSym, Elf32_Sym* aElfSym, PLUINT32 aCodeIndex) {
+
+ aElfSym->st_other = STV_DEFAULT;
+
+ aElfSym->st_info = (PLUCHAR) (ELF32_ST_INFO(STB_GLOBAL, aSym->CodeDataType()));
+ aElfSym->st_value = (aCodeIndex - 1)*sizeof(Elf32_Word);
+
+ if(aSym->CodeDataType() == SymbolTypeCode){
+ aElfSym->st_size = sizeof(Elf32_Word);
+ }else{
+ aElfSym->st_size = aSym->SymbolSize();
+ }
+ aElfSym->st_shndx = CODE_SECTION;
+}
+
+/**
+This function adds an entry into the hash table based on the symbol name.
+@internalComponent
+@released
+@param aSymName The Symbol name
+@param aIndex The Symbol index in the Symbol table
+*/
+void ElfProducer::AddToHashTable(const char* aSymName, PLUINT32 aIndex)
+{
+ Elf32_Sword aNullPtr = 0;
+
+ PLULONG aHash = Util::elf_hash((PLUCHAR*)aSymName);
+ PLUINT32 aBIdx = aHash % iHashTbl->nBuckets;
+
+ if(iDSOBuckets[aBIdx] == aNullPtr)
+ {
+ iDSOBuckets[aBIdx] = aIndex;
+ }
+ else
+ {
+ PLUINT32 aCIdx = iDSOBuckets[aBIdx];
+
+ while(iDSOChains[aCIdx] != aNullPtr){
+
+ /* If the entry is already added into the hash table*/
+ if((PLUINT32)iDSOChains[aCIdx] == aIndex) {
+ return;
+ }
+ aCIdx = iDSOChains[aCIdx];
+ }
+ iDSOChains[aCIdx] = aIndex;
+ }
+}
+
+/**
+This function creates the different sections of the Elf file
+@internalComponent
+@released
+*/
+void ElfProducer::CreateSections() {
+ PLUINT32 aIdx = 0;
+
+ //clear the first section...
+ memset(&iSections[0], 0, sizeof(Elf32_Shdr));
+ iDSOSectionNames.insert(iDSOSectionNames.begin(), 0);
+
+ // Set the ELF file offset.
+ // This indicates the start of sections.
+ iElfFileOffset = sizeof(Elf32_Ehdr);
+
+ iElfFileOffset += (sizeof(Elf32_Shdr) * iElfHeader->e_shnum);
+
+ //Check if the string table is 4-byte aligned..
+ AlignString(iDSOSymNameStrTbl);
+
+ for(aIdx = 1; aIdx <= MAX_SECTIONS; aIdx++) {
+ switch(aIdx)
+ {
+ case SYMBOL_SECTION:
+ SetSectionFields(aIdx, SECTION_NAME[aIdx], SHT_DYNSYM, \
+ sizeof(Elf32_Sym), (iNSymbols * sizeof(Elf32_Sym)),\
+ STRING_SECTION, CODE_SECTION, 4, 0, 0);
+ break;
+ case STRING_SECTION:
+ SetSectionFields(aIdx, SECTION_NAME[aIdx], SHT_STRTAB, \
+ 1, iDSOSymNameStrTbl.size(), 0, \
+ 0, 0, 0,0);
+ break;
+ case VERSION_SECTION:
+ SetSectionFields(aIdx, SECTION_NAME[aIdx], 0x6fffffff, \
+ sizeof(Elf32_Half), (iNSymbols * sizeof(Elf32_Half)), SYMBOL_SECTION, \
+ 0, 2, 0, 0);
+ break;
+ case VER_DEF_SECTION:
+ SetSectionFields(aIdx, SECTION_NAME[aIdx],0x6ffffffd, \
+ sizeof(Elf32_Verdaux), (2*(sizeof(Elf32_Verdef) + sizeof(Elf32_Verdaux))),\
+ STRING_SECTION, DYNAMIC_SECTION, 4, 0, 0);
+ break;
+ case HASH_TBL_SECTION:
+ {
+ PLUINT32 aSize = sizeof(Elf32_HashTable) + \
+ (sizeof(Elf32_Sword) * (iHashTbl->nBuckets + iHashTbl->nChains));
+
+ SetSectionFields(aIdx, SECTION_NAME[aIdx], SHT_HASH, \
+ 0, aSize, SYMBOL_SECTION, 0, 4, 0, 0);
+ }
+ break;
+ case DYNAMIC_SECTION:
+ SetSectionFields(aIdx, SECTION_NAME[aIdx], SHT_DYNAMIC, \
+ sizeof(Elf32_Dyn), ((MAX_DYN_ENTS + 1) *sizeof(Elf32_Dyn)),\
+ STRING_SECTION, 0, 4, 0,0);
+ break;
+ case CODE_SECTION:
+ SetSectionFields(aIdx, SECTION_NAME[aIdx], SHT_PROGBITS, \
+ 0, (iNSymbols *sizeof(PLUINT32)),\
+ 0, 0, 4, (SHF_ALLOC | SHF_EXECINSTR),0);
+ break;
+ case SH_STR_SECTION:
+ {
+ PLUINT32 aSize = iDSOSectionNames.size() + strlen(SECTION_NAME[aIdx]);
+ SetSectionFields(aIdx, SECTION_NAME[aIdx], SHT_STRTAB, \
+ 1, aSize, 0, \
+ 0, 0, 0, 0);
+ //Check if the string table is 4-byte aligned..
+ AlignString(iDSOSectionNames);
+ iSections[aIdx].sh_size = iDSOSectionNames.size();
+
+ }
+ break;
+ default:
+ break;
+ }
+ iSections[aIdx].sh_offset = iElfFileOffset;
+ iElfFileOffset += iSections[aIdx].sh_size;
+
+ if(iElfFileOffset %4) {
+ iElfFileOffset += (4 - (iElfFileOffset %4));
+ }
+ }
+}
+
+/**
+This function sets the section header fields.
+@internalComponent
+@released
+@return Error status
+@param aSectionIndex The index of the section
+@param aSectionName The name of the section
+@param aType The type of the section
+@param aEntSz The size of each entry of the section
+@param aSectionSize The size of the section
+@param aLink The section this section is linked to
+@param aInfo Extra information. Depends on the section type of this section.
+@param aAddrAlign The address alignment of this section.
+@param aFlags Section flags
+@param aAddr The address of this section in memory(Here it remains 0)
+*/
+void ElfProducer::SetSectionFields(PLUINT32 aSectionIndex, char* aSectionName, PLUINT32 aType, \
+ PLUINT32 aEntSz, PLUINT32 aSectionSize, PLUINT32 aLink, \
+ PLUINT32 aInfo, PLUINT32 aAddrAlign, PLUINT32 aFlags, \
+ PLUINT32 aAddr)
+{
+ String aSecName = aSectionName;
+
+ iSections[aSectionIndex].sh_name = iDSOSectionNames.size();
+ iDSOSectionNames.insert(iDSOSectionNames.end(), aSecName.begin(), aSecName.end());
+ iDSOSectionNames.insert(iDSOSectionNames.end(), 0);
+
+ iSections[aSectionIndex].sh_type = aType;
+ iSections[aSectionIndex].sh_entsize = aEntSz;
+ iSections[aSectionIndex].sh_size = aSectionSize;
+ iSections[aSectionIndex].sh_link = aLink;
+ iSections[aSectionIndex].sh_flags = aFlags;
+ iSections[aSectionIndex].sh_addralign = aAddrAlign;
+ iSections[aSectionIndex].sh_info = aInfo;
+ iSections[aSectionIndex].sh_addr = aAddr;
+}
+
+/**
+This function cleans up the memory allocated to the Elf fields.
+@internalComponent
+@released
+*/
+void ElfProducer::Cleanup()
+{
+ DELETE_PTR(iElfHeader);
+ DELETE_PTR_ARRAY(iSections);
+ DELETE_PTR_ARRAY(iElfDynSym);
+ DELETE_PTR_ARRAY(iVersionTbl);
+ DELETE_PTR_ARRAY(iVersionDef);
+ DELETE_PTR_ARRAY(iDSODaux);
+
+ DELETE_PTR_ARRAY(iProgHeader);
+ DELETE_PTR_ARRAY(iCodeSectionData);
+ DELETE_PTR_ARRAY(iHashTbl);
+ DELETE_PTR_ARRAY(iDSOBuckets);
+ DELETE_PTR_ARRAY(iDSOChains);
+}
+
+/**
+This function creates the dynamic sections.
+@internalComponent
+@released
+*/
+void ElfProducer::CreateDynamicEntries()
+{
+ for(PLUINT32 aIdx = 0; aIdx <= MAX_DYN_ENTS; aIdx++ ) {
+ switch(aIdx) {
+ case DSO_DT_DSONAME:
+ iDSODynTbl[aIdx].d_tag = DT_SONAME;
+ iDSODynTbl[aIdx].d_val = iDSONameOffset;
+ break;
+ case DSO_DT_SYMTAB:
+ iDSODynTbl[aIdx].d_tag = DT_SYMTAB;
+ iDSODynTbl[aIdx].d_val = iSections[SYMBOL_SECTION].sh_offset;
+ break;
+ case DSO_DT_SYMENT:
+ iDSODynTbl[aIdx].d_tag = DT_SYMENT;
+ iDSODynTbl[aIdx].d_val = iSections[SYMBOL_SECTION].sh_entsize;
+ break;
+ case DSO_DT_STRTAB:
+ iDSODynTbl[aIdx].d_tag = DT_STRTAB;
+ iDSODynTbl[aIdx].d_val = iSections[STRING_SECTION].sh_offset;
+ break;
+ case DSO_DT_STRSZ:
+ iDSODynTbl[aIdx].d_tag = DT_STRSZ;
+ iDSODynTbl[aIdx].d_val = iDSOSymNameStrTbl.size();
+ break;
+ case DSO_DT_VERSYM:
+ iDSODynTbl[aIdx].d_tag = DT_VERSYM;
+ iDSODynTbl[aIdx].d_val = iSections[VERSION_SECTION].sh_offset;
+ break;
+ case DSO_DT_VERDEF:
+ iDSODynTbl[aIdx].d_tag = DT_VERDEF;
+ iDSODynTbl[aIdx].d_val = iSections[VER_DEF_SECTION].sh_offset;
+ break;
+ case DSO_DT_VERDEFNUM:
+ iDSODynTbl[aIdx].d_tag = DT_VERDEFNUM;
+ iDSODynTbl[aIdx].d_val = 2;
+ break;
+ case DSO_DT_HASH:
+ iDSODynTbl[aIdx].d_tag = DT_HASH;
+ iDSODynTbl[aIdx].d_val = iSections[HASH_TBL_SECTION].sh_offset;
+ break;
+ case DSO_DT_NULL:
+ iDSODynTbl[aIdx].d_tag = DT_NULL;
+ iDSODynTbl[aIdx].d_val = 0;
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+/**
+This function creates the Elf header.
+@internalComponent
+@released
+*/
+void ElfProducer::CreateElfHeader()
+{
+ //create ELF header
+ unsigned char c[EI_NIDENT] = {0x7f, 'E', 'L', 'F', \
+ ELFCLASS32, ELFDATA2LSB, 1, 0, \
+ 0, 0, 0, 0, \
+ 0, 0, 0, 0}; // e_ident
+
+ for (PLUINT32 i=0; i <EI_NIDENT;i++)
+ iElfHeader->e_ident[i] = c[i];
+
+ iElfHeader->e_type = ET_DYN;
+ iElfHeader->e_machine = EM_ARM;
+ iElfHeader->e_version = EV_CURRENT;
+ iElfHeader->e_entry = 0;
+ iElfHeader->e_shoff = sizeof(Elf32_Ehdr);
+ iElfHeader->e_flags = EF_ARM_BPABI_VERSION | EF_ARM_SYMSARESORTED;
+ iElfHeader->e_ehsize = sizeof(Elf32_Ehdr);
+ iElfHeader->e_phentsize = sizeof(Elf32_Phdr);
+ iElfHeader->e_shentsize = sizeof(Elf32_Shdr);
+ iElfHeader->e_shnum = MAX_SECTIONS + 1;
+ iElfHeader->e_shstrndx = SH_STR_SECTION;
+ iElfHeader->e_phnum = 2;
+}
+
+/**
+This function creates the program header
+@internalComponent
+@released
+*/
+void ElfProducer::CreateProgHeader()
+{
+ //Update the program header offset..
+ iElfHeader->e_phoff = iElfFileOffset;
+
+ // Update code section data..
+ SymbolList::iterator aItr = iSymbolsList->begin();
+ SymbolList::iterator end = iSymbolsList->end();
+
+ Symbol *aSym;
+ PLUINT32 aPos = 0;
+ while(aItr != end) {
+ aSym = *aItr;
+
+ iCodeSectionData[aPos] = aSym->OrdNum();
+ aItr++;aPos++;
+ }
+
+ //Create program header
+ iProgHeader[0].p_align = 4;
+ iProgHeader[0].p_offset = iSections[CODE_SECTION].sh_offset;
+ iProgHeader[0].p_type = PT_LOAD;
+ iProgHeader[0].p_flags = (PF_X | PF_ARM_ENTRY);
+ iProgHeader[0].p_filesz = iSections[CODE_SECTION].sh_size;
+ iProgHeader[0].p_paddr = 0;
+ iProgHeader[0].p_vaddr = 0;
+ iProgHeader[0].p_memsz = iSections[CODE_SECTION].sh_size;
+
+ iProgHeader[1].p_align = 4;
+ iProgHeader[1].p_offset = iSections[DYNAMIC_SECTION].sh_offset;
+ iProgHeader[1].p_type = PT_DYNAMIC;
+ iProgHeader[1].p_flags = (PF_R );
+ iProgHeader[1].p_filesz = iSections[DYNAMIC_SECTION].sh_size;
+ iProgHeader[1].p_paddr = 0;
+ iProgHeader[1].p_vaddr = 0;
+ iProgHeader[1].p_memsz = 0;
+
+}
+
+/**
+This function aligns the string table to a 4-byte boundary
+@internalComponent
+@released
+@return Error status
+@param aStr - string to be aligned
+*/
+void ElfProducer::AlignString(String& aStr) {
+
+ if( aStr.size() %4 ){
+ PLUCHAR aPad = (PLUCHAR)(4 - (aStr.size() %4));
+
+ while(aPad--) {
+ aStr.insert(aStr.end(), 0);
+ }
+ }
+}
+
+/**
+This function writes the Elf file contents.
+@internalComponent
+@released
+*/
+void ElfProducer::WriteElfContents()
+{
+ FILE *aElfFd;
+ PLUINT32 aIndex;
+
+ if((aElfFd = fopen(iDsoFullName.c_str(), "wb")) == NULL ) {
+ throw FileError(FILEOPENERROR, (char*)iDsoFullName.c_str());
+ }
+
+ // The ELF header..
+ fwrite(iElfHeader, 1, sizeof(Elf32_Ehdr), aElfFd);
+
+ //Section headers
+ for(aIndex = 0; aIndex <= MAX_SECTIONS; aIndex++) {
+ fwrite(&iSections[aIndex], 1, sizeof(Elf32_Shdr), aElfFd);
+ }
+
+
+ //Each section..
+
+ //code
+ for(aIndex = 0; aIndex < iNSymbols; aIndex++) {
+ fwrite(&iCodeSectionData[aIndex], 1, sizeof(PLUINT32), aElfFd );
+ }
+
+ //dyn table
+ for(aIndex = 0; aIndex <= MAX_DYN_ENTS; aIndex++) {
+ fwrite(&iDSODynTbl[aIndex], 1, sizeof(Elf32_Dyn), aElfFd);
+ }
+
+ //hash table
+ fwrite(&iHashTbl->nBuckets, 1, sizeof(Elf32_Word), aElfFd);
+ fwrite(&iHashTbl->nChains, 1, sizeof(Elf32_Word), aElfFd);
+
+ for(aIndex=0; aIndex < iHashTbl->nBuckets; aIndex++) {
+ fwrite(&iDSOBuckets[aIndex], 1, sizeof(Elf32_Sword), aElfFd);
+
+ }
+ for(aIndex=0; aIndex < iHashTbl->nChains; aIndex++) {
+ fwrite(&iDSOChains[aIndex], 1, sizeof(Elf32_Sword), aElfFd);
+
+ }
+
+ //version def table
+ for(aIndex = 0; aIndex < 2; aIndex++) {
+ fwrite(&iVersionDef[aIndex], 1, sizeof(Elf32_Verdef), aElfFd);
+ fwrite(&iDSODaux[aIndex], 1, sizeof(Elf32_Verdaux), aElfFd);
+ }
+
+ //version table
+ for(aIndex = 0; aIndex < iNSymbols; aIndex++) {
+ fwrite(&iVersionTbl[aIndex], 1, sizeof(Elf32_Half), aElfFd );
+ }
+
+ if( iSections[VERSION_SECTION].sh_size %4 ) {
+ PLUINT32 aNPads = 4 - (iSections[VERSION_SECTION].sh_size %4);
+ PLUCHAR aPad = '\0';
+ while(aNPads--) {
+ fwrite(&aPad, 1, 1, aElfFd);
+ }
+ }
+
+ //string table
+ PLUINT32 aSz = iDSOSymNameStrTbl.size();
+ char *aData = new char[aSz];
+ memcpy(aData, iDSOSymNameStrTbl.data(), aSz);
+ fwrite(aData, 1, aSz, aElfFd);
+
+ DELETE_PTR_ARRAY(aData);
+
+ //Sym table
+ for(aIndex = 0; aIndex < iNSymbols; aIndex ++) {
+ fwrite(&iElfDynSym[aIndex], 1, sizeof(Elf32_Sym), aElfFd);
+ }
+
+ //section header name table
+ aSz = iDSOSectionNames.size();
+ char *aData1 = new char[ aSz];
+ memcpy(aData1, iDSOSectionNames.data(), aSz);
+ fwrite(aData1, 1, aSz, aElfFd);
+ DELETE_PTR_ARRAY(aData1);
+
+ //program header
+ for(aIndex = 0; aIndex < 2; aIndex++) {
+ fwrite(&iProgHeader[aIndex], 1, sizeof(Elf32_Phdr), aElfFd );
+ }
+
+ fclose(aElfFd);
+}
+