ELFReader.cpp revision 21433dddd6366055d6b305675f4afca0b4592dcd 
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
29using namespace mcld;
30
31//===----------------------------------------------------------------------===//
32// ELFReader<32, true>
33//===----------------------------------------------------------------------===//
34/// constructor
35ELFReader<32, true>::ELFReader(GNULDBackend& pBackend)
36  : ELFReaderIF(pBackend) {
37}
38
39/// destructor
40ELFReader<32, true>::~ELFReader()
41{
42}
43
44/// isELF - is this a ELF file
45bool 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.
55bool
56ELFReader<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
67bool 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
212bool 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
249bool 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?
284bool 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.
293bool 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
304Input::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
330bool
331ELFReader<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.
477ResolveInfo* 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
529bool 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
596ELFReader<64, true>::ELFReader(GNULDBackend& pBackend)
597  : ELFReaderIF(pBackend) {
598}
599
600/// destructor
601ELFReader<64, true>::~ELFReader()
602{
603}
604
605/// isELF - is this a ELF file
606bool 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.
616bool
617ELFReader<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
628bool 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
768bool 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
805bool 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?
840bool 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.
849bool 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
860Input::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
886bool
887ELFReader<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.
1033ResolveInfo* 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
1085bool 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