Home | History | Annotate | Download | only in LD 
      1 //===- ELFReader.cpp ------------------------------------------------------===//
      2 //
      3 //                     The MCLinker Project
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 #include <mcld/LD/ELFReader.h>
     10 
     11 #include <mcld/IRBuilder.h>
     12 #include <mcld/Fragment/FillFragment.h>
     13 #include <mcld/LD/EhFrame.h>
     14 #include <mcld/LD/SectionData.h>
     15 #include <mcld/Target/GNULDBackend.h>
     16 #include <mcld/Support/MemoryRegion.h>
     17 #include <mcld/Support/MsgHandling.h>
     18 #include <mcld/Object/ObjectBuilder.h>
     19 
     20 #include <cstring>
     21 
     22 #include <llvm/ADT/StringRef.h>
     23 #include <llvm/ADT/Twine.h>
     24 #include <llvm/Support/ELF.h>
     25 #include <llvm/Support/Host.h>
     26 
     27 #include <iostream>
     28 
     29 using namespace mcld;
     30 
     31 //===----------------------------------------------------------------------===//
     32 // ELFReader<32, true>
     33 //===----------------------------------------------------------------------===//
     34 /// constructor
     35 ELFReader<32, true>::ELFReader(GNULDBackend& pBackend)
     36   : ELFReaderIF(pBackend) {
     37 }
     38 
     39 /// destructor
     40 ELFReader<32, true>::~ELFReader()
     41 {
     42 }
     43 
     44 /// isELF - is this a ELF file
     45 bool ELFReader<32, true>::isELF(void* pELFHeader) const
     46 {
     47   llvm::ELF::Elf32_Ehdr* hdr =
     48                           reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
     49   if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4))
     50     return true;
     51   return false;
     52 }
     53 
     54 /// readRegularSection - read a regular section and create fragments.
     55 bool
     56 ELFReader<32, true>::readRegularSection(Input& pInput, SectionData& pSD) const
     57 {
     58   uint32_t offset = pInput.fileOffset() + pSD.getSection().offset();
     59   uint32_t size = pSD.getSection().size();
     60 
     61   Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size);
     62   ObjectBuilder::AppendFragment(*frag, pSD);
     63   return true;
     64 }
     65 
     66 /// readSymbols - read ELF symbols and create LDSymbol
     67 bool ELFReader<32, true>::readSymbols(Input& pInput,
     68                                       IRBuilder& pBuilder,
     69                                       const MemoryRegion& pRegion,
     70                                       const char* pStrTab) const
     71 {
     72   // get number of symbols
     73   size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf32_Sym);
     74   const llvm::ELF::Elf32_Sym* symtab =
     75                  reinterpret_cast<const llvm::ELF::Elf32_Sym*>(pRegion.start());
     76 
     77   uint32_t st_name  = 0x0;
     78   uint32_t st_value = 0x0;
     79   uint32_t st_size  = 0x0;
     80   uint8_t  st_info  = 0x0;
     81   uint8_t  st_other = 0x0;
     82   uint16_t st_shndx = 0x0;
     83 
     84   // skip the first NULL symbol
     85   pInput.context()->addSymbol(LDSymbol::Null());
     86 
     87   /// recording symbols added from DynObj to analyze weak alias
     88   std::vector<AliasInfo> potential_aliases;
     89   bool is_dyn_obj = (pInput.type()==Input::DynObj);
     90   for (size_t idx = 1; idx < entsize; ++idx) {
     91     st_info  = symtab[idx].st_info;
     92     st_other = symtab[idx].st_other;
     93 
     94     if (llvm::sys::IsLittleEndianHost) {
     95       st_name  = symtab[idx].st_name;
     96       st_value = symtab[idx].st_value;
     97       st_size  = symtab[idx].st_size;
     98       st_shndx = symtab[idx].st_shndx;
     99     }
    100     else {
    101       st_name  = mcld::bswap32(symtab[idx].st_name);
    102       st_value = mcld::bswap32(symtab[idx].st_value);
    103       st_size  = mcld::bswap32(symtab[idx].st_size);
    104       st_shndx = mcld::bswap16(symtab[idx].st_shndx);
    105     }
    106 
    107     // If the section should not be included, set the st_shndx SHN_UNDEF
    108     // - A section in interrelated groups are not included.
    109     if (pInput.type() == Input::Object &&
    110         st_shndx < llvm::ELF::SHN_LORESERVE &&
    111         st_shndx != llvm::ELF::SHN_UNDEF) {
    112       if (NULL == pInput.context()->getSection(st_shndx))
    113         st_shndx = llvm::ELF::SHN_UNDEF;
    114     }
    115 
    116     // get ld_type
    117     ResolveInfo::Type ld_type = getSymType(st_info, st_shndx);
    118 
    119     // get ld_desc
    120     ResolveInfo::Desc ld_desc = getSymDesc(st_shndx, pInput);
    121 
    122     // get ld_binding
    123     ResolveInfo::Binding ld_binding = getSymBinding((st_info >> 4), st_shndx, st_other);
    124 
    125     // get ld_value - ld_value must be section relative.
    126     uint64_t ld_value = getSymValue(st_value, st_shndx, pInput);
    127 
    128     // get ld_vis
    129     ResolveInfo::Visibility ld_vis = getSymVisibility(st_other);
    130 
    131     // get section
    132     LDSection* section = NULL;
    133     if (st_shndx < llvm::ELF::SHN_LORESERVE) // including ABS and COMMON
    134       section = pInput.context()->getSection(st_shndx);
    135 
    136     // get ld_name
    137     std::string ld_name;
    138     if (ResolveInfo::Section == ld_type) {
    139       // Section symbol's st_name is the section index.
    140       assert(NULL != section && "get a invalid section");
    141       ld_name = section->name();
    142     }
    143     else {
    144       ld_name = std::string(pStrTab + st_name);
    145     }
    146 
    147     LDSymbol *psym =
    148         pBuilder.AddSymbol(pInput,
    149                            ld_name,
    150                            ld_type,
    151                            ld_desc,
    152                            ld_binding,
    153                            st_size,
    154                            ld_value,
    155                            section, ld_vis);
    156 
    157     if ( is_dyn_obj
    158          && NULL!=psym
    159          && ResolveInfo::Undefined!=ld_desc
    160          && (ResolveInfo::Global==ld_binding ||
    161              ResolveInfo::Weak==ld_binding)
    162          && ResolveInfo::Object==ld_type ) {
    163       AliasInfo p;
    164       p.pt_alias = psym;
    165       p.ld_binding = ld_binding;
    166       p.ld_value = ld_value;
    167       potential_aliases.push_back(p);
    168     }
    169 
    170   } // end of for loop
    171 
    172   // analyze weak alias
    173   // FIXME: it is better to let IRBuilder handle alias anlysis.
    174   //        1. eliminate code duplication
    175   //        2. easy to know if a symbol is from .so
    176   //           (so that it may be a potential alias)
    177   if ( is_dyn_obj ) {
    178     // sort symbols by symbol value and then weak before strong
    179     std::sort( potential_aliases.begin(), potential_aliases.end(), less);
    180 
    181     // for each weak symbol, find out all its aliases, and
    182     // then link them as a circular list in Module
    183     std::vector<AliasInfo>::iterator sym_it, sym_e;
    184     sym_e = potential_aliases.end();
    185     for (sym_it = potential_aliases.begin(); sym_it!=sym_e; ++sym_it) {
    186       if (ResolveInfo::Weak!=sym_it->ld_binding)
    187         continue;
    188 
    189       Module& pModule = pBuilder.getModule();
    190       std::vector<AliasInfo>::iterator alias_it = sym_it+1;
    191       while(alias_it!=sym_e) {
    192         if ( sym_it->ld_value != alias_it->ld_value )
    193           break;
    194 
    195         if (sym_it+1==alias_it)
    196           pModule.CreateAliasList(*sym_it->pt_alias->resolveInfo());
    197         pModule.addAlias(*alias_it->pt_alias->resolveInfo());
    198         ++alias_it;
    199       }
    200 
    201       sym_it = alias_it-1;
    202     }// end of for loop
    203   }
    204 
    205   return true;
    206 }
    207 
    208 //===----------------------------------------------------------------------===//
    209 // ELFReader::read relocations - read ELF rela and rel, and create Relocation
    210 //===----------------------------------------------------------------------===//
    211 /// ELFReader::readRela - read ELF rela and create Relocation
    212 bool ELFReader<32, true>::readRela(Input& pInput,
    213                                    LDSection& pSection,
    214                                    const MemoryRegion& pRegion) const
    215 {
    216   // get the number of rela
    217   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rela);
    218   const llvm::ELF::Elf32_Rela* relaTab =
    219                 reinterpret_cast<const llvm::ELF::Elf32_Rela*>(pRegion.start());
    220 
    221   for (size_t idx=0; idx < entsize; ++idx) {
    222     uint32_t r_offset = 0x0;
    223     uint32_t r_info   = 0x0;
    224     int32_t  r_addend = 0;
    225     if (llvm::sys::IsLittleEndianHost) {
    226       r_offset = relaTab[idx].r_offset;
    227       r_info   = relaTab[idx].r_info;
    228       r_addend = relaTab[idx].r_addend;
    229     }
    230     else {
    231       r_offset = mcld::bswap32(relaTab[idx].r_offset);
    232       r_info   = mcld::bswap32(relaTab[idx].r_info);
    233       r_addend = mcld::bswap32(relaTab[idx].r_addend);
    234     }
    235 
    236     uint8_t  r_type = static_cast<unsigned char>(r_info);
    237     uint32_t r_sym  = (r_info >> 8);
    238     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    239     if (NULL == symbol) {
    240       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    241     }
    242 
    243     IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset, r_addend);
    244   } // end of for
    245   return true;
    246 }
    247 
    248 /// readRel - read ELF rel and create Relocation
    249 bool ELFReader<32, true>::readRel(Input& pInput,
    250                                   LDSection& pSection,
    251                                   const MemoryRegion& pRegion) const
    252 {
    253   // get the number of rel
    254   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rel);
    255   const llvm::ELF::Elf32_Rel* relTab =
    256                  reinterpret_cast<const llvm::ELF::Elf32_Rel*>(pRegion.start());
    257 
    258   for (size_t idx=0; idx < entsize; ++idx) {
    259     uint32_t r_offset = 0x0;
    260     uint32_t r_info   = 0x0;
    261     if (llvm::sys::IsLittleEndianHost) {
    262       r_offset = relTab[idx].r_offset;
    263       r_info   = relTab[idx].r_info;
    264     }
    265     else {
    266       r_offset = mcld::bswap32(relTab[idx].r_offset);
    267       r_info   = mcld::bswap32(relTab[idx].r_info);
    268     }
    269 
    270     uint8_t  r_type = static_cast<unsigned char>(r_info);
    271     uint32_t r_sym  = (r_info >> 8);
    272 
    273     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    274     if (NULL == symbol) {
    275       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    276     }
    277 
    278     IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset);
    279   } // end of for
    280   return true;
    281 }
    282 
    283 /// isMyEndian - is this ELF file in the same endian to me?
    284 bool ELFReader<32, true>::isMyEndian(void* pELFHeader) const
    285 {
    286   llvm::ELF::Elf32_Ehdr* hdr =
    287                           reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
    288 
    289   return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB);
    290 }
    291 
    292 /// isMyMachine - is this ELF file generated for the same machine.
    293 bool ELFReader<32, true>::isMyMachine(void* pELFHeader) const
    294 {
    295   llvm::ELF::Elf32_Ehdr* hdr =
    296                           reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
    297 
    298   if (llvm::sys::IsLittleEndianHost)
    299     return (hdr->e_machine == target().getInfo().machine());
    300   return (mcld::bswap16(hdr->e_machine) == target().getInfo().machine());
    301 }
    302 
    303 /// fileType - return the file type
    304 Input::Type ELFReader<32, true>::fileType(void* pELFHeader) const
    305 {
    306   llvm::ELF::Elf32_Ehdr* hdr =
    307                           reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
    308   uint32_t type = 0x0;
    309   if (llvm::sys::IsLittleEndianHost)
    310     type = hdr->e_type;
    311   else
    312     type = mcld::bswap16(hdr->e_type);
    313 
    314   switch(type) {
    315   case llvm::ELF::ET_REL:
    316     return Input::Object;
    317   case llvm::ELF::ET_EXEC:
    318     return Input::Exec;
    319   case llvm::ELF::ET_DYN:
    320     return Input::DynObj;
    321   case llvm::ELF::ET_CORE:
    322     return Input::CoreFile;
    323   case llvm::ELF::ET_NONE:
    324   default:
    325     return Input::Unknown;
    326   }
    327 }
    328 
    329 /// readSectionHeaders - read ELF section header table and create LDSections
    330 bool
    331 ELFReader<32, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const
    332 {
    333   llvm::ELF::Elf32_Ehdr* ehdr =
    334                           reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
    335 
    336   uint32_t shoff     = 0x0;
    337   uint16_t shentsize = 0x0;
    338   uint32_t shnum     = 0x0;
    339   uint32_t shstrtab  = 0x0;
    340 
    341   if (llvm::sys::IsLittleEndianHost) {
    342     shoff     = ehdr->e_shoff;
    343     shentsize = ehdr->e_shentsize;
    344     shnum     = ehdr->e_shnum;
    345     shstrtab  = ehdr->e_shstrndx;
    346   }
    347   else {
    348     shoff     = mcld::bswap32(ehdr->e_shoff);
    349     shentsize = mcld::bswap16(ehdr->e_shentsize);
    350     shnum     = mcld::bswap16(ehdr->e_shnum);
    351     shstrtab  = mcld::bswap16(ehdr->e_shstrndx);
    352   }
    353 
    354   // If the file has no section header table, e_shoff holds zero.
    355   if (0x0 == shoff)
    356     return true;
    357 
    358   llvm::ELF::Elf32_Shdr *shdr = NULL;
    359   MemoryRegion* shdr_region = NULL;
    360   uint32_t sh_name      = 0x0;
    361   uint32_t sh_type      = 0x0;
    362   uint32_t sh_flags     = 0x0;
    363   uint32_t sh_offset    = 0x0;
    364   uint32_t sh_size      = 0x0;
    365   uint32_t sh_link      = 0x0;
    366   uint32_t sh_info      = 0x0;
    367   uint32_t sh_addralign = 0x0;
    368 
    369   // if shnum and shstrtab overflow, the actual values are in the 1st shdr
    370   if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) {
    371     shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
    372                                             shentsize);
    373     shdr = reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start());
    374 
    375     if (llvm::sys::IsLittleEndianHost) {
    376       sh_size = shdr->sh_size;
    377       sh_link = shdr->sh_link;
    378     }
    379     else {
    380       sh_size = mcld::bswap32(shdr->sh_size);
    381       sh_link = mcld::bswap32(shdr->sh_link);
    382     }
    383     pInput.memArea()->release(shdr_region);
    384 
    385     if (shnum == llvm::ELF::SHN_UNDEF)
    386       shnum = sh_size;
    387     if (shstrtab == llvm::ELF::SHN_XINDEX)
    388       shstrtab = sh_link;
    389 
    390     shoff += shentsize;
    391   }
    392 
    393   shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
    394                                           shnum * shentsize);
    395   llvm::ELF::Elf32_Shdr * shdrTab =
    396     reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start());
    397 
    398   // get .shstrtab first
    399   shdr = &shdrTab[shstrtab];
    400   if (llvm::sys::IsLittleEndianHost) {
    401     sh_offset = shdr->sh_offset;
    402     sh_size   = shdr->sh_size;
    403   }
    404   else {
    405     sh_offset = mcld::bswap32(shdr->sh_offset);
    406     sh_size   = mcld::bswap32(shdr->sh_size);
    407   }
    408 
    409   MemoryRegion* sect_name_region = pInput.memArea()->request(
    410                                       pInput.fileOffset() + sh_offset, sh_size);
    411   const char* sect_name =
    412                        reinterpret_cast<const char*>(sect_name_region->start());
    413 
    414   LinkInfoList link_info_list;
    415 
    416   // create all LDSections, including first NULL section.
    417   for (size_t idx = 0; idx < shnum; ++idx) {
    418     if (llvm::sys::IsLittleEndianHost) {
    419       sh_name      = shdrTab[idx].sh_name;
    420       sh_type      = shdrTab[idx].sh_type;
    421       sh_flags     = shdrTab[idx].sh_flags;
    422       sh_offset    = shdrTab[idx].sh_offset;
    423       sh_size      = shdrTab[idx].sh_size;
    424       sh_link      = shdrTab[idx].sh_link;
    425       sh_info      = shdrTab[idx].sh_info;
    426       sh_addralign = shdrTab[idx].sh_addralign;
    427     }
    428     else {
    429       sh_name      = mcld::bswap32(shdrTab[idx].sh_name);
    430       sh_type      = mcld::bswap32(shdrTab[idx].sh_type);
    431       sh_flags     = mcld::bswap32(shdrTab[idx].sh_flags);
    432       sh_offset    = mcld::bswap32(shdrTab[idx].sh_offset);
    433       sh_size      = mcld::bswap32(shdrTab[idx].sh_size);
    434       sh_link      = mcld::bswap32(shdrTab[idx].sh_link);
    435       sh_info      = mcld::bswap32(shdrTab[idx].sh_info);
    436       sh_addralign = mcld::bswap32(shdrTab[idx].sh_addralign);
    437     }
    438 
    439     LDSection* section = IRBuilder::CreateELFHeader(pInput,
    440                                                     sect_name+sh_name,
    441                                                     sh_type,
    442                                                     sh_flags,
    443                                                     sh_addralign);
    444     section->setSize(sh_size);
    445     section->setOffset(sh_offset);
    446     section->setInfo(sh_info);
    447 
    448     if (sh_link != 0x0 || sh_info != 0x0) {
    449       LinkInfo link_info = { section, sh_link, sh_info };
    450       link_info_list.push_back(link_info);
    451     }
    452   } // end of for
    453 
    454   // set up InfoLink
    455   LinkInfoList::iterator info, infoEnd = link_info_list.end();
    456   for (info = link_info_list.begin(); info != infoEnd; ++info) {
    457     if (LDFileFormat::NamePool == info->section->kind() ||
    458         LDFileFormat::Group == info->section->kind() ||
    459         LDFileFormat::Note == info->section->kind()) {
    460       info->section->setLink(pInput.context()->getSection(info->sh_link));
    461       continue;
    462     }
    463     if (LDFileFormat::Relocation == info->section->kind()) {
    464       info->section->setLink(pInput.context()->getSection(info->sh_info));
    465       continue;
    466     }
    467   }
    468 
    469   pInput.memArea()->release(shdr_region);
    470   pInput.memArea()->release(sect_name_region);
    471 
    472   return true;
    473 }
    474 
    475 /// readSignature - read a symbol from the given Input and index in symtab
    476 /// This is used to get the signature of a group section.
    477 ResolveInfo* ELFReader<32, true>::readSignature(Input& pInput,
    478                                                 LDSection& pSymTab,
    479                                                 uint32_t pSymIdx) const
    480 {
    481   LDSection* symtab = &pSymTab;
    482   LDSection* strtab = symtab->getLink();
    483   assert(NULL != symtab && NULL != strtab);
    484 
    485   uint32_t offset = pInput.fileOffset() + symtab->offset() +
    486                       sizeof(llvm::ELF::Elf32_Sym) * pSymIdx;
    487   MemoryRegion* symbol_region =
    488                 pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf32_Sym));
    489   llvm::ELF::Elf32_Sym* entry =
    490                 reinterpret_cast<llvm::ELF::Elf32_Sym*>(symbol_region->start());
    491 
    492   uint32_t st_name  = 0x0;
    493   uint8_t  st_info  = 0x0;
    494   uint8_t  st_other = 0x0;
    495   uint16_t st_shndx = 0x0;
    496   st_info  = entry->st_info;
    497   st_other = entry->st_other;
    498   if (llvm::sys::IsLittleEndianHost) {
    499     st_name  = entry->st_name;
    500     st_shndx = entry->st_shndx;
    501   }
    502   else {
    503     st_name  = mcld::bswap32(entry->st_name);
    504     st_shndx = mcld::bswap16(entry->st_shndx);
    505   }
    506 
    507   MemoryRegion* strtab_region = pInput.memArea()->request(
    508                        pInput.fileOffset() + strtab->offset(), strtab->size());
    509 
    510   // get ld_name
    511   llvm::StringRef ld_name(
    512                     reinterpret_cast<char*>(strtab_region->start() + st_name));
    513 
    514   ResolveInfo* result = ResolveInfo::Create(ld_name);
    515   result->setSource(pInput.type() == Input::DynObj);
    516   result->setType(static_cast<ResolveInfo::Type>(st_info & 0xF));
    517   result->setDesc(getSymDesc(st_shndx, pInput));
    518   result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other));
    519   result->setVisibility(getSymVisibility(st_other));
    520 
    521   // release regions
    522   pInput.memArea()->release(symbol_region);
    523   pInput.memArea()->release(strtab_region);
    524 
    525   return result;
    526 }
    527 
    528 /// readDynamic - read ELF .dynamic in input dynobj
    529 bool ELFReader<32, true>::readDynamic(Input& pInput) const
    530 {
    531   assert(pInput.type() == Input::DynObj);
    532   const LDSection* dynamic_sect = pInput.context()->getSection(".dynamic");
    533   if (NULL == dynamic_sect) {
    534     fatal(diag::err_cannot_read_section) << ".dynamic";
    535   }
    536   const LDSection* dynstr_sect = dynamic_sect->getLink();
    537   if (NULL == dynstr_sect) {
    538     fatal(diag::err_cannot_read_section) << ".dynstr";
    539   }
    540 
    541   MemoryRegion* dynamic_region = pInput.memArea()->request(
    542            pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());
    543 
    544   MemoryRegion* dynstr_region = pInput.memArea()->request(
    545              pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());
    546 
    547   assert(NULL != dynamic_region && NULL != dynstr_region);
    548 
    549   const llvm::ELF::Elf32_Dyn* dynamic =
    550     (llvm::ELF::Elf32_Dyn*) dynamic_region->start();
    551   const char* dynstr = (const char*) dynstr_region->start();
    552   bool hasSOName = false;
    553   size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf32_Dyn);
    554 
    555   for (size_t idx = 0; idx < numOfEntries; ++idx) {
    556 
    557     llvm::ELF::Elf32_Sword d_tag = 0x0;
    558     llvm::ELF::Elf32_Word d_val = 0x0;
    559 
    560     if (llvm::sys::IsLittleEndianHost) {
    561       d_tag = dynamic[idx].d_tag;
    562       d_val = dynamic[idx].d_un.d_val;
    563     } else {
    564       d_tag = mcld::bswap32(dynamic[idx].d_tag);
    565       d_val = mcld::bswap32(dynamic[idx].d_un.d_val);
    566     }
    567 
    568     switch (d_tag) {
    569       case llvm::ELF::DT_SONAME:
    570         assert(d_val < dynstr_sect->size());
    571         pInput.setName(sys::fs::Path(dynstr + d_val).filename().native());
    572         hasSOName = true;
    573         break;
    574       case llvm::ELF::DT_NEEDED:
    575         // TODO:
    576         break;
    577       case llvm::ELF::DT_NULL:
    578       default:
    579         break;
    580     }
    581   }
    582 
    583   // if there is no SONAME in .dynamic, then set it from input path
    584   if (!hasSOName)
    585     pInput.setName(pInput.path().filename().native());
    586 
    587   pInput.memArea()->release(dynamic_region);
    588   pInput.memArea()->release(dynstr_region);
    589   return true;
    590 }
    591 
    592 //===----------------------------------------------------------------------===//
    593 // ELFReader<64, true>
    594 //===----------------------------------------------------------------------===//
    595 /// constructor
    596 ELFReader<64, true>::ELFReader(GNULDBackend& pBackend)
    597   : ELFReaderIF(pBackend) {
    598 }
    599 
    600 /// destructor
    601 ELFReader<64, true>::~ELFReader()
    602 {
    603 }
    604 
    605 /// isELF - is this a ELF file
    606 bool ELFReader<64, true>::isELF(void* pELFHeader) const
    607 {
    608   llvm::ELF::Elf64_Ehdr* hdr =
    609                           reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
    610   if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4))
    611     return true;
    612   return false;
    613 }
    614 
    615 /// readRegularSection - read a regular section and create fragments.
    616 bool
    617 ELFReader<64, true>::readRegularSection(Input& pInput, SectionData& pSD) const
    618 {
    619   uint64_t offset = pInput.fileOffset() + pSD.getSection().offset();
    620   uint64_t size = pSD.getSection().size();
    621 
    622   Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size);
    623   ObjectBuilder::AppendFragment(*frag, pSD);
    624   return true;
    625 }
    626 
    627 /// readSymbols - read ELF symbols and create LDSymbol
    628 bool ELFReader<64, true>::readSymbols(Input& pInput,
    629                                       IRBuilder& pBuilder,
    630                                       const MemoryRegion& pRegion,
    631                                       const char* pStrTab) const
    632 {
    633   // get number of symbols
    634   size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf64_Sym);
    635   const llvm::ELF::Elf64_Sym* symtab =
    636                  reinterpret_cast<const llvm::ELF::Elf64_Sym*>(pRegion.start());
    637 
    638   uint32_t st_name  = 0x0;
    639   uint64_t st_value = 0x0;
    640   uint64_t st_size  = 0x0;
    641   uint8_t  st_info  = 0x0;
    642   uint8_t  st_other = 0x0;
    643   uint16_t st_shndx = 0x0;
    644 
    645   // skip the first NULL symbol
    646   pInput.context()->addSymbol(LDSymbol::Null());
    647 
    648   /// recording symbols added from DynObj to analyze weak alias
    649   std::vector<AliasInfo> potential_aliases;
    650   bool is_dyn_obj = (pInput.type()==Input::DynObj);
    651   for (size_t idx = 1; idx < entsize; ++idx) {
    652     st_info  = symtab[idx].st_info;
    653     st_other = symtab[idx].st_other;
    654 
    655     if (llvm::sys::IsLittleEndianHost) {
    656       st_name  = symtab[idx].st_name;
    657       st_value = symtab[idx].st_value;
    658       st_size  = symtab[idx].st_size;
    659       st_shndx = symtab[idx].st_shndx;
    660     }
    661     else {
    662       st_name  = mcld::bswap32(symtab[idx].st_name);
    663       st_value = mcld::bswap64(symtab[idx].st_value);
    664       st_size  = mcld::bswap64(symtab[idx].st_size);
    665       st_shndx = mcld::bswap16(symtab[idx].st_shndx);
    666     }
    667 
    668     // If the section should not be included, set the st_shndx SHN_UNDEF
    669     // - A section in interrelated groups are not included.
    670     if (pInput.type() == Input::Object &&
    671         st_shndx < llvm::ELF::SHN_LORESERVE &&
    672         st_shndx != llvm::ELF::SHN_UNDEF) {
    673       if (NULL == pInput.context()->getSection(st_shndx))
    674         st_shndx = llvm::ELF::SHN_UNDEF;
    675     }
    676 
    677     // get ld_type
    678     ResolveInfo::Type ld_type = getSymType(st_info, st_shndx);
    679 
    680     // get ld_desc
    681     ResolveInfo::Desc ld_desc = getSymDesc(st_shndx, pInput);
    682 
    683     // get ld_binding
    684     ResolveInfo::Binding ld_binding = getSymBinding((st_info >> 4), st_shndx, st_other);
    685 
    686     // get ld_value - ld_value must be section relative.
    687     uint64_t ld_value = getSymValue(st_value, st_shndx, pInput);
    688 
    689     // get ld_vis
    690     ResolveInfo::Visibility ld_vis = getSymVisibility(st_other);
    691 
    692     // get section
    693     LDSection* section = NULL;
    694     if (st_shndx < llvm::ELF::SHN_LORESERVE) // including ABS and COMMON
    695       section = pInput.context()->getSection(st_shndx);
    696 
    697     // get ld_name
    698     std::string ld_name;
    699     if (ResolveInfo::Section == ld_type) {
    700       // Section symbol's st_name is the section index.
    701       assert(NULL != section && "get a invalid section");
    702       ld_name = section->name();
    703     }
    704     else {
    705       ld_name = std::string(pStrTab + st_name);
    706     }
    707 
    708     LDSymbol *psym =
    709             pBuilder.AddSymbol(pInput,
    710                                ld_name,
    711                                ld_type,
    712                                ld_desc,
    713                                ld_binding,
    714                                st_size,
    715                                ld_value,
    716                                section, ld_vis);
    717 
    718     if ( is_dyn_obj
    719          && NULL!=psym
    720          && ResolveInfo::Undefined!=ld_desc
    721          && (ResolveInfo::Global==ld_binding ||
    722              ResolveInfo::Weak==ld_binding)
    723          && ResolveInfo::Object==ld_type ) {
    724       AliasInfo p;
    725       p.pt_alias = psym;
    726       p.ld_binding = ld_binding;
    727       p.ld_value = ld_value;
    728       potential_aliases.push_back(p);
    729     }
    730 
    731   } // end of for loop
    732 
    733   // analyze weak alias here
    734   if ( is_dyn_obj ) {
    735     // sort symbols by symbol value and then weak before strong
    736     std::sort( potential_aliases.begin(), potential_aliases.end(), less);
    737 
    738     // for each weak symbol, find out all its aliases, and
    739     // then link them as a circular list in Module
    740     std::vector<AliasInfo>::iterator sym_it, sym_e;
    741     sym_e = potential_aliases.end();
    742     for (sym_it = potential_aliases.begin(); sym_it!=sym_e; ++sym_it) {
    743       if (ResolveInfo::Weak!=sym_it->ld_binding)
    744         continue;
    745 
    746       Module& pModule = pBuilder.getModule();
    747       std::vector<AliasInfo>::iterator alias_it = sym_it+1;
    748       while(alias_it!=sym_e) {
    749         if ( sym_it->ld_value != alias_it->ld_value )
    750           break;
    751 
    752         if (sym_it+1==alias_it)
    753           pModule.CreateAliasList(*sym_it->pt_alias->resolveInfo());
    754         pModule.addAlias(*alias_it->pt_alias->resolveInfo());
    755         ++alias_it;
    756       }
    757 
    758       sym_it = alias_it-1;
    759     }// end of for loop
    760   }
    761   return true;
    762 }
    763 
    764 //===----------------------------------------------------------------------===//
    765 // ELFReader::read relocations - read ELF rela and rel, and create Relocation
    766 //===----------------------------------------------------------------------===//
    767 /// ELFReader::readRela - read ELF rela and create Relocation
    768 bool ELFReader<64, true>::readRela(Input& pInput,
    769                                    LDSection& pSection,
    770                                    const MemoryRegion& pRegion) const
    771 {
    772   // get the number of rela
    773   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rela);
    774   const llvm::ELF::Elf64_Rela* relaTab =
    775                 reinterpret_cast<const llvm::ELF::Elf64_Rela*>(pRegion.start());
    776 
    777   for (size_t idx=0; idx < entsize; ++idx) {
    778     uint64_t r_offset = 0x0;
    779     uint64_t r_info   = 0x0;
    780     int64_t  r_addend = 0;
    781     if (llvm::sys::IsLittleEndianHost) {
    782       r_offset = relaTab[idx].r_offset;
    783       r_info   = relaTab[idx].r_info;
    784       r_addend = relaTab[idx].r_addend;
    785     }
    786     else {
    787       r_offset = mcld::bswap64(relaTab[idx].r_offset);
    788       r_info   = mcld::bswap64(relaTab[idx].r_info);
    789       r_addend = mcld::bswap64(relaTab[idx].r_addend);
    790     }
    791 
    792     uint32_t  r_type = static_cast<uint32_t>(r_info);
    793     uint32_t r_sym  = (r_info >> 32);
    794     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    795     if (NULL == symbol) {
    796       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    797     }
    798 
    799     IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset, r_addend);
    800   } // end of for
    801   return true;
    802 }
    803 
    804 /// readRel - read ELF rel and create Relocation
    805 bool ELFReader<64, true>::readRel(Input& pInput,
    806                                   LDSection& pSection,
    807                                   const MemoryRegion& pRegion) const
    808 {
    809   // get the number of rel
    810   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rel);
    811   const llvm::ELF::Elf64_Rel* relTab =
    812                  reinterpret_cast<const llvm::ELF::Elf64_Rel*>(pRegion.start());
    813 
    814   for (size_t idx=0; idx < entsize; ++idx) {
    815     uint64_t r_offset = 0x0;
    816     uint64_t r_info   = 0x0;
    817     if (llvm::sys::IsLittleEndianHost) {
    818       r_offset = relTab[idx].r_offset;
    819       r_info   = relTab[idx].r_info;
    820     }
    821     else {
    822       r_offset = mcld::bswap64(relTab[idx].r_offset);
    823       r_info   = mcld::bswap64(relTab[idx].r_info);
    824     }
    825 
    826     uint32_t  r_type = static_cast<uint32_t>(r_info);
    827     uint32_t r_sym  = (r_info >> 32);
    828 
    829     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
    830     if (NULL == symbol) {
    831       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
    832     }
    833 
    834     IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset);
    835   } // end of for
    836   return true;
    837 }
    838 
    839 /// isMyEndian - is this ELF file in the same endian to me?
    840 bool ELFReader<64, true>::isMyEndian(void* pELFHeader) const
    841 {
    842   llvm::ELF::Elf64_Ehdr* hdr =
    843                           reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
    844 
    845   return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB);
    846 }
    847 
    848 /// isMyMachine - is this ELF file generated for the same machine.
    849 bool ELFReader<64, true>::isMyMachine(void* pELFHeader) const
    850 {
    851   llvm::ELF::Elf64_Ehdr* hdr =
    852                           reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
    853 
    854   if (llvm::sys::IsLittleEndianHost)
    855     return (hdr->e_machine == target().getInfo().machine());
    856   return (mcld::bswap16(hdr->e_machine) == target().getInfo().machine());
    857 }
    858 
    859 /// fileType - return the file type
    860 Input::Type ELFReader<64, true>::fileType(void* pELFHeader) const
    861 {
    862   llvm::ELF::Elf64_Ehdr* hdr =
    863                           reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
    864   uint32_t type = 0x0;
    865   if (llvm::sys::IsLittleEndianHost)
    866     type = hdr->e_type;
    867   else
    868     type = mcld::bswap16(hdr->e_type);
    869 
    870   switch(type) {
    871   case llvm::ELF::ET_REL:
    872     return Input::Object;
    873   case llvm::ELF::ET_EXEC:
    874     return Input::Exec;
    875   case llvm::ELF::ET_DYN:
    876     return Input::DynObj;
    877   case llvm::ELF::ET_CORE:
    878     return Input::CoreFile;
    879   case llvm::ELF::ET_NONE:
    880   default:
    881     return Input::Unknown;
    882   }
    883 }
    884 
    885 /// readSectionHeaders - read ELF section header table and create LDSections
    886 bool
    887 ELFReader<64, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const
    888 {
    889   llvm::ELF::Elf64_Ehdr* ehdr =
    890                           reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
    891 
    892   uint64_t shoff     = 0x0;
    893   uint16_t shentsize = 0x0;
    894   uint32_t shnum     = 0x0;
    895   uint32_t shstrtab  = 0x0;
    896 
    897   if (llvm::sys::IsLittleEndianHost) {
    898     shoff     = ehdr->e_shoff;
    899     shentsize = ehdr->e_shentsize;
    900     shnum     = ehdr->e_shnum;
    901     shstrtab  = ehdr->e_shstrndx;
    902   }
    903   else {
    904     shoff     = mcld::bswap64(ehdr->e_shoff);
    905     shentsize = mcld::bswap16(ehdr->e_shentsize);
    906     shnum     = mcld::bswap16(ehdr->e_shnum);
    907     shstrtab  = mcld::bswap16(ehdr->e_shstrndx);
    908   }
    909 
    910   // If the file has no section header table, e_shoff holds zero.
    911   if (0x0 == shoff)
    912     return true;
    913 
    914   llvm::ELF::Elf64_Shdr *shdr = NULL;
    915   MemoryRegion* shdr_region = NULL;
    916   uint32_t sh_name      = 0x0;
    917   uint32_t sh_type      = 0x0;
    918   uint64_t sh_flags     = 0x0;
    919   uint64_t sh_offset    = 0x0;
    920   uint64_t sh_size      = 0x0;
    921   uint32_t sh_link      = 0x0;
    922   uint32_t sh_info      = 0x0;
    923   uint64_t sh_addralign = 0x0;
    924 
    925   // if shnum and shstrtab overflow, the actual values are in the 1st shdr
    926   if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) {
    927     shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
    928                                             shentsize);
    929     shdr = reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start());
    930 
    931     if (llvm::sys::IsLittleEndianHost) {
    932       sh_size = shdr->sh_size;
    933       sh_link = shdr->sh_link;
    934     }
    935     else {
    936       sh_size = mcld::bswap64(shdr->sh_size);
    937       sh_link = mcld::bswap32(shdr->sh_link);
    938     }
    939     pInput.memArea()->release(shdr_region);
    940 
    941     if (shnum == llvm::ELF::SHN_UNDEF)
    942       shnum = sh_size;
    943     if (shstrtab == llvm::ELF::SHN_XINDEX)
    944       shstrtab = sh_link;
    945 
    946     shoff += shentsize;
    947   }
    948 
    949   shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
    950                                           shnum * shentsize);
    951   llvm::ELF::Elf64_Shdr * shdrTab =
    952     reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start());
    953 
    954   // get .shstrtab first
    955   shdr = &shdrTab[shstrtab];
    956   if (llvm::sys::IsLittleEndianHost) {
    957     sh_offset = shdr->sh_offset;
    958     sh_size   = shdr->sh_size;
    959   }
    960   else {
    961     sh_offset = mcld::bswap64(shdr->sh_offset);
    962     sh_size   = mcld::bswap64(shdr->sh_size);
    963   }
    964 
    965   MemoryRegion* sect_name_region = pInput.memArea()->request(
    966                                       pInput.fileOffset() + sh_offset, sh_size);
    967   const char* sect_name =
    968                        reinterpret_cast<const char*>(sect_name_region->start());
    969 
    970   LinkInfoList link_info_list;
    971 
    972   // create all LDSections, including first NULL section.
    973   for (size_t idx = 0; idx < shnum; ++idx) {
    974     if (llvm::sys::IsLittleEndianHost) {
    975       sh_name      = shdrTab[idx].sh_name;
    976       sh_type      = shdrTab[idx].sh_type;
    977       sh_flags     = shdrTab[idx].sh_flags;
    978       sh_offset    = shdrTab[idx].sh_offset;
    979       sh_size      = shdrTab[idx].sh_size;
    980       sh_link      = shdrTab[idx].sh_link;
    981       sh_info      = shdrTab[idx].sh_info;
    982       sh_addralign = shdrTab[idx].sh_addralign;
    983     }
    984     else {
    985       sh_name      = mcld::bswap32(shdrTab[idx].sh_name);
    986       sh_type      = mcld::bswap32(shdrTab[idx].sh_type);
    987       sh_flags     = mcld::bswap64(shdrTab[idx].sh_flags);
    988       sh_offset    = mcld::bswap64(shdrTab[idx].sh_offset);
    989       sh_size      = mcld::bswap64(shdrTab[idx].sh_size);
    990       sh_link      = mcld::bswap32(shdrTab[idx].sh_link);
    991       sh_info      = mcld::bswap32(shdrTab[idx].sh_info);
    992       sh_addralign = mcld::bswap64(shdrTab[idx].sh_addralign);
    993     }
    994 
    995     LDSection* section = IRBuilder::CreateELFHeader(pInput,
    996                                                     sect_name+sh_name,
    997                                                     sh_type,
    998                                                     sh_flags,
    999                                                     sh_addralign);
   1000     section->setSize(sh_size);
   1001     section->setOffset(sh_offset);
   1002     section->setInfo(sh_info);
   1003 
   1004     if (sh_link != 0x0 || sh_info != 0x0) {
   1005       LinkInfo link_info = { section, sh_link, sh_info };
   1006       link_info_list.push_back(link_info);
   1007     }
   1008   } // end of for
   1009 
   1010   // set up InfoLink
   1011   LinkInfoList::iterator info, infoEnd = link_info_list.end();
   1012   for (info = link_info_list.begin(); info != infoEnd; ++info) {
   1013     if (LDFileFormat::NamePool == info->section->kind() ||
   1014         LDFileFormat::Group == info->section->kind() ||
   1015         LDFileFormat::Note == info->section->kind()) {
   1016       info->section->setLink(pInput.context()->getSection(info->sh_link));
   1017       continue;
   1018     }
   1019     if (LDFileFormat::Relocation == info->section->kind()) {
   1020       info->section->setLink(pInput.context()->getSection(info->sh_info));
   1021       continue;
   1022     }
   1023   }
   1024 
   1025   pInput.memArea()->release(shdr_region);
   1026   pInput.memArea()->release(sect_name_region);
   1027 
   1028   return true;
   1029 }
   1030 
   1031 /// readSignature - read a symbol from the given Input and index in symtab
   1032 /// This is used to get the signature of a group section.
   1033 ResolveInfo* ELFReader<64, true>::readSignature(Input& pInput,
   1034                                                 LDSection& pSymTab,
   1035                                                 uint32_t pSymIdx) const
   1036 {
   1037   LDSection* symtab = &pSymTab;
   1038   LDSection* strtab = symtab->getLink();
   1039   assert(NULL != symtab && NULL != strtab);
   1040 
   1041   uint64_t offset = pInput.fileOffset() + symtab->offset() +
   1042                       sizeof(llvm::ELF::Elf64_Sym) * pSymIdx;
   1043   MemoryRegion* symbol_region =
   1044                 pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf64_Sym));
   1045   llvm::ELF::Elf64_Sym* entry =
   1046                 reinterpret_cast<llvm::ELF::Elf64_Sym*>(symbol_region->start());
   1047 
   1048   uint32_t st_name  = 0x0;
   1049   uint8_t  st_info  = 0x0;
   1050   uint8_t  st_other = 0x0;
   1051   uint16_t st_shndx = 0x0;
   1052   st_info  = entry->st_info;
   1053   st_other = entry->st_other;
   1054   if (llvm::sys::IsLittleEndianHost) {
   1055     st_name  = entry->st_name;
   1056     st_shndx = entry->st_shndx;
   1057   }
   1058   else {
   1059     st_name  = mcld::bswap32(entry->st_name);
   1060     st_shndx = mcld::bswap16(entry->st_shndx);
   1061   }
   1062 
   1063   MemoryRegion* strtab_region = pInput.memArea()->request(
   1064                        pInput.fileOffset() + strtab->offset(), strtab->size());
   1065 
   1066   // get ld_name
   1067   llvm::StringRef ld_name(
   1068                     reinterpret_cast<char*>(strtab_region->start() + st_name));
   1069 
   1070   ResolveInfo* result = ResolveInfo::Create(ld_name);
   1071   result->setSource(pInput.type() == Input::DynObj);
   1072   result->setType(static_cast<ResolveInfo::Type>(st_info & 0xF));
   1073   result->setDesc(getSymDesc(st_shndx, pInput));
   1074   result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other));
   1075   result->setVisibility(getSymVisibility(st_other));
   1076 
   1077   // release regions
   1078   pInput.memArea()->release(symbol_region);
   1079   pInput.memArea()->release(strtab_region);
   1080 
   1081   return result;
   1082 }
   1083 
   1084 /// readDynamic - read ELF .dynamic in input dynobj
   1085 bool ELFReader<64, true>::readDynamic(Input& pInput) const
   1086 {
   1087   assert(pInput.type() == Input::DynObj);
   1088   const LDSection* dynamic_sect = pInput.context()->getSection(".dynamic");
   1089   if (NULL == dynamic_sect) {
   1090     fatal(diag::err_cannot_read_section) << ".dynamic";
   1091   }
   1092   const LDSection* dynstr_sect = dynamic_sect->getLink();
   1093   if (NULL == dynstr_sect) {
   1094     fatal(diag::err_cannot_read_section) << ".dynstr";
   1095   }
   1096 
   1097   MemoryRegion* dynamic_region = pInput.memArea()->request(
   1098            pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());
   1099 
   1100   MemoryRegion* dynstr_region = pInput.memArea()->request(
   1101              pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());
   1102 
   1103   assert(NULL != dynamic_region && NULL != dynstr_region);
   1104 
   1105   const llvm::ELF::Elf64_Dyn* dynamic =
   1106     (llvm::ELF::Elf64_Dyn*) dynamic_region->start();
   1107   const char* dynstr = (const char*) dynstr_region->start();
   1108   bool hasSOName = false;
   1109   size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf64_Dyn);
   1110 
   1111   for (size_t idx = 0; idx < numOfEntries; ++idx) {
   1112 
   1113     llvm::ELF::Elf64_Sxword d_tag = 0x0;
   1114     llvm::ELF::Elf64_Xword d_val = 0x0;
   1115 
   1116     if (llvm::sys::IsLittleEndianHost) {
   1117       d_tag = dynamic[idx].d_tag;
   1118       d_val = dynamic[idx].d_un.d_val;
   1119     } else {
   1120       d_tag = mcld::bswap64(dynamic[idx].d_tag);
   1121       d_val = mcld::bswap64(dynamic[idx].d_un.d_val);
   1122     }
   1123 
   1124     switch (d_tag) {
   1125       case llvm::ELF::DT_SONAME:
   1126         assert(d_val < dynstr_sect->size());
   1127         pInput.setName(sys::fs::Path(dynstr + d_val).filename().native());
   1128         hasSOName = true;
   1129         break;
   1130       case llvm::ELF::DT_NEEDED:
   1131         // TODO:
   1132         break;
   1133       case llvm::ELF::DT_NULL:
   1134       default:
   1135         break;
   1136     }
   1137   }
   1138 
   1139   // if there is no SONAME in .dynamic, then set it from input path
   1140   if (!hasSOName)
   1141     pInput.setName(pInput.path().filename().native());
   1142 
   1143   pInput.memArea()->release(dynamic_region);
   1144   pInput.memArea()->release(dynstr_region);
   1145   return true;
   1146 }
   1147 
   1148