emitElf-64.C

Go to the documentation of this file.

/*
 * See the dyninst/COPYRIGHT file for copyright information.
 * 
 * We provide the Paradyn Tools (below described as "Paradyn")
 * on an AS IS basis, and do not warrant its validity or performance.
 * We reserve the right to update, modify, or discontinue this
 * software at any time.  We shall have no obligation to supply such
 * updates or modifications or any other form of support to you.
 * 
 * By your use of Paradyn, you understand and agree that we (or any
 * other person or entity with proprietary rights in Paradyn) are
 * under no obligation to provide either maintenance services,
 * update services, notices of latent defects, or correction of
 * defects for Paradyn.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
  #if !defined(cap_libelf_so_0) && defined(os_linux)
  #define _FILE_OFFSET_BITS 64
  #endif
*/

#include <algorithm>
#include "Symtab.h"
#include "emitElf-64.h"
#include "emitElfStatic.h"
#include "debug.h"
#include "common/h/pathName.h"

#if defined(os_freebsd)
#include "common/h/freebsdKludges.h"
#endif

#if defined(os_linux)
#include "common/h/linuxKludges.h"
#endif

extern void symtab_log_perror(const char *msg);
using namespace Dyninst;
using namespace Dyninst::SymtabAPI;
using namespace std;

extern const char *pdelf_get_shnames(Elf_X *elf);
extern const char *STRTAB_NAME;
extern const char *SYMTAB_NAME;
extern const char *INTERP_NAME;
extern unsigned int elfHash(const char *name);

unsigned long bgq_sh_flags = SHF_EXECINSTR | SHF_ALLOC | SHF_WRITE;;
bool isBlueGeneQ = false;
bool isStaticBinary = false;

// Error reporting
extern void setSymtabError(SymtabError new_err);
extern void symtab_log_perror(const char *msg);

struct sortByIndex
{
  bool operator ()(Symbol * lhs, Symbol* rhs) {
    return lhs->getIndex() < rhs->getIndex();
  }
};

static bool libelfso0Flag;
static bool libelfso1Flag;
static int libelfso1version_major;
static int libelfso1version_minor;

static void setVersion(){
  libelfso0Flag = false;
  libelfso1Flag = false;
  libelfso1version_major = 0;
  libelfso1version_minor = 0;
#if defined(os_linux) || defined(os_freebsd)
  unsigned nEntries;
  map_entries *maps = getVMMaps(getpid(), nEntries);
  for (unsigned i=0; i< nEntries; i++){
     if (!strstr(maps[i].path, "libelf"))
        continue;
     std::string real_file = resolve_file_path(maps[i].path);
     const char *libelf_start = strstr(real_file.c_str(), "libelf");
     int num_read, major, minor;
     num_read = sscanf(libelf_start, "libelf-%d.%d.so", &major, &minor);
     if (num_read == 2) {
        libelfso1Flag = true;
        libelfso1version_major = major;
        libelfso1version_minor = minor;        
     }
     else {
        libelfso0Flag = true;
     }
  }
  if (libelfso0Flag && libelfso1Flag) {
     fprintf(stderr, "WARNING: SymtabAPI is linked with libelf.so.0 and "
             "libelf.so.1!  SymtabAPI likely going to be unable to read "
             "and write elf files!\n");
  }

#if defined(os_freebsd)
  if( libelfso1Flag ) {
      fprintf(stderr, "WARNING: SymtabAPI on FreeBSD is known to function "
              "incorrectly when linked with libelf.so.1\n");
  }
#endif
#endif
}

bool emitElf64::hasPHdrSectionBug()
{
   if (movePHdrsFirst)
      return false;
   if (!libelfso1Flag)
      return false;
   return (libelfso1version_major == 0 && libelfso1version_minor <= 137);
}

bool emitElf64::cannotRelocatePhdrs()
{
#if defined(bug_phdrs_first_page)
    return true;
#else
    return false;
#endif
}

static int elfSymType(Symbol *sym)
{
  switch (sym->getType()) {
  case Symbol::ST_MODULE: return STT_FILE;
  case Symbol::ST_SECTION: return STT_SECTION;
  case Symbol::ST_OBJECT: return STT_OBJECT;
  case Symbol::ST_FUNCTION: return STT_FUNC;
  case Symbol::ST_TLS: return STT_TLS;
  case Symbol::ST_NOTYPE : return STT_NOTYPE;
  case Symbol::ST_UNKNOWN: return sym->getInternalType();
     case Symbol::ST_INDIRECT: return STT_GNU_IFUNC;

  default: return STT_SECTION;
  }
}

static int elfSymBind(Symbol::SymbolLinkage sLinkage)
{
  switch (sLinkage) {
  case Symbol::SL_LOCAL: return STB_LOCAL;
  case Symbol::SL_WEAK: return STB_WEAK;
  case Symbol::SL_GLOBAL: return STB_GLOBAL;
  default: return STB_LOPROC;
  }
}

static int elfSymVisibility(Symbol::SymbolVisibility sVisibility)
{
  switch (sVisibility) {
  case Symbol::SV_DEFAULT: return STV_DEFAULT;
  case Symbol::SV_INTERNAL: return STV_INTERNAL;
  case Symbol::SV_HIDDEN: return STV_HIDDEN;
  case Symbol::SV_PROTECTED: return STV_PROTECTED;
  default: return STV_DEFAULT;
  }
}

emitElf64::emitElf64(Elf_X *oldElfHandle_, bool isStripped_, Object *obj_, void (*err_func)(const char *)) :
   oldElfHandle(oldElfHandle_),
   phdrs_scn(NULL),
   isStripped(isStripped_),
   object(obj_),
   err_func_(err_func)
{
  firstNewLoadSec = NULL;
  textData = NULL;
  symStrData = NULL;
  symTabData = NULL;
  dynsymData = NULL;
  dynStrData = NULL;
  hashData = NULL;
  rodata = NULL;
 
  linkedStaticData = NULL;
  hasRewrittenTLS = false;
  TLSExists = false;
  newTLSData = NULL;
   
  oldElf = oldElfHandle->e_elfp();
  curVersionNum = 2;
  setVersion();
 
  //Set variable based on the mechanism to add new load segment
  // 1) createNewPhdr (Total program headers + 1) - default
  //    (a) movePHdrsFirst
  //    (b) create new section called dynphdrs and change pointers (createNewPhdrRegion)
  //    (c) library_adjust - create room for a new program header in a position-indepdent library 
  //                         by increasing all virtual addresses for the library
  // 2) Use existing Phdr (used in bleugene - will be handled in function fixPhdrs)
  //    (a) replaceNOTE section - if NOTE exists
  //    (b) BSSExpandFlag - expand BSS section - default option

  // default
  createNewPhdr = true; BSSExpandFlag = false; replaceNOTE = false; 

  //If we're dealing with a library that can be loaded anywhere,
  // then load the program headers into the later part of the binary,
  // this may trigger a kernel bug that was fixed in Summer 2007,
  // but is the only reliable way to modify these libraries.
  //If we're dealing with a library/executable that loads at a specific
  // address we'll put the phdrs into the page before that address.  This
  // works and will avoid the kernel bug.

  isBlueGeneQ = obj_->isBlueGeneQ();
  isStaticBinary = obj_->isStaticBinary();
  if(isBlueGeneQ){
    movePHdrsFirst = false;
  } else {
    movePHdrsFirst = createNewPhdr && object && object->getLoadAddress();
  }

  //If we want to try a mode where we add the program headers to a library
  // that can be loaded anywhere, and put the program headers in the first 
  // page (avoiding the kernel bug), then set library_adjust to getpagesize().
  // This will shift all addresses in the library down by a page, accounting
  // for the extra page for program headers.  This causes some significant
  // changes to the binary, and isn't well tested.
  library_adjust = 0;
  if( cannotRelocatePhdrs() && !movePHdrsFirst ) {
      movePHdrsFirst = true;
      library_adjust = getpagesize();
  }
}

bool emitElf64::createElfSymbol(Symbol *symbol, unsigned strIndex, vector<Elf64_Sym *> &symbols, bool dynSymFlag)
{
  Elf64_Sym *sym = new Elf64_Sym();
  sym->st_name = strIndex;

  // OPD-based systems
  if (symbol->getPtrOffset()) {
    sym->st_value = symbol->getPtrOffset() + library_adjust;
  }
  else if (symbol->getOffset()) {
       sym->st_value = symbol->getOffset() + library_adjust;
  }

  sym->st_size = symbol->getSize();
  sym->st_other = ELF64_ST_VISIBILITY(elfSymVisibility(symbol->getVisibility()));
  sym->st_info = (unsigned char) ELF64_ST_INFO(elfSymBind(symbol->getLinkage()), elfSymType(symbol));

  if (symbol->getRegion())
    {
#if defined(os_freebsd)
      sym->st_shndx = (Elf64_Half) symbol->getRegion()->getRegionNumber();
#else
      sym->st_shndx = (Elf64_Section) symbol->getRegion()->getRegionNumber();
#endif
    }
  else if (symbol->isAbsolute())
    {
      sym->st_shndx = SHN_ABS;
    }
  else
    {
      sym->st_shndx = 0;
    }

  symbols.push_back(sym);

  if (dynSymFlag) 
    {
      //printf("dynamic symbol: %s\n", symbol->getMangledName().c_str());

      char msg[2048];
      char *mpos = msg;
      msg[0] = '\0';
      string fileName;

      if (!symbol->getVersionFileName(fileName))
    {
      //verdef entry
      vector<string> *vers;
      if (!symbol->getVersions(vers))
        {
          if (symbol->getLinkage() == Symbol::SL_GLOBAL)
        {
          versionSymTable.push_back(1);

        }
          else
        {
          versionSymTable.push_back(0);
          mpos += sprintf(mpos, "  local\n");
        }
        }
      else 
        {
          if (vers->size() > 0)
        {
          // new verdef entry
          mpos += sprintf(mpos, "verdef: symbol=%s  version=%s ", symbol->getMangledName().c_str(), (*vers)[0].c_str());
          if (verdefEntries.find((*vers)[0]) != verdefEntries.end())
            {
              unsigned short index = verdefEntries[(*vers)[0]];
              if (symbol->getVersionHidden()) index += 0x8000;
              versionSymTable.push_back(index);
            }
          else 
            {
              unsigned short index = curVersionNum;
              if (symbol->getVersionHidden()) index += 0x8000;
              versionSymTable.push_back(index);

              verdefEntries[(*vers)[0]] = curVersionNum;
              curVersionNum++;
            }
        }
          // add all versions to the verdef entry
          for (unsigned i=0; i< vers->size(); i++)
        {
          mpos += sprintf(mpos, "  {%s}", (*vers)[i].c_str());
          if (versionNames.find((*vers)[i]) == versionNames.end())
            {
              versionNames[(*vers)[i]] = 0;
            }

          if (find( verdauxEntries[verdefEntries[(*vers)[0]]].begin(),
                verdauxEntries[verdefEntries[(*vers)[0]]].end(),
                (*vers)[i]) == verdauxEntries[verdefEntries[(*vers)[0]]].end())
            {
              verdauxEntries[verdefEntries[(*vers)[0]]].push_back((*vers)[i]);
            }
        }
          mpos += sprintf(mpos, "\n");
        }
    }
      else 
    {           
      //verneed entry
      mpos += sprintf(mpos, "need: symbol=%s    filename=%s\n", 
              symbol->getMangledName().c_str(), fileName.c_str());

      vector<string> *vers;

      if (!symbol->getVersions(vers) || (vers && vers->size() != 1)) 
        {
          // add an unversioned dependency
          if (fileName != "") 
        {
          // If the file is not an executable, then add to unversioned entries
         if (!symbol->getReferringSymbol()->getSymtab()->isExec()) {
            if (find(unversionedNeededEntries.begin(),
                     unversionedNeededEntries.end(),
                     fileName) == unversionedNeededEntries.end()) 
                {
               mpos += sprintf(mpos, "  new unversioned: %s\n", fileName.c_str());
               unversionedNeededEntries.push_back(fileName);
                }
         }

          if (symbol->getLinkage() == Symbol::SL_GLOBAL) {
            mpos += sprintf(mpos, "  global (w/ filename)\n");
            versionSymTable.push_back(1);
          }
          else {

            versionSymTable.push_back(0);
          }
        }
        } 
      else 
        {
          if (!vers)
        {
          fprintf(stderr, "%s[%d]:  weird inconsistency here...  getVersions returned NULL\n",
              FILE__, __LINE__);
        }
          else
        {
          // There should only be one version string by this time
          //If the verison name already exists then add the same version number to the version symbol table
          //Else give a new number and add it to the mapping.
          if (versionNames.find((*vers)[0]) == versionNames.end()) 
            {
              mpos += sprintf(mpos, "  new version name: %s\n", (*vers)[0].c_str());
              versionNames[(*vers)[0]] = 0;
            }

          if (verneedEntries.find(fileName) != verneedEntries.end())
            {
              if (verneedEntries[fileName].find((*vers)[0]) != verneedEntries[fileName].end()) 
            {
              mpos += sprintf(mpos, "  vernum: %d\n", verneedEntries[fileName][(*vers)[0]]);
              versionSymTable.push_back((unsigned short) verneedEntries[fileName][(*vers)[0]]);
            }
              else
            {
              mpos += sprintf(mpos, "  new entry #%d: %s [%s]\n", 
                      curVersionNum, (*vers)[0].c_str(), fileName.c_str());
              versionSymTable.push_back((unsigned short) curVersionNum);
              verneedEntries[fileName][(*vers)[0]] = curVersionNum;
              curVersionNum++;
            }
            }
          else
            {
              mpos += sprintf(mpos, "  new entry #%d: %s [%s]\n", 
                      curVersionNum, (*vers)[0].c_str(), fileName.c_str());
              versionSymTable.push_back((unsigned short) curVersionNum);
              verneedEntries[fileName][(*vers)[0]] = curVersionNum;
              curVersionNum++;
            }
        } 
        }
    }
#ifdef BINEDIT_DEBUG
      printf("%s", msg);
#endif
    }

  return true;
}

// Find the end of data/text segment
void emitElf64::findSegmentEnds()
{
  Elf64_Phdr *tmp = elf64_getphdr(oldElf);
  // Find the offset of the start of the text & the data segment
  // The first LOAD segment is the text & the second LOAD segment 
  // is the data
  dataSegEnd = 0;
  for(unsigned i=0;i<oldEhdr->e_phnum;i++)
    {
      if(tmp->p_type == PT_LOAD)
        {
      if (dataSegEnd < tmp->p_vaddr+tmp->p_memsz)
        dataSegEnd = tmp->p_vaddr+tmp->p_memsz;
        }else if( PT_TLS == tmp->p_type ) {
            TLSExists = true;
        }
      tmp++;
    }
}

// Rename an old section. Lengths of old and new names must match.
// Only renames the FIRST matching section encountered.
void emitElf64::renameSection(const std::string &oldStr, const std::string &newStr, bool renameAll) {
  assert(oldStr.length() == newStr.length());
  for (unsigned k = 0; k < secNames.size(); k++) {
    if (secNames[k] == oldStr) {
      secNames[k].replace(0, oldStr.length(), newStr);
      if (!renameAll)
    break;
    }
  }
}

bool emitElf64::driver(Symtab *obj, string fName){
  int newfd;
  Region *foundSec = NULL;
  unsigned pgSize = getpagesize();
  rewrite_printf("::driver for emitElf64\n");

  string strtmpl = fName + "XXXXXX";
  char buf[strtmpl.length() + 1];
  strncpy(buf, strtmpl.c_str(), strtmpl.length()+1);

  newfd = mkstemp(buf);

  if (newfd == -1) {
    log_elferror(err_func_, "error opening file to write symbols");
    return false;
  }
  strtmpl = buf;

  fchmod(newfd, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP);
  rewrite_printf("Emitting to temporary file %s\n", buf);

#if 0
  //open ELF File for writing
  if((newfd = (open(fName.c_str(), O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP)))==-1){ 
    log_elferror(err_func_, "error opening file to write symbols");
    return false;
  }
#endif

  if((newElf = elf_begin(newfd, ELF_C_WRITE, NULL)) == NULL){
    log_elferror(err_func_, "NEWELF_BEGIN_FAIL");
    fflush(stdout);
    cerr << "Failed to elf_begin" << endl;
    return false;
  }

  //Section name index for all sections
  secNames.push_back("");
  secNameIndex = 1;
  //Section name index for new sections
  loadSecTotalSize = 0;
  unsigned NOBITStotalsize = 0;
  int dirtySecsChange = 0;
  unsigned extraAlignSize = 0;
    
  // ".shstrtab" section: string table for section header names
  const char *shnames = pdelf_get_shnames(oldElfHandle);
  if (shnames == NULL) {
    log_elferror(err_func_, ".shstrtab section");
    return false;
  } 

  // Write the Elf header first!
  newEhdr = elf64_newehdr(newElf);
  if(!newEhdr){
    log_elferror(err_func_, "newEhdr failed\n");
    return false;
  }
  oldEhdr = elf64_getehdr(oldElf);
  memcpy(newEhdr, oldEhdr, sizeof(Elf64_Ehdr));
    
  newEhdr->e_shnum += newSecs.size();

  // Find the end of text and data segments
  findSegmentEnds();
  unsigned insertPoint = oldEhdr->e_shnum;
  unsigned insertPointOffset = 0;
  unsigned NOBITSstartPoint = oldEhdr->e_shnum;

  if(movePHdrsFirst)
  {
     newEhdr->e_phoff = sizeof(Elf64_Ehdr);
  }
    
  /* flag the file for no auto-layout */
  elf_flagelf(newElf,ELF_C_SET,ELF_F_LAYOUT);
    
  Elf_Scn *scn = NULL, *newscn = NULL;
  Elf_Data *newdata = NULL, *olddata = NULL;
  Elf64_Shdr *newshdr = NULL, *shdr = NULL;
  dyn_hash_map<unsigned, unsigned> secLinkMapping;
  dyn_hash_map<unsigned, unsigned> secInfoMapping;
  dyn_hash_map<unsigned, unsigned> changeMapping;
  dyn_hash_map<std::string, unsigned> newNameIndexMapping;
  dyn_hash_map<unsigned, std::string> oldIndexNameMapping;

  bool createdLoadableSections = false;
  unsigned scncount;
  unsigned sectionNumber = 0;

  bool startMovingSections = false;
  for (scncount = 0; (scn = elf_nextscn(oldElf, scn)); scncount++) {
    //copy sections from oldElf to newElf
    shdr = elf64_getshdr(scn);

    // resolve section name
    const char *name = &shnames[shdr->sh_name];
    bool result = obj->findRegion(foundSec, shdr->sh_addr, shdr->sh_size);
    if (!result || foundSec->isDirty()) {
      result = obj->findRegion(foundSec, name);
    }

    // write the shstrtabsection at the end
    if(!strcmp(name, ".shstrtab"))
      continue;

    sectionNumber++;
    changeMapping[sectionNumber] = 0;
    oldIndexNameMapping[scncount+1] = string(name);
    newNameIndexMapping[string(name)] = sectionNumber;

    newscn = elf_newscn(newElf);
    newshdr = elf64_getshdr(newscn);
    newdata = elf_newdata(newscn);
    olddata = elf_getdata(scn,NULL);
    memcpy(newshdr, shdr, sizeof(Elf64_Shdr));
    memcpy(newdata,olddata, sizeof(Elf_Data));


    secNames.push_back(name);
    newshdr->sh_name = secNameIndex;
    secNameIndex += strlen(name) + 1;
    
    if (newshdr->sh_addr) {
       newshdr->sh_addr += library_adjust;
    }

    if(foundSec->isDirty())
    {
       newdata->d_buf = (char *)malloc(foundSec->getDiskSize());
       memcpy(newdata->d_buf, foundSec->getPtrToRawData(), foundSec->getDiskSize());
       newdata->d_size = foundSec->getDiskSize();
       newshdr->sh_size = foundSec->getDiskSize();
    }
    else if(olddata->d_buf)     //copy the data buffer from oldElf
    {
       newdata->d_buf = (char *)malloc(olddata->d_size);
       memcpy(newdata->d_buf, olddata->d_buf, olddata->d_size);
      }

    if (newshdr->sh_entsize && (newshdr->sh_size % newshdr->sh_entsize != 0))
    {
       newshdr->sh_entsize = 0x0;
    }

    if(BSSExpandFlag) {
      // Add the expanded SHT_NOBITS section size if the section comes after those sections 
      if(scncount > NOBITSstartPoint)
    newshdr->sh_offset += NOBITStotalsize;
    
      // Expand the NOBITS sections in file & and change the type from SHT_NOBITS to SHT_PROGBITS
      if(shdr->sh_type == SHT_NOBITS)
    {
      newshdr->sh_type = SHT_PROGBITS;
      newdata->d_buf = (char *)malloc(shdr->sh_size);
      memset(newdata->d_buf, '\0', shdr->sh_size);
      newdata->d_size = shdr->sh_size;
      if(NOBITSstartPoint == oldEhdr->e_shnum)
        NOBITSstartPoint = scncount;
      NOBITStotalsize += shdr->sh_size; 
    }
    }    
      
    std::vector <std::vector <unsigned long> > moveSecAddrRange = obj->getObject()->getMoveSecAddrRange();

    for (unsigned i = 0 ; i != moveSecAddrRange.size(); i++) {
      if ( (moveSecAddrRange[i][0] == shdr->sh_addr) ||
       (shdr->sh_addr >= moveSecAddrRange[i][0] && shdr->sh_addr < moveSecAddrRange[i][1]) )
    {
      newshdr->sh_type = SHT_PROGBITS;
      changeMapping[sectionNumber] = 1;
      string newName = ".o";
      newName.append(name, 2, strlen(name));
      renameSection((string)name, newName, false);
    }
    }

    if((obj->getObject()->getStrtabAddr() != 0 &&
       obj->getObject()->getStrtabAddr() == shdr->sh_addr) ||
       !strcmp(name, STRTAB_NAME))
      {
    symStrData = newdata;
    updateSymbols(symTabData, symStrData, loadSecTotalSize);
      }
        
    //Change sh_link for .symtab to point to .strtab
    if((obj->getObject()->getSymtabAddr() != 0 && 
       obj->getObject()->getSymtabAddr() == shdr->sh_addr) ||
       !strcmp(name, SYMTAB_NAME) ){
      newshdr->sh_link = secNames.size();
      changeMapping[sectionNumber] = 1;
      symTabData = newdata;
    }


    if(obj->getObject()->getTextAddr() != 0 &&
       obj->getObject()->getTextAddr() == shdr->sh_addr){
      textData = newdata;
    }

    if(obj->getObject()->getDynamicAddr() != 0 &&
       obj->getObject()->getDynamicAddr() == shdr->sh_addr){
      dynData = newdata;
      dynSegOff = newshdr->sh_offset;
      dynSegAddr = newshdr->sh_addr;
      // Change the data to update the relocation addr
      newshdr->sh_type = SHT_PROGBITS;
      changeMapping[sectionNumber] = 1;
      string newName = ".o";
      newName.append(name, 2, strlen(name));
      renameSection((string)name, newName, false);
    }

    // Only need to rewrite data section
    if( hasRewrittenTLS && foundSec->isTLS() 
        && foundSec->getRegionType() == Region::RT_DATA ) 
    {
        // Clear TLS flag
        newshdr->sh_flags &= ~SHF_TLS;

        string newName = ".o";
        newName.append(name, 2, strlen(name));
        renameSection((string)name, newName, false);
    }

#if defined(arch_power) && defined(arch_64bit)
    // DISABLED
    if (0 && isStaticBinary && strcmp(name, ".got") == 0) {
      string newName = ".o";
      newName.append(name, 2, strlen(name));
      renameSection((string) name, newName, false);
    }
#endif

    if (isStaticBinary && (strcmp(name, ".rela.plt") == 0)) {
       string newName = ".o";
       newName.append(name, 2, strlen(name));
       renameSection(name, newName, false);
    }

    if (isStaticBinary && (strcmp(name, ".rela.plt") == 0)) {
      string newName = ".o";
      newName.append(name, 2, strlen(name));
      renameSection(name, newName, false);
      // Clear the PLT type; use PROGBITS
      newshdr->sh_type = SHT_PROGBITS;
    }

    // Change offsets of sections based on the newly added sections
    if(movePHdrsFirst) {
        /* This special case is specific to FreeBSD but there is no hurt in
         * handling it on other platforms.
         *
         * This is necessary because the INTERP header must be located within in
         * the first page of the file -- if the section is moved to the next
         * page the object file will not be parsed correctly by the kernel.
         *
         * However, the initial sections still need to be shifted, but just
         * by the difference in size of the new PHDR segment. 
         */
        if( newshdr->sh_offset > 0 ) {
            if( startMovingSections || obj->isStaticBinary() 
                || obj->getObjectType() == obj_SharedLib ) newshdr->sh_offset += pgSize;
            else if( createNewPhdr ) newshdr->sh_offset += oldEhdr->e_phentsize;
        }
    }       

    if(scncount > insertPoint && newshdr->sh_offset >= insertPointOffset )
      newshdr->sh_offset += loadSecTotalSize;

    if (newshdr->sh_offset > 0 ) 
        newshdr->sh_offset += dirtySecsChange;

    if (BSSExpandFlag) {
        if( newshdr->sh_offset > 0 ) {
            newshdr->sh_offset += extraAlignSize;
        }
    }else if (newshdr->sh_offset >= insertPointOffset ) {
        newshdr->sh_offset += extraAlignSize;
    }

    if(foundSec->isDirty()) 
      dirtySecsChange += newshdr->sh_size - shdr->sh_size;

    if(BSSExpandFlag && newshdr->sh_addr) {
      unsigned newOff = newshdr->sh_offset - (newshdr->sh_offset & (pgSize-1)) + (newshdr->sh_addr & (pgSize-1));
      if(newOff < newshdr->sh_offset)
    newOff += pgSize;
      extraAlignSize += newOff - newshdr->sh_offset;
      newshdr->sh_offset = newOff;
    }
    
    secLinkMapping[sectionNumber] = shdr->sh_link; 
    secInfoMapping[sectionNumber] = shdr->sh_info; 

    rewrite_printf("section %s addr = %lx off = %lx size = %lx\n",
            name, newshdr->sh_addr, newshdr->sh_offset, newshdr->sh_size);

    //Insert new loadable sections at the end of data segment           
    if (shdr->sh_addr+shdr->sh_size == dataSegEnd && !createdLoadableSections) {
      createdLoadableSections = true;
      insertPoint = scncount;
      if( SHT_NOBITS == shdr->sh_type ) {
          insertPointOffset = shdr->sh_offset;
      }else{
          insertPointOffset = shdr->sh_offset + shdr->sh_size;
      }
      
      if(!createLoadableSections(obj,newshdr, extraAlignSize, 
                                 newNameIndexMapping, sectionNumber))        
         return false;
      if (createNewPhdr && !movePHdrsFirst) {
     sectionNumber++;
         createNewPhdrRegion(newNameIndexMapping);
    }

        // Update the heap symbols, now that loadSecTotalSize is set
        updateSymbols(dynsymData, dynStrData, loadSecTotalSize);

    }

    if ( 0 > elf_update(newElf, ELF_C_NULL))
    {
       fprintf(stderr, "%s[%d]:  elf_update failed: %d, %s\n", FILE__, __LINE__, elf_errno(), elf_errmsg(elf_errno()));
       return false;
    }

    if(!strcmp(name, INTERP_NAME)) {
        startMovingSections = true;
    }
  }

  // Add non-loadable sections at the end of object file
  if(!createNonLoadableSections(newshdr))
    return false;

  if ( 0 >  elf_update(newElf, ELF_C_NULL))
  {
     fprintf(stderr, "%s[%d]:  elf_update failed: %d, %s\n", FILE__, __LINE__, elf_errno(), elf_errmsg(elf_errno()));
     return false;
  }
   
  //Add the section header table right at the end        
  addSectionHeaderTable(newshdr);

  // Second iteration to fix the link fields to point to the correct section
  scn = NULL;

  for (scncount = 0; (scn = elf_nextscn(newElf, scn)); scncount++) {
    shdr = elf64_getshdr(scn);
    if (changeMapping[scncount+1] == 0 && secLinkMapping[scncount+1] != 0) {
      unsigned linkIndex = secLinkMapping[scncount+1];
      string secName = oldIndexNameMapping[linkIndex];
      unsigned newLinkIndex = newNameIndexMapping[secName];
      shdr->sh_link = newLinkIndex;
    } 

    if (changeMapping[scncount+1] == 0 && secInfoMapping[scncount+1] != 0) {
      // For REL and RELA section, info field is a section index - hence of the index changes, the info field must change.
      // For SYMTAB and DYNSYM, info field is OS specific - so just copy it.
      // For others, info field is 0, so just copy it
      if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) {
    unsigned infoIndex = secInfoMapping[scncount+1];
    string secName = oldIndexNameMapping[infoIndex];
    unsigned newInfoIndex = newNameIndexMapping[secName];
    shdr->sh_info = newInfoIndex;
      } 
    }
  }

  newEhdr->e_shstrndx = scncount;

  // Move the section header to the end
  newEhdr->e_shoff =shdr->sh_offset+shdr->sh_size;
  if (newEhdr->e_shoff % 8)
    newEhdr->e_shoff += 8 - (newEhdr->e_shoff % 8);

  //copy program headers
  oldPhdr = elf64_getphdr(oldElf);
  fixPhdrs(extraAlignSize);

  //Write the new Elf file
  if (elf_update(newElf, ELF_C_WRITE) < 0){
    int err;
    if ((err = elf_errno()) != 0)
      {
    const char *msg = elf_errmsg(err);
    /* print msg */
    fprintf(stderr, "Error: Unable to write ELF file: %s\n", msg);
      }
    log_elferror(err_func_, "elf_update failed");
    return false;
  }
  elf_end(newElf);
  if (hasPHdrSectionBug()) {
     unsigned long ehdr_off = (unsigned long) &(((Elf64_Ehdr *) 0x0)->e_phoff);
     lseek(newfd, ehdr_off, SEEK_SET);
     Elf64_Off offset = (Elf64_Off) phdr_offset;
     write(newfd, &offset, sizeof(Elf64_Off));
  }
  close(newfd);

  if (::rename(strtmpl.c_str(), fName.c_str())) {
     return false;
  }

  return true;
}

void emitElf64::createNewPhdrRegion(dyn_hash_map<std::string, unsigned> &newNameIndexMapping)
{
   assert(!movePHdrsFirst);

   unsigned phdr_size = oldEhdr->e_phnum*oldEhdr->e_phentsize;
   if (createNewPhdr)
      phdr_size += oldEhdr->e_phentsize;

   unsigned align = 0;
   if (currEndOffset % 8)
      align = 8 - (currEndOffset % 8);

   newEhdr->e_phoff = currEndOffset + align;
   phdr_offset = newEhdr->e_phoff;

   Address endaddr = currEndAddress;
   currEndAddress += phdr_size + align;
   currEndOffset += phdr_size + align;
   loadSecTotalSize += phdr_size + align;

   //libelf.so.1 is annoying.  It'll overwrite the data
   // between sections with 0's, even if we've stuck the
   // program headers in there.  Create a dummy section
   // to contain the program headers.
   phdrs_scn = elf_newscn(newElf);
   Elf64_Shdr *newshdr = elf64_getshdr(phdrs_scn);
   const char *newname = ".dynphdrs";

   secNames.push_back(newname);
   newNameIndexMapping[newname] = secNames.size() - 1;
   newshdr->sh_name = secNameIndex;
   secNameIndex += strlen(newname) + 1;
   newshdr->sh_flags = SHF_ALLOC;
    if (isBlueGeneQ) newshdr->sh_flags = bgq_sh_flags;
   newshdr->sh_type = SHT_PROGBITS;
   newshdr->sh_offset = newEhdr->e_phoff;
   newshdr->sh_addr = endaddr + align;
   newshdr->sh_size = phdr_size;
   newshdr->sh_link = SHN_UNDEF;
   newshdr->sh_info = 0;
   newshdr->sh_addralign = 4;
   newshdr->sh_entsize = newEhdr->e_phentsize;
    phdrSegOff = newshdr->sh_offset;
    phdrSegAddr = newshdr->sh_addr;
    
}

void emitElf64::fixPhdrs(unsigned &extraAlignSize)
{
  unsigned pgSize = getpagesize();
  Elf64_Phdr *old = oldPhdr;

  newEhdr->e_phnum = oldEhdr->e_phnum;
  newEhdr->e_phentsize = oldEhdr->e_phentsize;

  if(createNewPhdr) {
     newEhdr->e_phnum++;
     if( hasRewrittenTLS && !TLSExists ) newEhdr->e_phnum++;
  }

  bool added_new_sec = false;    
  bool replaced = false;

  if (!hasPHdrSectionBug())
     newPhdr = elf64_newphdr(newElf,newEhdr->e_phnum);
  else {
     newPhdr = (Elf64_Phdr *) malloc(sizeof(Elf64_Phdr) * newEhdr->e_phnum);
  }
  void *phdr_data = (void *) newPhdr;

  Elf64_Phdr newSeg;
  bool last_load_segment = false;
  for(unsigned i=0;i<oldEhdr->e_phnum;i++)
  {
    /*
     * If we've created a new loadable segment, we need to insert a new
     * program header amidst the other loadable segments.
     * 
     * ELF format says:
     *
     * `Loadable segment entries in the program header table appear in
     * ascending order, sorted on the p_vaddr member.'
     * 
     * Note: replacing NOTE with LOAD section for bluegene systems 
     * does not follow this rule.
     */

    Elf64_Phdr * insert_phdr = NULL;
   if(createNewPhdr && !added_new_sec && firstNewLoadSec) {
       if(i+1 == oldEhdr->e_phnum) {
            insert_phdr = newPhdr + 1;

        }
        else if(old->p_type == PT_LOAD && (old+1)->p_type != PT_LOAD) {
            // insert at end of loadable phdrs
            insert_phdr = newPhdr+1;
        last_load_segment = true;
        }
        else if(old->p_type != PT_LOAD &&
                (old+1)->p_type == PT_LOAD &&
                newSegmentStart < (old+1)->p_vaddr)
        {
            // insert at beginning of loadable list (after the
            // current phdr)
            insert_phdr = newPhdr+1;
        }
        else if(old->p_type == PT_LOAD &&
                (old+1)->p_type == PT_LOAD &&
                newSegmentStart >= old->p_vaddr &&
                newSegmentStart < (old+1)->p_vaddr)
        {
            // insert in middle of loadable list, after current
            insert_phdr = newPhdr+1;
        }
        else if(i == 0 && 
                old->p_type == PT_LOAD &&
                newSegmentStart < old->p_vaddr)
        {
            // insert BEFORE current phdr
            insert_phdr = newPhdr;
            newPhdr++;
        }
    }

      if(insert_phdr)
      {
         newSeg.p_type = PT_LOAD;
         newSeg.p_offset = firstNewLoadSec->sh_offset;
         newSeg.p_vaddr = newSegmentStart;
         newSeg.p_paddr = newSeg.p_vaddr;
         newSeg.p_filesz = loadSecTotalSize - (newSegmentStart - firstNewLoadSec->sh_addr);
         newSeg.p_memsz = (currEndAddress - firstNewLoadSec->sh_addr) - (newSegmentStart - firstNewLoadSec->sh_addr);
     newSeg.p_flags = PF_R+PF_W+PF_X;
         newSeg.p_align = pgSize;
         memcpy(insert_phdr, &newSeg, oldEhdr->e_phentsize);
         added_new_sec = true;
         rewrite_printf("Added New program header : offset 0x%lx,addr 0x%lx file Size 0x%lx memsize 0x%lx \n", newSeg.p_paddr, newSeg.p_vaddr, newSeg.p_filesz, newSeg.p_memsz);
#ifdef BINEDIT_DEBUG
         fprintf(stderr, "Added New program header : offset 0x%lx,addr 0x%lx\n", newPhdr->p_offset, newPhdr->p_vaddr);
#endif
      }

    memcpy(newPhdr, old, oldEhdr->e_phentsize);

     // Expand the data segment to include the new loadable sections
     // Also add a executable permission to the segment

     if(old->p_type == PT_DYNAMIC){
    newPhdr->p_vaddr = dynSegAddr;
    newPhdr->p_paddr = dynSegAddr;
    newPhdr->p_offset = dynSegOff;
    newPhdr->p_memsz = dynSegSize;
    newPhdr->p_filesz = newPhdr->p_memsz;
     }
     else if(old->p_type == PT_PHDR){
    if(createNewPhdr && !movePHdrsFirst)
            newPhdr->p_vaddr = phdrSegAddr;
        else if (createNewPhdr && movePHdrsFirst)
            newPhdr->p_vaddr = old->p_vaddr - pgSize;
    else
            newPhdr->p_vaddr = old->p_vaddr;
        newPhdr->p_offset = newEhdr->e_phoff;
        newPhdr->p_paddr = newPhdr->p_vaddr;
        newPhdr->p_filesz = sizeof(Elf64_Phdr) * newEhdr->e_phnum;
        newPhdr->p_memsz = newPhdr->p_filesz;
     }else if( hasRewrittenTLS && old->p_type == PT_TLS) {
          newPhdr->p_offset = newTLSData->sh_offset;
          newPhdr->p_vaddr = newTLSData->sh_addr;
          newPhdr->p_paddr = newTLSData->sh_addr;
          newPhdr->p_filesz = newTLSData->sh_size;
          newPhdr->p_memsz = newTLSData->sh_size + old->p_memsz - old->p_filesz;
          newPhdr->p_align = newTLSData->sh_addralign;
     }else if (old->p_type == PT_LOAD) {
        if(!createNewPhdr && newPhdr->p_align > pgSize) { //not on bluegene
           newPhdr->p_align = pgSize;
        }
        if(BSSExpandFlag) {
           if(old->p_flags == 6 || old->p_flags == 7)
           {
              newPhdr->p_memsz += loadSecTotalSize + extraAlignSize;
              newPhdr->p_filesz = newPhdr->p_memsz;
              newPhdr->p_flags = 7;
           }    
        }   

        if(movePHdrsFirst) {
           if (!old->p_offset) {
              if (newPhdr->p_vaddr)
                 newPhdr->p_vaddr = old->p_vaddr - pgSize;
          newPhdr->p_paddr = newPhdr->p_vaddr;
          newPhdr->p_filesz += pgSize;
          newPhdr->p_memsz = newPhdr->p_filesz;
           } else {
              newPhdr->p_offset += pgSize;
           }
           if (newPhdr->p_vaddr) {
              newPhdr->p_vaddr += library_adjust;
              newPhdr->p_paddr += library_adjust;
           }
        }
     }else if (replaceNOTE && old->p_type == PT_NOTE && !replaced) {
     replaced = true;
         newPhdr->p_type = PT_LOAD;
         newPhdr->p_offset = firstNewLoadSec->sh_offset;
         newPhdr->p_vaddr = newSegmentStart;
         newPhdr->p_paddr = newPhdr->p_vaddr; 
         newPhdr->p_filesz = loadSecTotalSize - (newSegmentStart - firstNewLoadSec->sh_addr);
         newPhdr->p_memsz = (currEndAddress - firstNewLoadSec->sh_addr) - (newSegmentStart - firstNewLoadSec->sh_addr);
         newPhdr->p_flags = PF_R+PF_W+PF_X;
         newPhdr->p_align = pgSize;
     }
     else if (old->p_type == PT_INTERP && movePHdrsFirst
             && old->p_offset && newEhdr->e_phnum >= oldEhdr->e_phnum)
     {
         newPhdr->p_offset += 
             oldEhdr->e_phentsize*(newEhdr->e_phnum-oldEhdr->e_phnum);
     }
     else if (movePHdrsFirst && old->p_offset) {
        newPhdr->p_offset += pgSize;
        if (newPhdr->p_vaddr) {
           newPhdr->p_vaddr += library_adjust;
           newPhdr->p_paddr += library_adjust;
        }
     }

     /* For BlueGeneQ statically linked binary, we cannot create a new LOAD section, 
         hence we extend existing LOAD section to include instrmentation.
          A new LOAD section must be aligned to 1MB in BlueGene. 
          But if we create a LOAD segment after 1MB, the TOC pointer will no longer be able to reach the new segment,
          as we have only 4 byte offset from TOC */

     if(0 && isBlueGeneQ && isStaticBinary && last_load_segment) {

        // add new load to this segment
         newPhdr->p_filesz = (newSeg.p_offset - newPhdr->p_offset) + loadSecTotalSize - (newSegmentStart - firstNewLoadSec->sh_addr);
         newPhdr->p_memsz = (newSegmentStart -  newPhdr->p_vaddr) + (currEndAddress - firstNewLoadSec->sh_addr) - (newSegmentStart - firstNewLoadSec->sh_addr);
         newPhdr->p_flags = PF_R+PF_W+PF_X;
        last_load_segment = false;

        // add new load to this segment
     } else {
         if(insert_phdr)
            newPhdr++;
    }   

     rewrite_printf("Existing program header: type %u, offset 0x%lx, addr 0x%lx\n", 
             newPhdr->p_type, newPhdr->p_offset, newPhdr->p_vaddr);
     
     newPhdr++;

     old++;
  }

  if( hasRewrittenTLS && !TLSExists ) {
    newPhdr->p_type = PT_TLS;
    newPhdr->p_offset = newTLSData->sh_offset;
    newPhdr->p_vaddr = newTLSData->sh_addr;
    newPhdr->p_filesz = newTLSData->sh_size;
    newPhdr->p_memsz = newTLSData->sh_size;
    newPhdr->p_align = newTLSData->sh_addralign;
  }
  
  if (!phdrs_scn)
     return;
  //We made a new section to contain the program headers--keeps
  // libelf from overwriting the program headers data when outputing
  // sections.  Fill in the new section's data with what we just wrote.
  Elf_Data *data = elf_newdata(phdrs_scn);
  size_t total_size = newEhdr->e_phnum * newEhdr->e_phentsize;
  data->d_buf = malloc(total_size);
  memcpy(data->d_buf, phdr_data, total_size);
  data->d_size = total_size;
  data->d_align = 0;
  data->d_off = 0;
  data->d_type = ELF_T_BYTE;
  data->d_version = 1;
}

#if !defined(DT_GNU_HASH)
#define DT_GNU_HASH 0x6ffffef5
#endif
#if !defined(DT_GNU_CONFLICT)
#define DT_GNU_CONFLICT 0x6ffffef8
#endif

//This method updates the .dynamic section to reflect the changes to the relocation section
void emitElf64::updateDynamic(unsigned tag, Elf64_Addr val){
  if (isStaticBinary) return;
  // This is for REL/RELA if it doesnt already exist in the original binary; 
  dynamicSecData[tag][0]->d_tag = tag;
  switch(dynamicSecData[tag][0]->d_tag){
  case DT_STRSZ:
  case DT_RELSZ:
  case DT_RELASZ:
  case DT_PLTRELSZ:
  case DT_RELACOUNT:
  case DT_RELENT:
  case DT_RELAENT:
    dynamicSecData[tag][0]->d_un.d_val = val;
    break;
  case DT_HASH:
  case DT_GNU_HASH:
  case DT_SYMTAB:
  case DT_STRTAB:
  case DT_REL:
  case DT_RELA:
  case DT_VERSYM:
  case DT_JMPREL:
    dynamicSecData[tag][0]->d_un.d_ptr = val;
    break;
  case DT_VERNEED:
    dynamicSecData[tag][0]->d_un.d_ptr = val;
    dynamicSecData[DT_VERNEEDNUM][0]->d_un.d_val = verneednum;
    break;
  case DT_VERDEF:
    dynamicSecData[tag][0]->d_un.d_ptr = val;
    dynamicSecData[DT_VERDEFNUM][0]->d_un.d_val = verdefnum;
    break;
    }
}

/* This method sets _end and _END_ to the starting position of the heap in the
 * new binary. 
 */
void emitElf64::updateSymbols(Elf_Data* symtabData,Elf_Data* strData, unsigned long loadSecsSize){
  unsigned pgSize = (unsigned)getpagesize();
  if( symtabData && strData && loadSecsSize){
    Elf64_Sym *symPtr=(Elf64_Sym*)symtabData->d_buf;
    for(unsigned int i=0;i< symtabData->d_size/(sizeof(Elf64_Sym));i++,symPtr++){
      if(!(strcmp("_end", (char*) strData->d_buf + symPtr->st_name))){
        if( newSegmentStart >= symPtr->st_value ) {
            symPtr->st_value += ((newSegmentStart - symPtr->st_value) + loadSecsSize);

            // Advance the location to the next page boundary
            symPtr->st_value = (symPtr->st_value & ~(pgSize-1)) + pgSize;
        }
      }
      if(!(strcmp("_END_", (char*) strData->d_buf + symPtr->st_name))){
        if( newSegmentStart > symPtr->st_value ) {
            symPtr->st_value += (newSegmentStart - symPtr->st_value) + loadSecsSize;
            
            // Advance the location to the next page boundary
            symPtr->st_value = (symPtr->st_value & ~(pgSize-1)) + pgSize;
        }
      }
    }    
  }
}

bool emitElf64::createLoadableSections(Symtab *obj, Elf64_Shdr* &shdr, unsigned &extraAlignSize, dyn_hash_map<std::string, unsigned> &newNameIndexMapping, unsigned &sectionNumber)
{
   Elf_Scn *newscn;
   Elf_Data *newdata = NULL;

   Elf64_Shdr *newshdr;
   std::vector<Elf64_Shdr *> updateDynLinkShdr;
   std::vector<Elf64_Shdr *> updateStrLinkShdr;
   firstNewLoadSec = NULL;
   unsigned pgSize = getpagesize();
   unsigned strtabIndex = 0;
   unsigned dynsymIndex = 0;
   Elf64_Shdr *prevshdr = NULL;

   /*
    * Order the new sections such that those with explicit
    * memory offsets come before those without (that will be placed
    * after the non-zero sections).
    *
    * zstart is used to place the first zero-offset section if
    * no non-zero-offset sections exist.
    */
   Address zstart = emitElfUtils::orderLoadableSections(obj,newSecs);

   for(unsigned i=0; i < newSecs.size(); i++)
   {
      if(!newSecs[i]->isLoadable()) {
         nonLoadableSecs.push_back(newSecs[i]);
         continue;
      }
      secNames.push_back(newSecs[i]->getRegionName());
      newNameIndexMapping[newSecs[i]->getRegionName()] = secNames.size() -1;
      sectionNumber++;
      // Add a new loadable section
      if((newscn = elf_newscn(newElf)) == NULL)
      {  
         log_elferror(err_func_, "unable to create new function");  
         return false;
      }     
      if ((newdata = elf_newdata(newscn)) == NULL)
      {
         log_elferror(err_func_, "unable to create section data");  
         return false;
      } 
      memset(newdata, 0, sizeof(Elf_Data));

      // Fill out the new section header    
     newshdr = elf64_getshdr(newscn);
     newshdr->sh_name = secNameIndex;
     newshdr->sh_flags = 0;
     newshdr->sh_type = SHT_PROGBITS;
     switch(newSecs[i]->getRegionType()){
        case Region::RT_TEXTDATA:
           newshdr->sh_flags = SHF_EXECINSTR | SHF_ALLOC | SHF_WRITE;
           break;
        case Region::RT_TEXT:
           newshdr->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
           break;
        case Region::RT_BSS:
           newshdr->sh_type = SHT_NOBITS;
        case Region::RT_DATA:
           newshdr->sh_flags = SHF_WRITE | SHF_ALLOC;
           break;
        default:
           break;
     }

     if(shdr->sh_type == SHT_NOBITS) {
        newshdr->sh_offset = shdr->sh_offset;
     }else if( !firstNewLoadSec || !newSecs[i]->getDiskOffset() ) {
        newshdr->sh_offset = shdr->sh_offset+shdr->sh_size;
     }else{
         // The offset can be computed by determing the difference from
         // the first new loadable section
         newshdr->sh_offset = firstNewLoadSec->sh_offset +
             (newSecs[i]->getDiskOffset() - firstNewLoadSec->sh_addr);

         // Account for inter-section spacing due to alignment constraints
         loadSecTotalSize += newshdr->sh_offset - (shdr->sh_offset+shdr->sh_size);
     }

     if(newSecs[i]->getDiskOffset())
        newshdr->sh_addr = newSecs[i]->getDiskOffset() + library_adjust;
     else if(!prevshdr) {
        newshdr->sh_addr = zstart + library_adjust;
     }
     else{
        newshdr->sh_addr = prevshdr->sh_addr+ prevshdr->sh_size;
     }

     newshdr->sh_link = SHN_UNDEF;
     newshdr->sh_info = 0;
     newshdr->sh_addralign = newSecs[i]->getMemAlignment();
     newshdr->sh_entsize = 0;

     // TLS section
     if( newSecs[i]->isTLS() ) {
          newTLSData = newshdr;
          newshdr->sh_flags |= SHF_TLS;
     }

     if(newSecs[i]->getRegionType() == Region::RT_REL ||
        newSecs[i]->getRegionType() == Region::RT_PLTREL)    //Relocation section
     {
        newshdr->sh_type = SHT_REL;
        newshdr->sh_flags = SHF_ALLOC;
        newshdr->sh_entsize = sizeof(Elf64_Rel);
        updateDynLinkShdr.push_back(newshdr);
        newdata->d_type = ELF_T_REL;
         newdata->d_align = 4;
         if (newSecs[i]->getRegionType() == Region::RT_REL)
            updateDynamic(DT_REL, newshdr->sh_addr);
         else if (newSecs[i]->getRegionType() == Region::RT_PLTREL)
            updateDynamic(DT_JMPREL, newshdr->sh_addr);
      }
      else if(newSecs[i]->getRegionType() == Region::RT_RELA ||
              newSecs[i]->getRegionType() == Region::RT_PLTRELA) //Relocation section
      {
         newshdr->sh_type = SHT_RELA;
         newshdr->sh_flags = SHF_ALLOC;
         newshdr->sh_entsize = sizeof(Elf64_Rela);
         updateDynLinkShdr.push_back(newshdr);
         newdata->d_type = ELF_T_RELA;
         newdata->d_align = 4;
         if (newSecs[i]->getRegionType() == Region::RT_RELA)
            updateDynamic(DT_RELA, newshdr->sh_addr);
         else if (newSecs[i]->getRegionType() == Region::RT_PLTRELA)
            updateDynamic(DT_JMPREL, newshdr->sh_addr);
      }
      else if(newSecs[i]->getRegionType() == Region::RT_STRTAB)    //String table Section
      {
         newshdr->sh_type = SHT_STRTAB;
         newshdr->sh_entsize = 1;
         newdata->d_type = ELF_T_BYTE;
         newshdr->sh_link = SHN_UNDEF;
         newshdr->sh_flags=  SHF_ALLOC;
         newdata->d_align = 1;
         dynStrData = newdata;
         strtabIndex = secNames.size()-1;
         newshdr->sh_addralign = 1;
         updateDynamic(DT_STRTAB, newshdr->sh_addr);
         updateDynamic(DT_STRSZ, newSecs[i]->getDiskSize());
      }
      else if(newSecs[i]->getRegionType() == Region::RT_SYMTAB)
      {
         newshdr->sh_type = SHT_DYNSYM;
         newshdr->sh_entsize = sizeof(Elf64_Sym);
         newdata->d_type = ELF_T_SYM;
         newdata->d_align = 4;
         dynsymData = newdata;
         newshdr->sh_link = secNames.size();   //.symtab section should have sh_link = index of .strtab for .dynsym
         newshdr->sh_flags = SHF_ALLOC ;
         dynsymIndex = secNames.size()-1;
         updateDynamic(DT_SYMTAB, newshdr->sh_addr);
      }
      else if(newSecs[i]->getRegionType() == Region::RT_DYNAMIC)
      {
         newshdr->sh_entsize = sizeof(Elf64_Dyn);
         newshdr->sh_type = SHT_DYNAMIC;
         newdata->d_type = ELF_T_DYN;
         newdata->d_align = 4;
         updateStrLinkShdr.push_back(newshdr);
         newshdr->sh_flags=  SHF_ALLOC | SHF_WRITE;
         dynSegOff = newshdr->sh_offset;
         dynSegAddr = newshdr->sh_addr;
         dynSegSize = newSecs[i]->getDiskSize();
      }
      else if(newSecs[i]->getRegionType() == Region::RT_HASH)
      {
         newshdr->sh_entsize = sizeof(Elf64_Word);
         newshdr->sh_type = SHT_HASH;
         newdata->d_type = ELF_T_WORD;
         newdata->d_align = 4;
         updateDynLinkShdr.push_back(newshdr);
         newshdr->sh_flags=  SHF_ALLOC;
         newshdr->sh_info = 0;
         updateDynamic(DT_HASH, newshdr->sh_addr);
      }
      else if(newSecs[i]->getRegionType() == Region::RT_SYMVERSIONS)
      {
         newshdr->sh_type = SHT_GNU_versym;
         newshdr->sh_entsize = sizeof(Elf64_Half);
         newshdr->sh_addralign = 2;
         newdata->d_type = ELF_T_HALF;
         newdata->d_align = 2;
         updateDynLinkShdr.push_back(newshdr);
         newshdr->sh_flags = SHF_ALLOC ;
         updateDynamic(DT_VERSYM, newshdr->sh_addr);
      }
      else if(newSecs[i]->getRegionType() == Region::RT_SYMVERNEEDED)
      {
         newshdr->sh_type = SHT_GNU_verneed;
         newshdr->sh_entsize = 0;
         newshdr->sh_addralign = 4;
         newdata->d_type = ELF_T_VNEED;
         newdata->d_align = 4;
         updateStrLinkShdr.push_back(newshdr);
         newshdr->sh_flags = SHF_ALLOC ;
         newshdr->sh_info = 2;
         updateDynamic(DT_VERNEED, newshdr->sh_addr);
      }
      else if(newSecs[i]->getRegionType() == Region::RT_SYMVERDEF)
      {
         newshdr->sh_type = SHT_GNU_verdef;
         newshdr->sh_entsize = 0;
         newdata->d_type = ELF_T_VDEF;
         newdata->d_align = 4;
         updateStrLinkShdr.push_back(newshdr);
         newshdr->sh_flags = SHF_ALLOC ;
         updateDynamic(DT_VERDEF, newshdr->sh_addr);
      }

       if(isBlueGeneQ) newshdr->sh_flags = bgq_sh_flags;

     // Check to make sure the (vaddr for the start of the new segment - the offset) is page aligned
     if(!firstNewLoadSec)
     {
        Offset newoff = newshdr->sh_offset  - (newshdr->sh_offset & (pgSize-1)) + (newshdr->sh_addr & (pgSize-1));
        if(newoff < newshdr->sh_offset)
           newoff += pgSize;
        extraAlignSize += newoff - newshdr->sh_offset;
        newshdr->sh_offset = newoff;

    // For now, bluegene is the only system for which createNewPhdr is false. 
    // Bluegene compute nodes have a 1MB alignment restructions on PT_LOAD section
    // When we are replaceing PT_NOTE with PT_LOAD, we need to make sure the new PT_LOAD is 1MB aligned
    if (!createNewPhdr && replaceNOTE)  {
            Offset newaddr = newshdr->sh_addr  - (newshdr->sh_addr & (0x100000-1));
            if(newaddr < newshdr->sh_addr)
                 newaddr += 0x100000;
            newshdr->sh_addr = newaddr;
    }
        newSegmentStart = newshdr->sh_addr;
     }

      //Set up the data
      newdata->d_buf = malloc(newSecs[i]->getDiskSize());
      memcpy(newdata->d_buf, newSecs[i]->getPtrToRawData(), newSecs[i]->getDiskSize());
      newdata->d_off = 0;
      newdata->d_size = newSecs[i]->getDiskSize();
      if (!newdata->d_align)
         newdata->d_align = newshdr->sh_addralign;
      newshdr->sh_size = newdata->d_size;

     if( newshdr->sh_type == SHT_NOBITS ) {
         currEndOffset = newshdr->sh_offset;
     }else{
        loadSecTotalSize += newshdr->sh_size;
        currEndOffset = newshdr->sh_offset + newshdr->sh_size;
     }
     currEndAddress = newshdr->sh_addr + newshdr->sh_size;

      rewrite_printf("new section %s addr = %lx off = %lx size = %lx\n",
              newSecs[i]->getRegionName().c_str(), newshdr->sh_addr, newshdr->sh_offset,
              newshdr->sh_size);
        
      newdata->d_version = 1;

     if (0 > elf_update(newElf, ELF_C_NULL))
     {
       fprintf(stderr, "%s[%d]:  elf_update failed: %d, %s\n", FILE__, __LINE__, errno, elf_errmsg(elf_errno()));
       return false;
     }

     shdr = newshdr;
     if(!firstNewLoadSec)
        firstNewLoadSec = shdr;
     secNameIndex += newSecs[i]->getRegionName().size() + 1;
     prevshdr = newshdr;
  }
    
  for(unsigned i=0; i < updateDynLinkShdr.size(); i++) {
    newshdr = updateDynLinkShdr[i];
    newshdr->sh_link = dynsymIndex;   
  }
    
  for(unsigned i=0; i < updateStrLinkShdr.size(); i++) {
    newshdr = updateStrLinkShdr[i];
    newshdr->sh_link = strtabIndex;   
  }

   
  return true;
}
    
bool emitElf64::addSectionHeaderTable(Elf64_Shdr *shdr) {
   Elf_Scn *newscn;
   Elf_Data *newdata = NULL;
   Elf64_Shdr *newshdr;
   
   if((newscn = elf_newscn(newElf)) == NULL)
   {
      log_elferror(err_func_, "unable to create new function"); 
      return false;
   }    
   if ((newdata = elf_newdata(newscn)) == NULL)
   {
      log_elferror(err_func_, "unable to create section data"); 
      return false;
   } 
   //Fill out the new section header
   newshdr = elf64_getshdr(newscn);
   newshdr->sh_name = secNameIndex;
   secNames.push_back(".shstrtab");
   secNameIndex += 10;
   newshdr->sh_type = SHT_STRTAB;
   newshdr->sh_entsize = 1;
   newdata->d_type = ELF_T_BYTE;
   newshdr->sh_link = SHN_UNDEF; 
   newshdr->sh_flags=  0;

   newshdr->sh_offset = shdr->sh_offset+shdr->sh_size;
   newshdr->sh_addr = 0;
   newshdr->sh_info = 0;
   newshdr->sh_addralign = 4;
   
   //Set up the data
   newdata->d_buf = (char *)malloc(secNameIndex);
   char *ptr = (char *)newdata->d_buf;
   for(unsigned i=0;i<secNames.size(); i++)
   {
      memcpy(ptr, secNames[i].c_str(), secNames[i].length());
      memcpy(ptr+secNames[i].length(), "\0", 1);
      ptr += secNames[i].length()+1;
   }    
    
   newdata->d_size = secNameIndex;
   newshdr->sh_size = newdata->d_size;
#ifdef BINEDIT_DEBUG
   fprintf(stderr, "Added New Section(%s) : secAddr 0x%lx, secOff 0x%lx, secsize 0x%lx, end 0x%lx\n",
           ".shstrtab", newshdr->sh_addr, newshdr->sh_offset, newshdr->sh_size, newshdr->sh_offset + newshdr->sh_size );
#endif
   //elf_update(newElf, ELF_C_NULL);
   
   newdata->d_align = 4;
   newdata->d_version = 1;
    if (newshdr->sh_entsize && (newshdr->sh_size % newshdr->sh_entsize != 0))
        fprintf(stderr, "%s[%d]:  ERROR:  setting size to non multiple of entry size in section %s: %lu/%lu\n", FILE__, __LINE__, ".shstrtab", newshdr->sh_size, newshdr->sh_entsize);
   return true;
}

bool emitElf64::createNonLoadableSections(Elf64_Shdr *&shdr)
{
  Elf_Scn *newscn;
  Elf_Data *newdata = NULL;
  Elf64_Shdr *newshdr;
    
  Elf64_Shdr *prevshdr = shdr; 
  //All of them that are left are non-loadable. stack'em up at the end.
  for(unsigned i = 0; i < nonLoadableSecs.size(); i++)
    {
      secNames.push_back(nonLoadableSecs[i]->getRegionName());
      // Add a new non-loadable section
      if((newscn = elf_newscn(newElf)) == NULL)
        {
      log_elferror(err_func_, "unable to create new function"); 
      return false;
        }   
      if ((newdata = elf_newdata(newscn)) == NULL)
        {
      log_elferror(err_func_, "unable to create section data"); 
      return false;
        } 

      //Fill out the new section header
      newshdr = elf64_getshdr(newscn);
      newshdr->sh_name = secNameIndex;
      secNameIndex += nonLoadableSecs[i]->getRegionName().length() + 1;
      if(nonLoadableSecs[i]->getRegionType() == Region::RT_TEXT)        //Text Section
        {
      newshdr->sh_type = SHT_PROGBITS;
      newshdr->sh_flags = SHF_EXECINSTR | SHF_WRITE;
      newshdr->sh_entsize = 1;
      newdata->d_type = ELF_T_BYTE;
        }
      else if(nonLoadableSecs[i]->getRegionType() == Region::RT_DATA)   //Data Section
        {
      newshdr->sh_type = SHT_PROGBITS;
      newshdr->sh_flags = SHF_WRITE;
      newshdr->sh_entsize = 1;
      newdata->d_type = ELF_T_BYTE;
        }
      else if(nonLoadableSecs[i]->getRegionType() == Region::RT_REL)    //Relocations section
        {
      newshdr->sh_type = SHT_REL;
      newshdr->sh_flags = SHF_WRITE;
      newshdr->sh_entsize = sizeof(Elf64_Rel);
      newdata->d_type = ELF_T_BYTE;
        }
      else if(nonLoadableSecs[i]->getRegionType() == Region::RT_RELA)   //Relocations section
        {
      newshdr->sh_type = SHT_RELA;
      newshdr->sh_flags = SHF_WRITE;
      newshdr->sh_entsize = sizeof(Elf64_Rela);
      newdata->d_type = ELF_T_BYTE;
        }
      else if(nonLoadableSecs[i]->getRegionType() == Region::RT_SYMTAB)
        {
      newshdr->sh_type = SHT_SYMTAB;
      newshdr->sh_entsize = sizeof(Elf64_Sym);
      newdata->d_type = ELF_T_SYM;
      newshdr->sh_link = secNames.size();   //.symtab section should have sh_link = index of .strtab 
      newshdr->sh_flags=  0;
        }
      else if(nonLoadableSecs[i]->getRegionType() == Region::RT_STRTAB) //String table Section
        {
      newshdr->sh_type = SHT_STRTAB;
      newshdr->sh_entsize = 1;
      newdata->d_type = ELF_T_BYTE;
      newshdr->sh_link = SHN_UNDEF; 
      newshdr->sh_flags=  0;
        }
      /*
        else if(nonLoadableSecs[i]->getFlags() & Section::dynsymtabSection)
        {
    newshdr->sh_type = SHT_DYNSYM;
    newshdr->sh_entsize = sizeof(Elf64_Sym);
    newdata->d_type = ELF_T_SYM;
    //newshdr->sh_link = newSecSize+i+1;   //.symtab section should have sh_link = index of .strtab
    newshdr->sh_flags=  SHF_ALLOC | SHF_WRITE;
        }*/
      newshdr->sh_offset = prevshdr->sh_offset+prevshdr->sh_size;
      if( prevshdr->sh_type == SHT_NOBITS ) {
          newshdr->sh_offset = prevshdr->sh_offset;
      }else{
          newshdr->sh_offset = prevshdr->sh_offset+prevshdr->sh_size;
      }
      if (newshdr->sh_offset < currEndOffset) {
         newshdr->sh_offset = currEndOffset;
      }
      newshdr->sh_addr = 0;
      newshdr->sh_info = 0;
      newshdr->sh_addralign = 4;

      //Set up the data
      newdata->d_buf = nonLoadableSecs[i]->getPtrToRawData();
      newdata->d_size = nonLoadableSecs[i]->getDiskSize();
      newshdr->sh_size = newdata->d_size;
      //elf_update(newElf, ELF_C_NULL);

      newdata->d_align = 4;
      newdata->d_off = 0;
      newdata->d_version = 1;
      currEndOffset = newshdr->sh_offset + newshdr->sh_size;
      //currEndAddress = newshdr->sh_addr + newshdr->sh_size;
      /* DEBUG */
#ifdef BINEDIT_DEBUG
      fprintf(stderr, "Added New Section(%s) : secAddr 0x%lx, secOff 0x%lx, secsize 0x%lx, end 0x%lx\n",
          nonLoadableSecs[i]->getRegionName().c_str(), newshdr->sh_addr, newshdr->sh_offset, newshdr->sh_size, newshdr->sh_offset + newshdr->sh_size );
#endif

    if (newshdr->sh_entsize && (newshdr->sh_size % newshdr->sh_entsize != 0))
        fprintf(stderr, "%s[%d]:  ERROR:  setting size to non multiple of entry size in section %s: %lu/%lu\n", FILE__, __LINE__, nonLoadableSecs[i]->getRegionName().c_str(), newshdr->sh_size, newshdr->sh_entsize);

      prevshdr = newshdr;
    }   
  shdr = prevshdr;
  return true;
}       


/* Regenerates the .symtab, .strtab sections from the symbols
 * Add new .dynsym, .dynstr sections for the newly added dynamic symbols
 * Method - For every symbol call createElfSymbol to get a Elf64_Sym corresposnding 
 *          to a Symbol object. Accumulate all and their names to form the sections
 *          and add them to the list of new sections
 */
bool emitElf64::createSymbolTables(Symtab *obj, vector<Symbol *>&allSymbols)
{
  rewrite_printf(" createSymbolTables for %s \n", obj->name().c_str());
  unsigned i;

  //Symbol table(.symtab) symbols
  std::vector<Elf64_Sym *> symbols;

  //Symbol table(.dynsymtab) symbols
  std::vector<Elf64_Sym *> dynsymbols;

  unsigned symbolNamesLength = 1, dynsymbolNamesLength = 1;
  dyn_hash_map<string, unsigned long> dynSymNameMapping;
  std::vector<std::string> symbolStrs, dynsymbolStrs;
  std::vector<Symbol *> dynsymVector;
  std::vector<Symbol *> allDynSymbols;
  std::vector<Symbol *> allSymSymbols;

  dyn_hash_map<int, Region*> secTagRegionMapping = obj->getObject()->getTagRegionMapping();

  Region *sec;
  dyn_hash_map<int, Region*>::const_iterator foundRegion;
  foundRegion = secTagRegionMapping.find(DT_STRTAB);
  if ((foundRegion != secTagRegionMapping.end()) && (foundRegion->second != NULL)) {
    // .dynstr
    sec = foundRegion->second;
    olddynStrData = (char *)(sec->getPtrToRawData());
    olddynStrSize = sec->getMemSize();
    dynsymbolNamesLength = olddynStrSize+1;
  }

  // Copy over the previous library dependencies
  vector<string> &elibs = obj->getObject()->deps_;
  for (std::vector<std::string>::iterator iter = elibs.begin();
       iter != elibs.end(); ++iter) {
     addDTNeeded(*iter);
  }

  //Initialize the list of new prereq libraries
  set<string> &plibs = obj->getObject()->prereq_libs;
  for (set<string>::iterator i = plibs.begin(); i != plibs.end(); i++) {
     addDTNeeded(*i);
  }
  new_dynamic_entries = obj->getObject()->new_dynamic_entries;
  Object *object = obj->getObject();
  // recreate a "dummy symbol"
  Elf64_Sym *sym = new Elf64_Sym();
  symbolStrs.push_back("");
  // We should increment this here, but for reasons I don't understand we create it with a size of
  // 1. 
  //symbolNamesLength++;
  sym->st_name = 0;
  sym->st_value = 0;
  sym->st_size = 0;
  sym->st_other = 0;
  sym->st_info = ELF64_ST_INFO(STB_LOCAL, STT_NOTYPE);
  sym->st_shndx = SHN_UNDEF;

  symbols.push_back(sym);
  if (!obj->isStaticBinary()) {
    dynsymbols.push_back(sym);
    dynsymVector.push_back(Symbol::magicEmitElfSymbol());
    versionSymTable.push_back(0);
  }   
 
  if (obj->isStaticBinary()) {
      // Static binary case
      vector<Region *> newRegs;
      obj->getAllNewRegions(newRegs);
      if( newRegs.size() ) {
          emitElfStatic linker(obj->getAddressWidth(), isStripped);

          emitElfStatic::StaticLinkError err;
          std::string errMsg;
          linkedStaticData = linker.linkStatic(obj, err, errMsg);
          if ( !linkedStaticData ) {
               std::string linkStaticError = 
                   std::string("Failed to link to static library code into the binary: ") +
                   emitElfStatic::printStaticLinkError(err) + std::string(" = ")
                   + errMsg;
               setSymtabError(Emit_Error);
               symtab_log_perror(linkStaticError.c_str());
               return false;
          }

          hasRewrittenTLS = linker.hasRewrittenTLS();

          // Find the end of the new Regions
          obj->getAllNewRegions(newRegs);

          Offset lastRegionAddr = 0, lastRegionSize = 0;
          vector<Region *>::iterator newRegIter;
          for(newRegIter = newRegs.begin(); newRegIter != newRegs.end();
              ++newRegIter)
          {
              if( (*newRegIter)->getDiskOffset() > lastRegionAddr ) {
                  lastRegionAddr = (*newRegIter)->getDiskOffset();
                  lastRegionSize = (*newRegIter)->getDiskSize();
              }
          }

          if( !emitElfUtils::updateHeapVariables(obj, lastRegionAddr + lastRegionSize) ) {
              return false;
          }
      }
  }

  for(i=0; i<allSymbols.size();i++) {
    if(allSymbols[i]->isInSymtab()) {
      allSymSymbols.push_back(allSymbols[i]);
    }   
    if (!obj->isStaticBinary()) {
      if(allSymbols[i]->isInDynSymtab()) {
        allDynSymbols.push_back(allSymbols[i]);
      } 
    }
  }
 
  int max_index = -1;
  for(i = 0; i < allDynSymbols.size();i++) {
    if (max_index < allDynSymbols[i]->getIndex()) 
      max_index = allDynSymbols[i]->getIndex();
  }
  for(i=0; i<allDynSymbols.size(); i++) {
    if (allDynSymbols[i]->getIndex() == -1) {
      max_index++;
      allDynSymbols[i]->setIndex(max_index);
    }

    if (allDynSymbols[i]->getStrIndex() == -1) {
      // New Symbol - append to the list of strings
      dynsymbolStrs.push_back( allDynSymbols[i]->getMangledName().c_str());
      allDynSymbols[i]->setStrIndex(dynsymbolNamesLength);
      dynsymbolNamesLength += allDynSymbols[i]->getMangledName().length() + 1;
    } 

  } 
  // reorder allSymbols based on index
  std::sort(allDynSymbols.begin(), allDynSymbols.end(), sortByIndex());
   
  max_index = -1;
  for(i = 0; i < allSymSymbols.size();i++) {
    if (max_index < allSymSymbols[i]->getIndex()) 
      max_index = allSymSymbols[i]->getIndex();
  }

  for(i=0; i<allSymSymbols.size(); i++) {
    if (allSymSymbols[i]->getIndex() == -1) {
      max_index++;
      allSymSymbols[i]->setIndex(max_index);
    }
  } 

  std::sort(allSymSymbols.begin(), allSymSymbols.end(), sortByIndex());

  /* We regenerate symtab and symstr section. We do not 
     maintain the order of the strings and symbols as it was in
     the original binary. Hence, the strings in symstr have new order and 
     new index.
     On the other hand, we do not regenerate dynsym and dynstr section. We copy over
     old symbols and string in the original order as it was in the 
     original binary. We preserve sh_index of Elf symbols (from Symbol's strIndex). We append 
     new symbols and string that we create for the new binary (targ*, versions etc).
  */  

  for(i=0; i<allSymSymbols.size();i++) {
    //allSymSymbols[i]->setStrIndex(symbolNamesLength);
    createElfSymbol(allSymSymbols[i], symbolNamesLength, symbols);
    symbolStrs.push_back(allSymSymbols[i]->getMangledName());
    symbolNamesLength += allSymSymbols[i]->getMangledName().length()+1;
  }
  for(i=0; i<allDynSymbols.size();i++) {
    createElfSymbol(allDynSymbols[i], allDynSymbols[i]->getStrIndex(), dynsymbols, true);
    dynSymNameMapping[allDynSymbols[i]->getMangledName().c_str()] = allDynSymbols[i]->getIndex();
    dynsymVector.push_back(allDynSymbols[i]);
  }

  //reconstruct .symtab section
  Elf64_Sym *syms = (Elf64_Sym *)malloc(symbols.size()* sizeof(Elf64_Sym));
  for(i=0;i<symbols.size();i++)
    syms[i] = *(symbols[i]);

  char *str = (char *)malloc(symbolNamesLength);
  unsigned cur=0;
  for(i=0;i<symbolStrs.size();i++)
    {
      strcpy(&str[cur],symbolStrs[i].c_str());
      cur+=symbolStrs[i].length()+1;
    }
    
  if(!isStripped)
    {
      Region *sec;
      if (obj->findRegion(sec,".symtab"))
    sec->setPtrToRawData(syms, symbols.size()*sizeof(Elf64_Sym));
      else
    obj->addRegion(0, syms, symbols.size()*sizeof(Elf64_Sym), ".symtab", Region::RT_SYMTAB);
    }
  else
    obj->addRegion(0, syms, symbols.size()*sizeof(Elf64_Sym), ".symtab", Region::RT_SYMTAB);

  //reconstruct .strtab section
  if(!isStripped)
    {
      Region *sec;
      if (obj->findRegion(sec,".strtab"))
          sec->setPtrToRawData(str, symbolNamesLength);
      else
              obj->addRegion(0, str, symbolNamesLength , ".strtab", Region::RT_STRTAB);
    }
  else
    obj->addRegion(0, str, symbolNamesLength , ".strtab", Region::RT_STRTAB);
    
  if(!obj->getAllNewRegions(newSecs))
    log_elferror(err_func_, "No new sections to add");

  if(dynsymbols.size() == 1)
    return true;

  if (!obj->isStaticBinary()) {
    //reconstruct .dynsym section
    Elf64_Sym *dynsyms = (Elf64_Sym *)malloc(dynsymbols.size()* sizeof(Elf64_Sym));
    for(i=0;i<dynsymbols.size();i++)
      dynsyms[i] = *(dynsymbols[i]);

    Elf64_Half *symVers;
    char *verneedSecData, *verdefSecData;
    unsigned verneedSecSize = 0, verdefSecSize = 0;
               
    createSymbolVersions(obj, symVers, verneedSecData, verneedSecSize, verdefSecData, verdefSecSize, dynsymbolNamesLength, dynsymbolStrs);
    // build new .hash section
    Elf64_Word *hashsecData;
    unsigned hashsecSize = 0;
    createHashSection(obj, hashsecData, hashsecSize, dynsymVector);
    if(hashsecSize) {
      string name; 
      if (secTagRegionMapping.find(DT_HASH) != secTagRegionMapping.end()) {
    name = secTagRegionMapping[DT_HASH]->getRegionName();
    obj->addRegion(0, hashsecData, hashsecSize*sizeof(Elf64_Word), name, Region::RT_HASH, true);
      } else if (secTagRegionMapping.find(0x6ffffef5) != secTagRegionMapping.end()) {
    name = secTagRegionMapping[0x6ffffef5]->getRegionName();
    obj->addRegion(0, hashsecData, hashsecSize*sizeof(Elf64_Word), name, Region::RT_HASH, true);
      } else {
    name = ".hash";
    obj->addRegion(0, hashsecData, hashsecSize*sizeof(Elf64_Word), name, Region::RT_HASH, true);
      } 
    }

    Elf64_Dyn *dynsecData;
    unsigned dynsecSize = 0;
    if(obj->findRegion(sec, ".dynamic")) {
        // Need to ensure that DT_REL and related fields added to .dynamic
        // The values of these fields will be set
/*
        if( !object->hasReldyn() && !object->hasReladyn() ) {
            if( object->getRelType() == Region::RT_REL ) {
                new_dynamic_entries.push_back(make_pair(DT_REL,0));
                new_dynamic_entries.push_back(make_pair(DT_RELSZ,0));
            }else if( object->getRelType() == Region::RT_RELA ) {
                new_dynamic_entries.push_back(make_pair(DT_RELA,0));
                new_dynamic_entries.push_back(make_pair(DT_RELASZ,0));
            }else{
                assert(!"Relocation type not set to known RT_REL or RT_RELA.");
            }
        } 
*/
        createDynamicSection(sec->getPtrToRawData(), sec->getDiskSize(), dynsecData, dynsecSize, dynsymbolNamesLength, dynsymbolStrs);
    }  
   
    if(!dynsymbolNamesLength)
      return true; 

    char *dynstr = (char *)malloc(dynsymbolNamesLength);
    memcpy((void *)dynstr, (void *)olddynStrData, olddynStrSize);
    cur = olddynStrSize+1;
    for(i=0;i<dynsymbolStrs.size();i++)
      {
    strcpy(&dynstr[cur],dynsymbolStrs[i].c_str());
    cur+=dynsymbolStrs[i].length()+1;
    if ( dynSymNameMapping.find(dynsymbolStrs[i]) == dynSymNameMapping.end()) {
      dynSymNameMapping[dynsymbolStrs[i]] = allDynSymbols.size()+i;
    }
      }

    string name; 
    if (secTagRegionMapping.find(DT_SYMTAB) != secTagRegionMapping.end()) {
      name = secTagRegionMapping[DT_SYMTAB]->getRegionName();
    } else {
      name = ".dynsym";
    }
    obj->addRegion(0, dynsyms, dynsymbols.size()*sizeof(Elf64_Sym), name, Region::RT_SYMTAB, true);

    if (secTagRegionMapping.find(DT_STRTAB) != secTagRegionMapping.end()) {
      name = secTagRegionMapping[DT_STRTAB]->getRegionName();
    } else {
      name = ".dynstr";
    }
    obj->addRegion(0, dynstr, dynsymbolNamesLength , name, Region::RT_STRTAB, true);

    //add .gnu.version, .gnu.version_r, and .gnu.version_d sections
    if (secTagRegionMapping.find(DT_VERSYM) != secTagRegionMapping.end()) {
      name = secTagRegionMapping[DT_VERSYM]->getRegionName();
    } else {
      name = ".gnu.version";
    }
    obj->addRegion(0, symVers, versionSymTable.size() * sizeof(Elf64_Half), name, Region::RT_SYMVERSIONS, true);

    if(verneedSecSize) {
      if (secTagRegionMapping.find(DT_VERNEED) != secTagRegionMapping.end()) {
    name = secTagRegionMapping[DT_VERNEED]->getRegionName();
      } else {
    name = ".gnu.version_r";
      }
      obj->addRegion(0, verneedSecData, verneedSecSize, name, Region::RT_SYMVERNEEDED, true);
    }

    if(verdefSecSize) {
      obj->addRegion(0, verdefSecData, verdefSecSize, ".gnu.version_d", Region::RT_SYMVERDEF, true);
    }

    //Always create a dyn section, it may get our new relocations.
    //If both exist, then just try to maintain order.
    bool has_plt = object->hasRelaplt() || object->hasRelplt();
    bool has_dyn = object->hasReladyn() || object->hasReldyn();
    if (!has_plt) {
       createRelocationSections(obj, object->getDynRelocs(), true, dynSymNameMapping);
    }
    else if (!has_dyn) {
       createRelocationSections(obj, object->getPLTRelocs(), false, dynSymNameMapping);
       createRelocationSections(obj, object->getDynRelocs(), true, dynSymNameMapping);
    }
    else if (object->getRelPLTAddr() < object->getRelDynAddr()) {
       createRelocationSections(obj, object->getPLTRelocs(), false, dynSymNameMapping);
       createRelocationSections(obj, object->getDynRelocs(), true, dynSymNameMapping);
    }
    else {
       createRelocationSections(obj, object->getDynRelocs(), true, dynSymNameMapping);
       createRelocationSections(obj, object->getPLTRelocs(), false, dynSymNameMapping);
    }

    //add .dynamic section
    if(dynsecSize)
      obj->addRegion(0, dynsecData, dynsecSize*sizeof(Elf64_Dyn), ".dynamic", Region::RT_DYNAMIC, true);
  }

  if(!obj->getAllNewRegions(newSecs))
    log_elferror(err_func_, "No new sections to add");

  return true;
}

void emitElf64::createRelocationSections(Symtab *obj, std::vector<relocationEntry> &relocation_table, bool isDynRelocs, dyn_hash_map<std::string, unsigned long> &dynSymNameMapping) {
  vector<relocationEntry> newRels;
  if(isDynRelocs && newSecs.size()) {
    std::vector<Region *>::iterator i;
    for (i = newSecs.begin(); i != newSecs.end(); i++) {
      std::copy((*i)->getRelocations().begin(),
        (*i)->getRelocations().end(),
        std::back_inserter(newRels));
    }
  }

   unsigned i,j,k,l,m;
    
   Elf64_Rel *rels = (Elf64_Rel *)malloc(sizeof(Elf64_Rel) * (relocation_table.size()+newRels.size()));
   Elf64_Rela *relas = (Elf64_Rela *)malloc(sizeof(Elf64_Rela) * (relocation_table.size()+newRels.size()));
   j=0; k=0; l=0; m=0;
   //reconstruct .rel
   for(i=0; i<relocation_table.size(); i++) 
   {

     if( library_adjust ) {
         // If we are shifting the library down in memory, we need to update
         // any relative offsets in the library. These relative offsets are 
         // found via relocations

         // XXX ...ignore the return value
         emitElfUtils::updateRelocation(obj, relocation_table[i], library_adjust);
     }

      if ((object->getRelType()  == Region::RT_REL) && (relocation_table[i].regionType() == Region::RT_REL)) {
         rels[j].r_offset = relocation_table[i].rel_addr() + library_adjust;
         unsigned long sym_offset = 0;
         std::string sym_name = relocation_table[i].name();
         if (!sym_name.empty()) {
            dyn_hash_map<string, unsigned long>::iterator j = dynSymNameMapping.find(sym_name);
            if (j != dynSymNameMapping.end())
               sym_offset = j->second;
            else {
               Symbol *sym = relocation_table[i].getDynSym();
               if (sym)
                  sym_offset = sym->getIndex();
            }
         }

         if (sym_offset) {
            rels[j].r_info = ELF64_R_INFO(sym_offset, relocation_table[i].getRelType());
         } else {
            rels[j].r_info = ELF64_R_INFO((unsigned long)STN_UNDEF, relocation_table[i].getRelType());
         }
         j++;
      } else if((object->getRelType()  == Region::RT_RELA) && (relocation_table[i].regionType() == Region::RT_RELA)){
         relas[k].r_offset = relocation_table[i].rel_addr() + library_adjust;
         relas[k].r_addend = relocation_table[i].addend();
         //if (relas[k].r_addend)
         //   relas[k].r_addend += library_adjust;
         unsigned long sym_offset = 0;
         std::string sym_name = relocation_table[i].name();
         if (!sym_name.empty()) {
            dyn_hash_map<string, unsigned long>::iterator j = dynSymNameMapping.find(sym_name);
            if (j != dynSymNameMapping.end())
               sym_offset = j->second;
            else {
               Symbol *sym = relocation_table[i].getDynSym();
               if (sym) {
                  j = dynSymNameMapping.find(sym->getMangledName());
                  if (j != dynSymNameMapping.end())
                     sym_offset = j->second;
               }
            }
         }
         if (sym_offset) {
            relas[k].r_info = ELF64_R_INFO(sym_offset, relocation_table[i].getRelType());
         } else {
            relas[k].r_info = ELF64_R_INFO((unsigned long)STN_UNDEF, relocation_table[i].getRelType());
         }
         k++;
      }
   }
   for(i=0;i<newRels.size();i++) 
   { 
     if ((object->getRelType()  == Region::RT_REL) && (newRels[i].regionType() == Region::RT_REL)) {
         rels[j].r_offset = newRels[i].rel_addr() + library_adjust;
         if(dynSymNameMapping.find(newRels[i].name()) != dynSymNameMapping.end()) {
#if defined(arch_x86)
            rels[j].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_386_GLOB_DAT);
#elif defined(arch_x86_64)
            rels[j].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_X86_64_GLOB_DAT);
#elif defined(arch_power)
        if (newRels[i].getDynSym() && (newRels[i].getDynSym()->getType() == Symbol::ST_FUNCTION))
          rels[j].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_PPC_JMP_SLOT);
        else
          rels[j].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_PPC_GLOB_DAT);
#endif
         } else {
#if defined(arch_x86)
            rels[j].r_info = ELF64_R_INFO(STN_UNDEF, R_386_GLOB_DAT);
#elif defined(arch_x86_64)
            rels[j].r_info = ELF64_R_INFO((unsigned long)STN_UNDEF, R_X86_64_GLOB_DAT);
#elif defined(arch_power)
            rels[j].r_info = ELF64_R_INFO(STN_UNDEF, R_PPC_GLOB_DAT);
#endif
         }
         j++;
     l++;
      } else if ((object->getRelType()  == Region::RT_RELA) && (newRels[i].regionType() == Region::RT_RELA)) {
         relas[k].r_offset = newRels[i].rel_addr() + library_adjust;
         relas[k].r_addend = newRels[i].addend();
         //if( relas[k].r_addend ) relas[k].r_addend += library_adjust;
         if(dynSymNameMapping.find(newRels[i].name()) != dynSymNameMapping.end()) {
#if defined(arch_x86)
            relas[k].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_386_GLOB_DAT);
#elif defined(arch_x86_64)
            relas[k].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_X86_64_GLOB_DAT);
#elif defined(arch_power)
        if (newRels[i].getDynSym() && (newRels[i].getDynSym()->getType() == Symbol::ST_FUNCTION))
          relas[k].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_PPC_JMP_SLOT);
        else
          relas[k].r_info = ELF64_R_INFO(dynSymNameMapping[newRels[i].name()], R_PPC_GLOB_DAT);
#endif
         } else {
#if defined(arch_x86)
            relas[k].r_info = ELF64_R_INFO(STN_UNDEF, R_386_GLOB_DAT);
#elif defined(arch_x86_64)
            relas[k].r_info = ELF64_R_INFO((unsigned long)STN_UNDEF, R_X86_64_GLOB_DAT);
#elif defined(arch_power)
            relas[k].r_info = ELF64_R_INFO(STN_UNDEF, R_PPC_GLOB_DAT);
#endif
         }
         k++;
     m++;
      }
   }

   dyn_hash_map<int, Region*> secTagRegionMapping = obj->getObject()->getTagRegionMapping();
   int reloc_size, old_reloc_size, dynamic_reloc_size;
   const char *new_name;
   Region::RegionType rtype;
   int dtype;
   int dsize_type;
   void *buffer = NULL;

   reloc_size = j*sizeof(Elf64_Rel)+k*sizeof(Elf64_Rela);
   if (!reloc_size) {
      return;
   }
   if (   isDynRelocs 
       && object->getRelType() == Region::RT_REL ) 
   {
      new_name = ".rel.dyn";
      dtype = DT_REL;
      rtype = Region::RT_REL;
      dsize_type = DT_RELSZ;
      buffer = rels;
   }
   if (   isDynRelocs
       && object->getRelType() == Region::RT_RELA ) 
   {
      new_name = ".rela.dyn";
      dtype = DT_RELA;
      rtype = Region::RT_RELA;
      dsize_type = DT_RELASZ;
      buffer = relas;
      updateDynamic(DT_RELAENT, sizeof(Elf64_Rela)); 
   }
   if (   !isDynRelocs 
       && object->getRelType() == Region::RT_REL ) 
   {
      new_name = ".rel.plt";
      dtype = DT_JMPREL;
      rtype = Region::RT_PLTREL;
      dsize_type = DT_PLTRELSZ;
      buffer = rels;
   }
   if (   !isDynRelocs 
       && object->getRelType() == Region::RT_RELA ) 
   {
      new_name = ".rela.plt";
      dtype = DT_JMPREL;
      rtype = Region::RT_PLTRELA;
      dsize_type = DT_PLTRELSZ;
      buffer = relas;
   }
if(dynamicSecData.find(dsize_type) != dynamicSecData.end())
   old_reloc_size =  dynamicSecData[dsize_type][0]->d_un.d_val;
else
   old_reloc_size = 0;
   dynamic_reloc_size = old_reloc_size+  l*sizeof(Elf64_Rel)+ m*sizeof(Elf64_Rela);
   string name;
   if (secTagRegionMapping.find(dtype) != secTagRegionMapping.end())
      name = secTagRegionMapping[dtype]->getRegionName();
   else
      name = std::string(new_name);
   obj->addRegion(0, buffer, reloc_size, name, rtype, true);
   updateDynamic(dsize_type, dynamic_reloc_size); 

}

void emitElf64::createSymbolVersions(Symtab *obj, Elf64_Half *&symVers, char*&verneedSecData, unsigned &verneedSecSize, char
*&verdefSecData, unsigned &verdefSecSize, unsigned &dynSymbolNamesLength, vector<string> &dynStrs){

   //Add all names to the new .dynstr section
   map<string, unsigned>::iterator iter = versionNames.begin();
   for(;iter!=versionNames.end();iter++){
      iter->second = dynSymbolNamesLength;
      dynStrs.push_back(iter->first);
      dynSymbolNamesLength+= iter->first.size()+1;
   }

   //reconstruct .gnu_version section
   symVers = (Elf64_Half *)malloc(versionSymTable.size() * sizeof(Elf64_Half));
   for(unsigned i=0; i<versionSymTable.size(); i++)
      symVers[i] = versionSymTable[i];

   //reconstruct .gnu.version_r section
   verneedSecSize = 0;
   map<string, map<string, unsigned> >::iterator it = verneedEntries.begin();
   for(; it != verneedEntries.end(); it++)
      verneedSecSize += sizeof(Elf64_Verneed) + sizeof(Elf64_Vernaux) * it->second.size();

   verneedSecData = (char *)malloc(verneedSecSize);
   unsigned curpos = 0;
   verneednum = 0;
   std::vector<std::string>::iterator dit;
   for(dit = unversionedNeededEntries.begin(); dit != unversionedNeededEntries.end(); dit++) {
      // account for any substitutions due to rewriting a shared lib
      std::string name = obj->getDynLibSubstitution(*dit);
      // no need for self-references
      if (!(obj->name() == name)) {
         versionNames[name] = dynSymbolNamesLength;
         dynStrs.push_back(name);
         dynSymbolNamesLength+= (name).size()+1;
         addDTNeeded(name);
      }
   }
   for(it = verneedEntries.begin(); it != verneedEntries.end(); it++){
      Elf64_Verneed *verneed = (Elf64_Verneed *)(void*)(verneedSecData+curpos);
      verneed->vn_version = 1;
      verneed->vn_cnt = it->second.size();
      verneed->vn_file = dynSymbolNamesLength;
      versionNames[it->first] = dynSymbolNamesLength;
      dynStrs.push_back(it->first);
      dynSymbolNamesLength+= it->first.size()+1;
      addDTNeeded(it->first);
      verneed->vn_aux = sizeof(Elf64_Verneed);
      verneed->vn_next = sizeof(Elf64_Verneed) + it->second.size()*sizeof(Elf64_Vernaux);
      if(curpos + verneed->vn_next == verneedSecSize)
         verneed->vn_next = 0;
      verneednum++;
      int i = 0;
      for(iter = it->second.begin(); iter!= it->second.end(); iter++){
         Elf64_Vernaux *vernaux = (Elf64_Vernaux *)(void*)(verneedSecData + curpos + verneed->vn_aux + i*sizeof(Elf64_Vernaux));
         vernaux->vna_hash = elfHash(iter->first.c_str());
         vernaux->vna_flags = 0;
         vernaux->vna_other = iter->second;
         vernaux->vna_name = versionNames[iter->first];
         if(i == verneed->vn_cnt-1)
            vernaux->vna_next = 0;
         else
            vernaux->vna_next = sizeof(Elf64_Vernaux);
         i++;
      }
      curpos += verneed->vn_next;
   }

   //reconstruct .gnu.version_d section
   verdefSecSize = 0;
   for(iter = verdefEntries.begin(); iter != verdefEntries.end(); iter++)
      verdefSecSize += sizeof(Elf64_Verdef) + sizeof(Elf64_Verdaux) * verdauxEntries[iter->second].size();

   verdefSecData = (char *)malloc(verdefSecSize);
   curpos = 0;
   verdefnum = 0;
   for(iter = verdefEntries.begin(); iter != verdefEntries.end(); iter++){
      Elf64_Verdef *verdef = (Elf64_Verdef *)(void*)(verdefSecData+curpos);
      verdef->vd_version = 1;
      verdef->vd_flags = 0;
      verdef->vd_ndx = iter->second;
      verdef->vd_cnt = verdauxEntries[iter->second].size();
      verdef->vd_hash = elfHash(iter->first.c_str());
      verdef->vd_aux = sizeof(Elf64_Verdef);
      verdef->vd_next = sizeof(Elf64_Verdef) + verdauxEntries[iter->second].size()*sizeof(Elf64_Verdaux);
      if(curpos + verdef->vd_next == verdefSecSize)
         verdef->vd_next = 0;
      verdefnum++;
      for(unsigned i = 0; i< verdauxEntries[iter->second].size(); i++){
         Elf64_Verdaux *verdaux = (Elf64_Verdaux *)(void*)(verdefSecData + curpos + verdef->vd_aux + i*sizeof(Elf64_Verdaux));
         verdaux->vda_name = versionNames[verdauxEntries[iter->second][0]];
         if((signed) i == verdef->vd_cnt-1)
            verdaux->vda_next = 0;
         else
            verdaux->vda_next = sizeof(Elf64_Verdaux);
      }
      curpos += verdef->vd_next;
   }
   return;
}

void emitElf64::createHashSection(Symtab *obj, Elf64_Word *&hashsecData, unsigned &hashsecSize, vector<Symbol *>&dynSymbols)
{

  /* Save the original hash table entries */
  std::vector<unsigned> originalHashEntries;
  unsigned dynsymSize = obj->getObject()->getDynsymSize();
  
  Elf_Scn *scn = NULL;
  Elf64_Shdr *shdr = NULL;
  for (unsigned scncount = 0; (scn = elf_nextscn(oldElf, scn)); scncount++) {
    shdr = elf64_getshdr(scn);
    if(obj->getObject()->getElfHashAddr() != 0 &&
       obj->getObject()->getElfHashAddr() == shdr->sh_addr){
      Elf_Data *hashData = elf_getdata(scn,NULL);
      Elf64_Word *oldHashSec = (Elf64_Word *) hashData->d_buf;
      unsigned original_nbuckets, original_nchains;
      original_nbuckets =  oldHashSec[0];
      original_nchains = oldHashSec[1];
      for (unsigned i = 0; i < original_nbuckets+original_nchains; i++) {
    if ( oldHashSec[2+i] != 0) {
        originalHashEntries.push_back( oldHashSec[2+i]);
        //printf(" ELF HASH pushing hash entry %d \n", oldHashSec[2+i] );
    }
      }
    }

    if(obj->getObject()->getGnuHashAddr() != 0 &&
       obj->getObject()->getGnuHashAddr() == shdr->sh_addr){
      Elf_Data *hashData = elf_getdata(scn,NULL);
      Elf64_Word *oldHashSec = (Elf64_Word *) hashData->d_buf;
      unsigned symndx = oldHashSec[1];
      if (dynsymSize != 0)
        for (unsigned i = symndx; i < dynsymSize ; i++) {
        originalHashEntries.push_back(i);
        //printf(" GNU HASH pushing hash entry %d \n", i);
    }
      }
  }

  vector<Symbol *>::iterator iter;
  dyn_hash_map<unsigned, unsigned> lastHash; // bucket number to symbol index
  unsigned nbuckets = (unsigned)dynSymbols.size()*2/3;
  if (nbuckets % 2 == 0)
    nbuckets--;
  if (nbuckets < 1)
    nbuckets = 1;
  unsigned nchains = (unsigned)dynSymbols.size();
  hashsecSize = 2 + nbuckets + nchains;
  hashsecData = (Elf64_Word *)malloc(hashsecSize*sizeof(Elf64_Word));
  unsigned i=0, key;
  for (i=0; i<hashsecSize; i++) {
    hashsecData[i] = STN_UNDEF;
  }
  hashsecData[0] = (Elf64_Word)nbuckets;
  hashsecData[1] = (Elf64_Word)nchains;
  i = 0;
  for (iter = dynSymbols.begin(); iter != dynSymbols.end(); iter++, i++) {
    if((*iter)->getMangledName().empty()) continue;
    unsigned index = (*iter)->getIndex();
    if ((find(originalHashEntries.begin(),originalHashEntries.end(),index) == originalHashEntries.end()) && 
    (index < obj->getObject()->getDynsymSize())) {
    continue;
    }
    key = elfHash((*iter)->getMangledName().c_str()) % nbuckets;
    if (lastHash.find(key) != lastHash.end()) {
      hashsecData[2+nbuckets+lastHash[key]] = i;
    }
    else {
      hashsecData[2+key] = i;
    }
    lastHash[key] = i;
    hashsecData[2+nbuckets+i] = STN_UNDEF;
  }
}

void emitElf64::createDynamicSection(void *dynData, unsigned size, Elf64_Dyn *&dynsecData, unsigned &dynsecSize, unsigned &dynSymbolNamesLength, std::vector<std::string> &dynStrs) {
  dynamicSecData.clear();
  Elf64_Dyn *dyns = (Elf64_Dyn *)dynData;
  unsigned count = size/sizeof(Elf64_Dyn);
  vector<string> &libs_rmd = object->libsRMd();
  dynsecSize = 2*(count + DT_NEEDEDEntries.size() + new_dynamic_entries.size());
  dynsecData = (Elf64_Dyn *)malloc(dynsecSize*sizeof(Elf64_Dyn));
  unsigned curpos = 0;
  string rpathstr;
  for(unsigned i = 0; i< DT_NEEDEDEntries.size(); i++){
    dynsecData[curpos].d_tag = DT_NEEDED;
    dynStrs.push_back(DT_NEEDEDEntries[i]);
    dynsecData[curpos].d_un.d_val = dynSymbolNamesLength;
    dynSymbolNamesLength += DT_NEEDEDEntries[i].size()+1;
    dynamicSecData[DT_NEEDED].push_back(dynsecData+curpos);
    curpos++;
  }
  for (unsigned i = 0; i<new_dynamic_entries.size(); i++) {
     long name = new_dynamic_entries[i].first;
     long value = new_dynamic_entries[i].second;
     dynsecData[curpos].d_tag = name;
     dynsecData[curpos].d_un.d_val = value;
     dynamicSecData[name].push_back(dynsecData+curpos);
     curpos++;
  }

  // There may be multiple HASH (ELF, GNU etc) sections in the original binary. We consolidate all of them into one.
  bool foundHashSection = false; 

  for(unsigned i = 0; i< count;i++){
    switch(dyns[i].d_tag){
    case DT_NULL:
      break;
    case 0x6ffffef5: // DT_GNU_HASH (not defined on all platforms)
      if (!foundHashSection) {
        dynsecData[curpos].d_tag = DT_HASH;
        dynsecData[curpos].d_un.d_ptr =dyns[i].d_un.d_ptr ;
        dynamicSecData[DT_HASH].push_back(dynsecData+curpos);
        curpos++;
        foundHashSection = true;
      }
      break;
    case DT_HASH: 
      if (!foundHashSection) {
        dynsecData[curpos].d_tag = dyns[i].d_tag;
        dynsecData[curpos].d_un.d_ptr =dyns[i].d_un.d_ptr ;
        dynamicSecData[dyns[i].d_tag].push_back(dynsecData+curpos);
        curpos++;
        foundHashSection = true;
      }
      break;
    case DT_NEEDED:
      rpathstr = &olddynStrData[dyns[i].d_un.d_val];
      if(find(DT_NEEDEDEntries.begin(), DT_NEEDEDEntries.end(), rpathstr) != DT_NEEDEDEntries.end()) {
         break;
      }
      if (find(libs_rmd.begin(), libs_rmd.end(), rpathstr) != libs_rmd.end())
         break;
      dynsecData[curpos].d_tag = dyns[i].d_tag;
      dynsecData[curpos].d_un.d_val = dynSymbolNamesLength;
      dynStrs.push_back(rpathstr);
      dynSymbolNamesLength += rpathstr.size() + 1;
      dynamicSecData[dyns[i].d_tag].push_back(dynsecData+curpos);
      curpos++;
      break;
    case DT_RPATH:
    case DT_RUNPATH:
      dynsecData[curpos].d_tag = dyns[i].d_tag;
      dynsecData[curpos].d_un.d_val = dynSymbolNamesLength;
      rpathstr = &olddynStrData[dyns[i].d_un.d_val];
      dynStrs.push_back(rpathstr);
      dynSymbolNamesLength += rpathstr.size() + 1;
      dynamicSecData[dyns[i].d_tag].push_back(dynsecData+curpos);
      curpos++;
      break;
    case DT_INIT:
    case DT_FINI:
    case DT_GNU_CONFLICT:
    case DT_JMPREL:
    case DT_PLTGOT:
       /**
        * List every dynamic entry that references an address and isn't already
        * updated here.  library_adjust will be a page size if
        * we're dealing with a library without a fixed load address.  We'll be shifting
        * the addresses of that library by a page.
        **/
       memcpy(dynsecData+curpos, dyns+i, sizeof(Elf64_Dyn));
       dynsecData[curpos].d_un.d_ptr += library_adjust;
       dynamicSecData[dyns[i].d_tag].push_back(dynsecData+curpos);
       curpos++;
       break;
    default:
      memcpy(dynsecData+curpos, dyns+i, sizeof(Elf64_Dyn));
      dynamicSecData[dyns[i].d_tag].push_back(dynsecData+curpos);
      curpos++;
      break;
    }
  }
        // Need to ensure that DT_REL and related fields added to .dynamic
        // The values of these fields will be set

        if( !object->hasReldyn() && !object->hasReladyn() ) {
            if( object->getRelType() == Region::RT_REL ) {
                new_dynamic_entries.push_back(make_pair(DT_REL,0));
                new_dynamic_entries.push_back(make_pair(DT_RELSZ,0));

  dynamicSecData[DT_REL].push_back(dynsecData+curpos);
  dynsecData[curpos].d_tag = DT_NULL;
  dynsecData[curpos].d_un.d_val = 0;
  curpos++;
  dynamicSecData[DT_RELSZ].push_back(dynsecData+curpos);
  dynsecData[curpos].d_tag = DT_NULL;
  dynsecData[curpos].d_un.d_val = 0;
  curpos++;
  dynamicSecData[DT_RELENT].push_back(dynsecData+curpos);
  dynsecData[curpos].d_tag = DT_NULL;
  dynsecData[curpos].d_un.d_val = 0;
  curpos++;

            }else if( object->getRelType() == Region::RT_RELA ) {

  dynamicSecData[DT_RELA].push_back(dynsecData+curpos);
  dynsecData[curpos].d_tag = DT_NULL;
  dynsecData[curpos].d_un.d_val = 0;
  curpos++;
  dynamicSecData[DT_RELASZ].push_back(dynsecData+curpos);
  dynsecData[curpos].d_tag = DT_NULL;
  dynsecData[curpos].d_un.d_val = 0;
  curpos++;
  dynamicSecData[DT_RELAENT].push_back(dynsecData+curpos);
  dynsecData[curpos].d_tag = DT_NULL;
  dynsecData[curpos].d_un.d_val = 0;
  curpos++;

            }
        } 


    dynsecData[curpos].d_tag = DT_NULL;
  dynsecData[curpos].d_un.d_val = 0;
  curpos++;
  dynsecSize = curpos+1;                            //assign size to the correct number of entries
}


void emitElf64::log_elferror(void (*err_func)(const char *), const char* msg) {
  const char* err = elf_errmsg(elf_errno());
  err = err ? err: "(bad elf error)";
  string str = string(err)+string(msg);
  err_func(str.c_str());
}

void emitElf64::addDTNeeded(string s)
{
   if (find(DT_NEEDEDEntries.begin(), DT_NEEDEDEntries.end(), s) != DT_NEEDEDEntries.end())
      return;
   vector<string> &libs_rmd = object->libsRMd();
   if (find(libs_rmd.begin(), libs_rmd.end(), s) != libs_rmd.end())
      return;
   DT_NEEDEDEntries.push_back(s);
}