xref: /frameworks/compile/mclinker/lib/LD/ELFReader.cpp

//===- ELFReader.cpp ------------------------------------------------------===//
//
//                     The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <mcld/LD/ELFReader.h>

#include <mcld/IRBuilder.h>
#include <mcld/Fragment/FillFragment.h>
#include <mcld/LD/EhFrame.h>
#include <mcld/LD/SectionData.h>
#include <mcld/Target/GNULDBackend.h>
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MsgHandling.h>
#include <mcld/Object/ObjectBuilder.h>

#include <cstring>

#include <llvm/ADT/StringRef.h>
#include <llvm/ADT/Twine.h>
#include <llvm/Support/ELF.h>
#include <llvm/Support/Host.h>

#include <iostream>

using namespace mcld;

//===----------------------------------------------------------------------===//
// ELFReader<32, true>
//===----------------------------------------------------------------------===//
/// constructor
ELFReader<32, true>::ELFReader(GNULDBackend& pBackend)
  : ELFReaderIF(pBackend) {
}

/// destructor
ELFReader<32, true>::~ELFReader()
{
}

/// isELF - is this a ELF file
bool ELFReader<32, true>::isELF(void* pELFHeader) const
{
  llvm::ELF::Elf32_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
  if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4))
    return true;
  return false;
}

/// readRegularSection - read a regular section and create fragments.
bool
ELFReader<32, true>::readRegularSection(Input& pInput, SectionData& pSD) const
{
  uint32_t offset = pInput.fileOffset() + pSD.getSection().offset();
  uint32_t size = pSD.getSection().size();

  Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size);
  ObjectBuilder::AppendFragment(*frag, pSD);
  return true;
}

/// readSymbols - read ELF symbols and create LDSymbol
bool ELFReader<32, true>::readSymbols(Input& pInput,
                                      IRBuilder& pBuilder,
                                      const MemoryRegion& pRegion,
                                      const char* pStrTab) const
{
  // get number of symbols
  size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf32_Sym);
  const llvm::ELF::Elf32_Sym* symtab =
                 reinterpret_cast<const llvm::ELF::Elf32_Sym*>(pRegion.start());

  uint32_t st_name  = 0x0;
  uint32_t st_value = 0x0;
  uint32_t st_size  = 0x0;
  uint8_t  st_info  = 0x0;
  uint8_t  st_other = 0x0;
  uint16_t st_shndx = 0x0;

  // skip the first NULL symbol
  pInput.context()->addSymbol(LDSymbol::Null());

  /// recording symbols added from DynObj to analyze weak alias
  std::vector<AliasInfo> potential_aliases;
  bool is_dyn_obj = (pInput.type()==Input::DynObj);
  for (size_t idx = 1; idx < entsize; ++idx) {
    st_info  = symtab[idx].st_info;
    st_other = symtab[idx].st_other;

    if (llvm::sys::isLittleEndianHost()) {
      st_name  = symtab[idx].st_name;
      st_value = symtab[idx].st_value;
      st_size  = symtab[idx].st_size;
      st_shndx = symtab[idx].st_shndx;
    }
    else {
      st_name  = mcld::bswap32(symtab[idx].st_name);
      st_value = mcld::bswap32(symtab[idx].st_value);
      st_size  = mcld::bswap32(symtab[idx].st_size);
      st_shndx = mcld::bswap16(symtab[idx].st_shndx);
    }

    // If the section should not be included, set the st_shndx SHN_UNDEF
    // - A section in interrelated groups are not included.
    if (pInput.type() == Input::Object &&
        st_shndx < llvm::ELF::SHN_LORESERVE &&
        st_shndx != llvm::ELF::SHN_UNDEF) {
      if (NULL == pInput.context()->getSection(st_shndx))
        st_shndx = llvm::ELF::SHN_UNDEF;
    }

    // get ld_type
    ResolveInfo::Type ld_type = getSymType(st_info, st_shndx);

    // get ld_desc
    ResolveInfo::Desc ld_desc = getSymDesc(st_shndx, pInput);

    // get ld_binding
    ResolveInfo::Binding ld_binding = getSymBinding((st_info >> 4), st_shndx, st_other);

    // get ld_value - ld_value must be section relative.
    uint64_t ld_value = getSymValue(st_value, st_shndx, pInput);

    // get ld_vis
    ResolveInfo::Visibility ld_vis = getSymVisibility(st_other);

    // get section
    LDSection* section = NULL;
    if (st_shndx < llvm::ELF::SHN_LORESERVE) // including ABS and COMMON
      section = pInput.context()->getSection(st_shndx);

    // get ld_name
    std::string ld_name;
    if (ResolveInfo::Section == ld_type) {
      // Section symbol's st_name is the section index.
      assert(NULL != section && "get a invalid section");
      ld_name = section->name();
    }
    else {
      ld_name = std::string(pStrTab + st_name);
    }

    LDSymbol *psym =
        pBuilder.AddSymbol(pInput,
                           ld_name,
                           ld_type,
                           ld_desc,
                           ld_binding,
                           st_size,
                           ld_value,
                           section, ld_vis);

    if ( is_dyn_obj
         && NULL!=psym
         && ResolveInfo::Undefined!=ld_desc
         && (ResolveInfo::Global==ld_binding ||
             ResolveInfo::Weak==ld_binding)
         && ResolveInfo::Object==ld_type ) {
      AliasInfo p;
      p.pt_alias = psym;
      p.ld_binding = ld_binding;
      p.ld_value = ld_value;
      potential_aliases.push_back(p);
    }

  } // end of for loop

  // analyze weak alias
  // FIXME: it is better to let IRBuilder handle alias anlysis.
  //        1. eliminate code duplication
  //        2. easy to know if a symbol is from .so
  //           (so that it may be a potential alias)
  if ( is_dyn_obj ) {
    // sort symbols by symbol value and then weak before strong
    std::sort( potential_aliases.begin(), potential_aliases.end(), less);

    // for each weak symbol, find out all its aliases, and
    // then link them as a circular list in Module
    std::vector<AliasInfo>::iterator sym_it, sym_e;
    sym_e = potential_aliases.end();
    for (sym_it = potential_aliases.begin(); sym_it!=sym_e; ++sym_it) {
      if (ResolveInfo::Weak!=sym_it->ld_binding)
        continue;

      Module& pModule = pBuilder.getModule();
      std::vector<AliasInfo>::iterator alias_it = sym_it+1;
      while(alias_it!=sym_e) {
        if ( sym_it->ld_value != alias_it->ld_value )
          break;

        if (sym_it+1==alias_it)
          pModule.CreateAliasList(*sym_it->pt_alias->resolveInfo());
        pModule.addAlias(*alias_it->pt_alias->resolveInfo());
        ++alias_it;
      }

      sym_it = alias_it-1;
    }// end of for loop
  }

  return true;
}

//===----------------------------------------------------------------------===//
// ELFReader::read relocations - read ELF rela and rel, and create Relocation
//===----------------------------------------------------------------------===//
/// ELFReader::readRela - read ELF rela and create Relocation
bool ELFReader<32, true>::readRela(Input& pInput,
                                   LDSection& pSection,
                                   const MemoryRegion& pRegion) const
{
  // get the number of rela
  size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rela);
  const llvm::ELF::Elf32_Rela* relaTab =
                reinterpret_cast<const llvm::ELF::Elf32_Rela*>(pRegion.start());

  for (size_t idx=0; idx < entsize; ++idx) {
    uint32_t r_offset = 0x0;
    uint32_t r_info   = 0x0;
    int32_t  r_addend = 0;
    if (llvm::sys::isLittleEndianHost()) {
      r_offset = relaTab[idx].r_offset;
      r_info   = relaTab[idx].r_info;
      r_addend = relaTab[idx].r_addend;
    }
    else {
      r_offset = mcld::bswap32(relaTab[idx].r_offset);
      r_info   = mcld::bswap32(relaTab[idx].r_info);
      r_addend = mcld::bswap32(relaTab[idx].r_addend);
    }

    uint8_t  r_type = static_cast<unsigned char>(r_info);
    uint32_t r_sym  = (r_info >> 8);
    LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    if (NULL == symbol) {
      fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    }

    IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset, r_addend);
  } // end of for
  return true;
}

/// readRel - read ELF rel and create Relocation
bool ELFReader<32, true>::readRel(Input& pInput,
                                  LDSection& pSection,
                                  const MemoryRegion& pRegion) const
{
  // get the number of rel
  size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rel);
  const llvm::ELF::Elf32_Rel* relTab =
                 reinterpret_cast<const llvm::ELF::Elf32_Rel*>(pRegion.start());

  for (size_t idx=0; idx < entsize; ++idx) {
    uint32_t r_offset = 0x0;
    uint32_t r_info   = 0x0;
    if (llvm::sys::isLittleEndianHost()) {
      r_offset = relTab[idx].r_offset;
      r_info   = relTab[idx].r_info;
    }
    else {
      r_offset = mcld::bswap32(relTab[idx].r_offset);
      r_info   = mcld::bswap32(relTab[idx].r_info);
    }

    uint8_t  r_type = static_cast<unsigned char>(r_info);
    uint32_t r_sym  = (r_info >> 8);

    LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    if (NULL == symbol) {
      fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    }

    IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset);
  } // end of for
  return true;
}

/// isMyEndian - is this ELF file in the same endian to me?
bool ELFReader<32, true>::isMyEndian(void* pELFHeader) const
{
  llvm::ELF::Elf32_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);

  return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB);
}

/// isMyMachine - is this ELF file generated for the same machine.
bool ELFReader<32, true>::isMyMachine(void* pELFHeader) const
{
  llvm::ELF::Elf32_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);

  if (llvm::sys::isLittleEndianHost())
    return (hdr->e_machine == target().getInfo().machine());
  return (mcld::bswap16(hdr->e_machine) == target().getInfo().machine());
}

/// fileType - return the file type
Input::Type ELFReader<32, true>::fileType(void* pELFHeader) const
{
  llvm::ELF::Elf32_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
  uint32_t type = 0x0;
  if (llvm::sys::isLittleEndianHost())
    type = hdr->e_type;
  else
    type = mcld::bswap16(hdr->e_type);

  switch(type) {
  case llvm::ELF::ET_REL:
    return Input::Object;
  case llvm::ELF::ET_EXEC:
    return Input::Exec;
  case llvm::ELF::ET_DYN:
    return Input::DynObj;
  case llvm::ELF::ET_CORE:
    return Input::CoreFile;
  case llvm::ELF::ET_NONE:
  default:
    return Input::Unknown;
  }
}

/// readSectionHeaders - read ELF section header table and create LDSections
bool
ELFReader<32, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const
{
  llvm::ELF::Elf32_Ehdr* ehdr =
                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);

  uint32_t shoff     = 0x0;
  uint16_t shentsize = 0x0;
  uint32_t shnum     = 0x0;
  uint32_t shstrtab  = 0x0;

  if (llvm::sys::isLittleEndianHost()) {
    shoff     = ehdr->e_shoff;
    shentsize = ehdr->e_shentsize;
    shnum     = ehdr->e_shnum;
    shstrtab  = ehdr->e_shstrndx;
  }
  else {
    shoff     = mcld::bswap32(ehdr->e_shoff);
    shentsize = mcld::bswap16(ehdr->e_shentsize);
    shnum     = mcld::bswap16(ehdr->e_shnum);
    shstrtab  = mcld::bswap16(ehdr->e_shstrndx);
  }

  // If the file has no section header table, e_shoff holds zero.
  if (0x0 == shoff)
    return true;

  llvm::ELF::Elf32_Shdr *shdr = NULL;
  MemoryRegion* shdr_region = NULL;
  uint32_t sh_name      = 0x0;
  uint32_t sh_type      = 0x0;
  uint32_t sh_flags     = 0x0;
  uint32_t sh_offset    = 0x0;
  uint32_t sh_size      = 0x0;
  uint32_t sh_link      = 0x0;
  uint32_t sh_info      = 0x0;
  uint32_t sh_addralign = 0x0;

  // if shnum and shstrtab overflow, the actual values are in the 1st shdr
  if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) {
    shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                            shentsize);
    shdr = reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start());

    if (llvm::sys::isLittleEndianHost()) {
      sh_size = shdr->sh_size;
      sh_link = shdr->sh_link;
    }
    else {
      sh_size = mcld::bswap32(shdr->sh_size);
      sh_link = mcld::bswap32(shdr->sh_link);
    }
    pInput.memArea()->release(shdr_region);

    if (shnum == llvm::ELF::SHN_UNDEF)
      shnum = sh_size;
    if (shstrtab == llvm::ELF::SHN_XINDEX)
      shstrtab = sh_link;

    shoff += shentsize;
  }

  shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                          shnum * shentsize);
  llvm::ELF::Elf32_Shdr * shdrTab =
    reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start());

  // get .shstrtab first
  shdr = &shdrTab[shstrtab];
  if (llvm::sys::isLittleEndianHost()) {
    sh_offset = shdr->sh_offset;
    sh_size   = shdr->sh_size;
  }
  else {
    sh_offset = mcld::bswap32(shdr->sh_offset);
    sh_size   = mcld::bswap32(shdr->sh_size);
  }

  MemoryRegion* sect_name_region = pInput.memArea()->request(
                                      pInput.fileOffset() + sh_offset, sh_size);
  const char* sect_name =
                       reinterpret_cast<const char*>(sect_name_region->start());

  LinkInfoList link_info_list;

  // create all LDSections, including first NULL section.
  for (size_t idx = 0; idx < shnum; ++idx) {
    if (llvm::sys::isLittleEndianHost()) {
      sh_name      = shdrTab[idx].sh_name;
      sh_type      = shdrTab[idx].sh_type;
      sh_flags     = shdrTab[idx].sh_flags;
      sh_offset    = shdrTab[idx].sh_offset;
      sh_size      = shdrTab[idx].sh_size;
      sh_link      = shdrTab[idx].sh_link;
      sh_info      = shdrTab[idx].sh_info;
      sh_addralign = shdrTab[idx].sh_addralign;
    }
    else {
      sh_name      = mcld::bswap32(shdrTab[idx].sh_name);
      sh_type      = mcld::bswap32(shdrTab[idx].sh_type);
      sh_flags     = mcld::bswap32(shdrTab[idx].sh_flags);
      sh_offset    = mcld::bswap32(shdrTab[idx].sh_offset);
      sh_size      = mcld::bswap32(shdrTab[idx].sh_size);
      sh_link      = mcld::bswap32(shdrTab[idx].sh_link);
      sh_info      = mcld::bswap32(shdrTab[idx].sh_info);
      sh_addralign = mcld::bswap32(shdrTab[idx].sh_addralign);
    }

    LDSection* section = IRBuilder::CreateELFHeader(pInput,
                                                    sect_name+sh_name,
                                                    sh_type,
                                                    sh_flags,
                                                    sh_addralign);
    section->setSize(sh_size);
    section->setOffset(sh_offset);
    section->setInfo(sh_info);

    if (sh_link != 0x0 || sh_info != 0x0) {
      LinkInfo link_info = { section, sh_link, sh_info };
      link_info_list.push_back(link_info);
    }
  } // end of for

  // set up InfoLink
  LinkInfoList::iterator info, infoEnd = link_info_list.end();
  for (info = link_info_list.begin(); info != infoEnd; ++info) {
    if (LDFileFormat::NamePool == info->section->kind() ||
        LDFileFormat::Group == info->section->kind() ||
        LDFileFormat::Note == info->section->kind()) {
      info->section->setLink(pInput.context()->getSection(info->sh_link));
      continue;
    }
    if (LDFileFormat::Relocation == info->section->kind()) {
      info->section->setLink(pInput.context()->getSection(info->sh_info));
      continue;
    }
  }

  pInput.memArea()->release(shdr_region);
  pInput.memArea()->release(sect_name_region);

  return true;
}

/// readSignature - read a symbol from the given Input and index in symtab
/// This is used to get the signature of a group section.
ResolveInfo* ELFReader<32, true>::readSignature(Input& pInput,
                                                LDSection& pSymTab,
                                                uint32_t pSymIdx) const
{
  LDSection* symtab = &pSymTab;
  LDSection* strtab = symtab->getLink();
  assert(NULL != symtab && NULL != strtab);

  uint32_t offset = pInput.fileOffset() + symtab->offset() +
                      sizeof(llvm::ELF::Elf32_Sym) * pSymIdx;
  MemoryRegion* symbol_region =
                pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf32_Sym));
  llvm::ELF::Elf32_Sym* entry =
                reinterpret_cast<llvm::ELF::Elf32_Sym*>(symbol_region->start());

  uint32_t st_name  = 0x0;
  uint8_t  st_info  = 0x0;
  uint8_t  st_other = 0x0;
  uint16_t st_shndx = 0x0;
  st_info  = entry->st_info;
  st_other = entry->st_other;
  if (llvm::sys::isLittleEndianHost()) {
    st_name  = entry->st_name;
    st_shndx = entry->st_shndx;
  }
  else {
    st_name  = mcld::bswap32(entry->st_name);
    st_shndx = mcld::bswap16(entry->st_shndx);
  }

  MemoryRegion* strtab_region = pInput.memArea()->request(
                       pInput.fileOffset() + strtab->offset(), strtab->size());

  // get ld_name
  llvm::StringRef ld_name(
                    reinterpret_cast<char*>(strtab_region->start() + st_name));

  ResolveInfo* result = ResolveInfo::Create(ld_name);
  result->setSource(pInput.type() == Input::DynObj);
  result->setType(static_cast<ResolveInfo::Type>(st_info & 0xF));
  result->setDesc(getSymDesc(st_shndx, pInput));
  result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other));
  result->setVisibility(getSymVisibility(st_other));

  // release regions
  pInput.memArea()->release(symbol_region);
  pInput.memArea()->release(strtab_region);

  return result;
}

/// readDynamic - read ELF .dynamic in input dynobj
bool ELFReader<32, true>::readDynamic(Input& pInput) const
{
  assert(pInput.type() == Input::DynObj);
  const LDSection* dynamic_sect = pInput.context()->getSection(".dynamic");
  if (NULL == dynamic_sect) {
    fatal(diag::err_cannot_read_section) << ".dynamic";
  }
  const LDSection* dynstr_sect = dynamic_sect->getLink();
  if (NULL == dynstr_sect) {
    fatal(diag::err_cannot_read_section) << ".dynstr";
  }

  MemoryRegion* dynamic_region = pInput.memArea()->request(
           pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());

  MemoryRegion* dynstr_region = pInput.memArea()->request(
             pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());

  assert(NULL != dynamic_region && NULL != dynstr_region);

  const llvm::ELF::Elf32_Dyn* dynamic =
    (llvm::ELF::Elf32_Dyn*) dynamic_region->start();
  const char* dynstr = (const char*) dynstr_region->start();
  bool hasSOName = false;
  size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf32_Dyn);

  for (size_t idx = 0; idx < numOfEntries; ++idx) {

    llvm::ELF::Elf32_Sword d_tag = 0x0;
    llvm::ELF::Elf32_Word d_val = 0x0;

    if (llvm::sys::isLittleEndianHost()) {
      d_tag = dynamic[idx].d_tag;
      d_val = dynamic[idx].d_un.d_val;
    } else {
      d_tag = mcld::bswap32(dynamic[idx].d_tag);
      d_val = mcld::bswap32(dynamic[idx].d_un.d_val);
    }

    switch (d_tag) {
      case llvm::ELF::DT_SONAME:
        assert(d_val < dynstr_sect->size());
        pInput.setName(sys::fs::Path(dynstr + d_val).filename().native());
        hasSOName = true;
        break;
      case llvm::ELF::DT_NEEDED:
        // TODO:
        break;
      case llvm::ELF::DT_NULL:
      default:
        break;
    }
  }

  // if there is no SONAME in .dynamic, then set it from input path
  if (!hasSOName)
    pInput.setName(pInput.path().filename().native());

  pInput.memArea()->release(dynamic_region);
  pInput.memArea()->release(dynstr_region);
  return true;
}

//===----------------------------------------------------------------------===//
// ELFReader<64, true>
//===----------------------------------------------------------------------===//
/// constructor
ELFReader<64, true>::ELFReader(GNULDBackend& pBackend)
  : ELFReaderIF(pBackend) {
}

/// destructor
ELFReader<64, true>::~ELFReader()
{
}

/// isELF - is this a ELF file
bool ELFReader<64, true>::isELF(void* pELFHeader) const
{
  llvm::ELF::Elf64_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
  if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4))
    return true;
  return false;
}

/// readRegularSection - read a regular section and create fragments.
bool
ELFReader<64, true>::readRegularSection(Input& pInput, SectionData& pSD) const
{
  uint64_t offset = pInput.fileOffset() + pSD.getSection().offset();
  uint64_t size = pSD.getSection().size();

  Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size);
  ObjectBuilder::AppendFragment(*frag, pSD);
  return true;
}

/// readSymbols - read ELF symbols and create LDSymbol
bool ELFReader<64, true>::readSymbols(Input& pInput,
                                      IRBuilder& pBuilder,
                                      const MemoryRegion& pRegion,
                                      const char* pStrTab) const
{
  // get number of symbols
  size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf64_Sym);
  const llvm::ELF::Elf64_Sym* symtab =
                 reinterpret_cast<const llvm::ELF::Elf64_Sym*>(pRegion.start());

  uint32_t st_name  = 0x0;
  uint64_t st_value = 0x0;
  uint64_t st_size  = 0x0;
  uint8_t  st_info  = 0x0;
  uint8_t  st_other = 0x0;
  uint16_t st_shndx = 0x0;

  // skip the first NULL symbol
  pInput.context()->addSymbol(LDSymbol::Null());

  /// recording symbols added from DynObj to analyze weak alias
  std::vector<AliasInfo> potential_aliases;
  bool is_dyn_obj = (pInput.type()==Input::DynObj);
  for (size_t idx = 1; idx < entsize; ++idx) {
    st_info  = symtab[idx].st_info;
    st_other = symtab[idx].st_other;

    if (llvm::sys::isLittleEndianHost()) {
      st_name  = symtab[idx].st_name;
      st_value = symtab[idx].st_value;
      st_size  = symtab[idx].st_size;
      st_shndx = symtab[idx].st_shndx;
    }
    else {
      st_name  = mcld::bswap32(symtab[idx].st_name);
      st_value = mcld::bswap64(symtab[idx].st_value);
      st_size  = mcld::bswap64(symtab[idx].st_size);
      st_shndx = mcld::bswap16(symtab[idx].st_shndx);
    }

    // If the section should not be included, set the st_shndx SHN_UNDEF
    // - A section in interrelated groups are not included.
    if (pInput.type() == Input::Object &&
        st_shndx < llvm::ELF::SHN_LORESERVE &&
        st_shndx != llvm::ELF::SHN_UNDEF) {
      if (NULL == pInput.context()->getSection(st_shndx))
        st_shndx = llvm::ELF::SHN_UNDEF;
    }

    // get ld_type
    ResolveInfo::Type ld_type = getSymType(st_info, st_shndx);

    // get ld_desc
    ResolveInfo::Desc ld_desc = getSymDesc(st_shndx, pInput);

    // get ld_binding
    ResolveInfo::Binding ld_binding = getSymBinding((st_info >> 4), st_shndx, st_other);

    // get ld_value - ld_value must be section relative.
    uint64_t ld_value = getSymValue(st_value, st_shndx, pInput);

    // get ld_vis
    ResolveInfo::Visibility ld_vis = getSymVisibility(st_other);

    // get section
    LDSection* section = NULL;
    if (st_shndx < llvm::ELF::SHN_LORESERVE) // including ABS and COMMON
      section = pInput.context()->getSection(st_shndx);

    // get ld_name
    std::string ld_name;
    if (ResolveInfo::Section == ld_type) {
      // Section symbol's st_name is the section index.
      assert(NULL != section && "get a invalid section");
      ld_name = section->name();
    }
    else {
      ld_name = std::string(pStrTab + st_name);
    }

    LDSymbol *psym =
            pBuilder.AddSymbol(pInput,
                               ld_name,
                               ld_type,
                               ld_desc,
                               ld_binding,
                               st_size,
                               ld_value,
                               section, ld_vis);

    if ( is_dyn_obj
         && NULL!=psym
         && ResolveInfo::Undefined!=ld_desc
         && (ResolveInfo::Global==ld_binding ||
             ResolveInfo::Weak==ld_binding)
         && ResolveInfo::Object==ld_type ) {
      AliasInfo p;
      p.pt_alias = psym;
      p.ld_binding = ld_binding;
      p.ld_value = ld_value;
      potential_aliases.push_back(p);
    }

  } // end of for loop

  // analyze weak alias here
  if ( is_dyn_obj ) {
    // sort symbols by symbol value and then weak before strong
    std::sort( potential_aliases.begin(), potential_aliases.end(), less);

    // for each weak symbol, find out all its aliases, and
    // then link them as a circular list in Module
    std::vector<AliasInfo>::iterator sym_it, sym_e;
    sym_e = potential_aliases.end();
    for (sym_it = potential_aliases.begin(); sym_it!=sym_e; ++sym_it) {
      if (ResolveInfo::Weak!=sym_it->ld_binding)
        continue;

      Module& pModule = pBuilder.getModule();
      std::vector<AliasInfo>::iterator alias_it = sym_it+1;
      while(alias_it!=sym_e) {
        if ( sym_it->ld_value != alias_it->ld_value )
          break;

        if (sym_it+1==alias_it)
          pModule.CreateAliasList(*sym_it->pt_alias->resolveInfo());
        pModule.addAlias(*alias_it->pt_alias->resolveInfo());
        ++alias_it;
      }

      sym_it = alias_it-1;
    }// end of for loop
  }
  return true;
}

//===----------------------------------------------------------------------===//
// ELFReader::read relocations - read ELF rela and rel, and create Relocation
//===----------------------------------------------------------------------===//
/// ELFReader::readRela - read ELF rela and create Relocation
bool ELFReader<64, true>::readRela(Input& pInput,
                                   LDSection& pSection,
                                   const MemoryRegion& pRegion) const
{
  // get the number of rela
  size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rela);
  const llvm::ELF::Elf64_Rela* relaTab =
                reinterpret_cast<const llvm::ELF::Elf64_Rela*>(pRegion.start());

  for (size_t idx=0; idx < entsize; ++idx) {
    uint64_t r_offset = 0x0;
    uint64_t r_info   = 0x0;
    int64_t  r_addend = 0;
    if (llvm::sys::isLittleEndianHost()) {
      r_offset = relaTab[idx].r_offset;
      r_info   = relaTab[idx].r_info;
      r_addend = relaTab[idx].r_addend;
    }
    else {
      r_offset = mcld::bswap64(relaTab[idx].r_offset);
      r_info   = mcld::bswap64(relaTab[idx].r_info);
      r_addend = mcld::bswap64(relaTab[idx].r_addend);
    }

    uint32_t  r_type = static_cast<uint32_t>(r_info);
    uint32_t r_sym  = (r_info >> 32);
    LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    if (NULL == symbol) {
      fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    }

    IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset, r_addend);
  } // end of for
  return true;
}

/// readRel - read ELF rel and create Relocation
bool ELFReader<64, true>::readRel(Input& pInput,
                                  LDSection& pSection,
                                  const MemoryRegion& pRegion) const
{
  // get the number of rel
  size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rel);
  const llvm::ELF::Elf64_Rel* relTab =
                 reinterpret_cast<const llvm::ELF::Elf64_Rel*>(pRegion.start());

  for (size_t idx=0; idx < entsize; ++idx) {
    uint64_t r_offset = 0x0;
    uint64_t r_info   = 0x0;
    if (llvm::sys::isLittleEndianHost()) {
      r_offset = relTab[idx].r_offset;
      r_info   = relTab[idx].r_info;
    }
    else {
      r_offset = mcld::bswap64(relTab[idx].r_offset);
      r_info   = mcld::bswap64(relTab[idx].r_info);
    }

    uint32_t  r_type = static_cast<uint32_t>(r_info);
    uint32_t r_sym  = (r_info >> 32);

    LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    if (NULL == symbol) {
      fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    }

    IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset);
  } // end of for
  return true;
}

/// isMyEndian - is this ELF file in the same endian to me?
bool ELFReader<64, true>::isMyEndian(void* pELFHeader) const
{
  llvm::ELF::Elf64_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);

  return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB);
}

/// isMyMachine - is this ELF file generated for the same machine.
bool ELFReader<64, true>::isMyMachine(void* pELFHeader) const
{
  llvm::ELF::Elf64_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);

  if (llvm::sys::isLittleEndianHost())
    return (hdr->e_machine == target().getInfo().machine());
  return (mcld::bswap16(hdr->e_machine) == target().getInfo().machine());
}

/// fileType - return the file type
Input::Type ELFReader<64, true>::fileType(void* pELFHeader) const
{
  llvm::ELF::Elf64_Ehdr* hdr =
                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
  uint32_t type = 0x0;
  if (llvm::sys::isLittleEndianHost())
    type = hdr->e_type;
  else
    type = mcld::bswap16(hdr->e_type);

  switch(type) {
  case llvm::ELF::ET_REL:
    return Input::Object;
  case llvm::ELF::ET_EXEC:
    return Input::Exec;
  case llvm::ELF::ET_DYN:
    return Input::DynObj;
  case llvm::ELF::ET_CORE:
    return Input::CoreFile;
  case llvm::ELF::ET_NONE:
  default:
    return Input::Unknown;
  }
}

/// readSectionHeaders - read ELF section header table and create LDSections
bool
ELFReader<64, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const
{
  llvm::ELF::Elf64_Ehdr* ehdr =
                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);

  uint64_t shoff     = 0x0;
  uint16_t shentsize = 0x0;
  uint32_t shnum     = 0x0;
  uint32_t shstrtab  = 0x0;

  if (llvm::sys::isLittleEndianHost()) {
    shoff     = ehdr->e_shoff;
    shentsize = ehdr->e_shentsize;
    shnum     = ehdr->e_shnum;
    shstrtab  = ehdr->e_shstrndx;
  }
  else {
    shoff     = mcld::bswap64(ehdr->e_shoff);
    shentsize = mcld::bswap16(ehdr->e_shentsize);
    shnum     = mcld::bswap16(ehdr->e_shnum);
    shstrtab  = mcld::bswap16(ehdr->e_shstrndx);
  }

  // If the file has no section header table, e_shoff holds zero.
  if (0x0 == shoff)
    return true;

  llvm::ELF::Elf64_Shdr *shdr = NULL;
  MemoryRegion* shdr_region = NULL;
  uint32_t sh_name      = 0x0;
  uint32_t sh_type      = 0x0;
  uint64_t sh_flags     = 0x0;
  uint64_t sh_offset    = 0x0;
  uint64_t sh_size      = 0x0;
  uint32_t sh_link      = 0x0;
  uint32_t sh_info      = 0x0;
  uint64_t sh_addralign = 0x0;

  // if shnum and shstrtab overflow, the actual values are in the 1st shdr
  if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) {
    shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                            shentsize);
    shdr = reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start());

    if (llvm::sys::isLittleEndianHost()) {
      sh_size = shdr->sh_size;
      sh_link = shdr->sh_link;
    }
    else {
      sh_size = mcld::bswap64(shdr->sh_size);
      sh_link = mcld::bswap32(shdr->sh_link);
    }
    pInput.memArea()->release(shdr_region);

    if (shnum == llvm::ELF::SHN_UNDEF)
      shnum = sh_size;
    if (shstrtab == llvm::ELF::SHN_XINDEX)
      shstrtab = sh_link;

    shoff += shentsize;
  }

  shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                          shnum * shentsize);
  llvm::ELF::Elf64_Shdr * shdrTab =
    reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start());

  // get .shstrtab first
  shdr = &shdrTab[shstrtab];
  if (llvm::sys::isLittleEndianHost()) {
    sh_offset = shdr->sh_offset;
    sh_size   = shdr->sh_size;
  }
  else {
    sh_offset = mcld::bswap64(shdr->sh_offset);
    sh_size   = mcld::bswap64(shdr->sh_size);
  }

  MemoryRegion* sect_name_region = pInput.memArea()->request(
                                      pInput.fileOffset() + sh_offset, sh_size);
  const char* sect_name =
                       reinterpret_cast<const char*>(sect_name_region->start());

  LinkInfoList link_info_list;

  // create all LDSections, including first NULL section.
  for (size_t idx = 0; idx < shnum; ++idx) {
    if (llvm::sys::isLittleEndianHost()) {
      sh_name      = shdrTab[idx].sh_name;
      sh_type      = shdrTab[idx].sh_type;
      sh_flags     = shdrTab[idx].sh_flags;
      sh_offset    = shdrTab[idx].sh_offset;
      sh_size      = shdrTab[idx].sh_size;
      sh_link      = shdrTab[idx].sh_link;
      sh_info      = shdrTab[idx].sh_info;
      sh_addralign = shdrTab[idx].sh_addralign;
    }
    else {
      sh_name      = mcld::bswap32(shdrTab[idx].sh_name);
      sh_type      = mcld::bswap32(shdrTab[idx].sh_type);
      sh_flags     = mcld::bswap64(shdrTab[idx].sh_flags);
      sh_offset    = mcld::bswap64(shdrTab[idx].sh_offset);
      sh_size      = mcld::bswap64(shdrTab[idx].sh_size);
      sh_link      = mcld::bswap32(shdrTab[idx].sh_link);
      sh_info      = mcld::bswap32(shdrTab[idx].sh_info);
      sh_addralign = mcld::bswap64(shdrTab[idx].sh_addralign);
    }

    LDSection* section = IRBuilder::CreateELFHeader(pInput,
                                                    sect_name+sh_name,
                                                    sh_type,
                                                    sh_flags,
                                                    sh_addralign);
    section->setSize(sh_size);
    section->setOffset(sh_offset);
    section->setInfo(sh_info);

    if (sh_link != 0x0 || sh_info != 0x0) {
      LinkInfo link_info = { section, sh_link, sh_info };
      link_info_list.push_back(link_info);
    }
  } // end of for

  // set up InfoLink
  LinkInfoList::iterator info, infoEnd = link_info_list.end();
  for (info = link_info_list.begin(); info != infoEnd; ++info) {
    if (LDFileFormat::NamePool == info->section->kind() ||
        LDFileFormat::Group == info->section->kind() ||
        LDFileFormat::Note == info->section->kind()) {
      info->section->setLink(pInput.context()->getSection(info->sh_link));
      continue;
    }
    if (LDFileFormat::Relocation == info->section->kind()) {
      info->section->setLink(pInput.context()->getSection(info->sh_info));
      continue;
    }
  }

  pInput.memArea()->release(shdr_region);
  pInput.memArea()->release(sect_name_region);

  return true;
}

/// readSignature - read a symbol from the given Input and index in symtab
/// This is used to get the signature of a group section.
ResolveInfo* ELFReader<64, true>::readSignature(Input& pInput,
                                                LDSection& pSymTab,
                                                uint32_t pSymIdx) const
{
  LDSection* symtab = &pSymTab;
  LDSection* strtab = symtab->getLink();
  assert(NULL != symtab && NULL != strtab);

  uint64_t offset = pInput.fileOffset() + symtab->offset() +
                      sizeof(llvm::ELF::Elf64_Sym) * pSymIdx;
  MemoryRegion* symbol_region =
                pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf64_Sym));
  llvm::ELF::Elf64_Sym* entry =
                reinterpret_cast<llvm::ELF::Elf64_Sym*>(symbol_region->start());

  uint32_t st_name  = 0x0;
  uint8_t  st_info  = 0x0;
  uint8_t  st_other = 0x0;
  uint16_t st_shndx = 0x0;
  st_info  = entry->st_info;
  st_other = entry->st_other;
  if (llvm::sys::isLittleEndianHost()) {
    st_name  = entry->st_name;
    st_shndx = entry->st_shndx;
  }
  else {
    st_name  = mcld::bswap32(entry->st_name);
    st_shndx = mcld::bswap16(entry->st_shndx);
  }

  MemoryRegion* strtab_region = pInput.memArea()->request(
                       pInput.fileOffset() + strtab->offset(), strtab->size());

  // get ld_name
  llvm::StringRef ld_name(
                    reinterpret_cast<char*>(strtab_region->start() + st_name));

  ResolveInfo* result = ResolveInfo::Create(ld_name);
  result->setSource(pInput.type() == Input::DynObj);
  result->setType(static_cast<ResolveInfo::Type>(st_info & 0xF));
  result->setDesc(getSymDesc(st_shndx, pInput));
  result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other));
  result->setVisibility(getSymVisibility(st_other));

  // release regions
  pInput.memArea()->release(symbol_region);
  pInput.memArea()->release(strtab_region);

  return result;
}

/// readDynamic - read ELF .dynamic in input dynobj
bool ELFReader<64, true>::readDynamic(Input& pInput) const
{
  assert(pInput.type() == Input::DynObj);
  const LDSection* dynamic_sect = pInput.context()->getSection(".dynamic");
  if (NULL == dynamic_sect) {
    fatal(diag::err_cannot_read_section) << ".dynamic";
  }
  const LDSection* dynstr_sect = dynamic_sect->getLink();
  if (NULL == dynstr_sect) {
    fatal(diag::err_cannot_read_section) << ".dynstr";
  }

  MemoryRegion* dynamic_region = pInput.memArea()->request(
           pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());

  MemoryRegion* dynstr_region = pInput.memArea()->request(
             pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());

  assert(NULL != dynamic_region && NULL != dynstr_region);

  const llvm::ELF::Elf64_Dyn* dynamic =
    (llvm::ELF::Elf64_Dyn*) dynamic_region->start();
  const char* dynstr = (const char*) dynstr_region->start();
  bool hasSOName = false;
  size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf64_Dyn);

  for (size_t idx = 0; idx < numOfEntries; ++idx) {

    llvm::ELF::Elf64_Sxword d_tag = 0x0;
    llvm::ELF::Elf64_Xword d_val = 0x0;

    if (llvm::sys::isLittleEndianHost()) {
      d_tag = dynamic[idx].d_tag;
      d_val = dynamic[idx].d_un.d_val;
    } else {
      d_tag = mcld::bswap64(dynamic[idx].d_tag);
      d_val = mcld::bswap64(dynamic[idx].d_un.d_val);
    }

    switch (d_tag) {
      case llvm::ELF::DT_SONAME:
        assert(d_val < dynstr_sect->size());
        pInput.setName(sys::fs::Path(dynstr + d_val).filename().native());
        hasSOName = true;
        break;
      case llvm::ELF::DT_NEEDED:
        // TODO:
        break;
      case llvm::ELF::DT_NULL:
      default:
        break;
    }
  }

  // if there is no SONAME in .dynamic, then set it from input path
  if (!hasSOName)
    pInput.setName(pInput.path().filename().native());

  pInput.memArea()->release(dynamic_region);
  pInput.memArea()->release(dynstr_region);
  return true;
}