ELFObjectReader.cpp revision cfcb22478ca64c308df58f9abe6fa2dedb213c16 
1//===- ELFObjectReader.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/ELFObjectReader.h"
10
11#include "mcld/IRBuilder.h"
12#include "mcld/MC/Input.h"
13#include "mcld/LD/ELFReader.h"
14#include "mcld/LD/EhFrameReader.h"
15#include "mcld/LD/EhFrame.h"
16#include "mcld/LD/LDContext.h"
17#include "mcld/Target/GNULDBackend.h"
18#include "mcld/Support/MsgHandling.h"
19#include "mcld/Support/MemoryArea.h"
20#include "mcld/Object/ObjectBuilder.h"
21
22#include <llvm/Support/ELF.h>
23#include <llvm/ADT/Twine.h>
24#include <llvm/ADT/StringRef.h>
25
26#include <string>
27#include <cassert>
28
29namespace mcld {
30
31//===----------------------------------------------------------------------===//
32// ELFObjectReader
33//===----------------------------------------------------------------------===//
34/// constructor
35ELFObjectReader::ELFObjectReader(GNULDBackend& pBackend,
36                                 IRBuilder& pBuilder,
37                                 const LinkerConfig& pConfig)
38    : ObjectReader(),
39      m_pELFReader(NULL),
40      m_pEhFrameReader(NULL),
41      m_Builder(pBuilder),
42      m_ReadFlag(ParseEhFrame),
43      m_Backend(pBackend),
44      m_Config(pConfig) {
45  if (pConfig.targets().is32Bits() && pConfig.targets().isLittleEndian()) {
46    m_pELFReader = new ELFReader<32, true>(pBackend);
47  } else if (pConfig.targets().is64Bits() &&
48             pConfig.targets().isLittleEndian()) {
49    m_pELFReader = new ELFReader<64, true>(pBackend);
50  }
51
52  m_pEhFrameReader = new EhFrameReader();
53}
54
55/// destructor
56ELFObjectReader::~ELFObjectReader() {
57  delete m_pELFReader;
58  delete m_pEhFrameReader;
59}
60
61/// isMyFormat
62bool ELFObjectReader::isMyFormat(Input& pInput, bool& pContinue) const {
63  assert(pInput.hasMemArea());
64
65  // Don't warning about the frequently requests.
66  // MemoryArea has a list of cache to handle this.
67  size_t hdr_size = m_pELFReader->getELFHeaderSize();
68  if (pInput.memArea()->size() < hdr_size)
69    return false;
70
71  llvm::StringRef region =
72      pInput.memArea()->request(pInput.fileOffset(), hdr_size);
73
74  const char* ELF_hdr = region.begin();
75  bool result = true;
76  if (!m_pELFReader->isELF(ELF_hdr)) {
77    pContinue = true;
78    result = false;
79  } else if (Input::Object != m_pELFReader->fileType(ELF_hdr)) {
80    pContinue = true;
81    result = false;
82  } else if (!m_pELFReader->isMyEndian(ELF_hdr)) {
83    pContinue = false;
84    result = false;
85  } else if (!m_pELFReader->isMyMachine(ELF_hdr)) {
86    pContinue = false;
87    result = false;
88  }
89  return result;
90}
91
92/// readHeader - read section header and create LDSections.
93bool ELFObjectReader::readHeader(Input& pInput) {
94  assert(pInput.hasMemArea());
95
96  size_t hdr_size = m_pELFReader->getELFHeaderSize();
97  if (pInput.memArea()->size() < hdr_size)
98    return false;
99
100  llvm::StringRef region =
101      pInput.memArea()->request(pInput.fileOffset(), hdr_size);
102  const char* ELF_hdr = region.begin();
103  m_Backend.mergeFlags(pInput, ELF_hdr);
104  bool result = m_pELFReader->readSectionHeaders(pInput, ELF_hdr);
105  return result;
106}
107
108/// readSections - read all regular sections.
109bool ELFObjectReader::readSections(Input& pInput) {
110  // handle sections
111  LDContext::sect_iterator section, sectEnd = pInput.context()->sectEnd();
112  for (section = pInput.context()->sectBegin(); section != sectEnd; ++section) {
113    // ignore the section if the LDSection* in input context is NULL
114    if (*section == NULL)
115      continue;
116
117    switch ((*section)->kind()) {
118      /** group sections **/
119      case LDFileFormat::Group: {
120        assert((*section)->getLink() != NULL);
121        ResolveInfo* signature = m_pELFReader->readSignature(
122            pInput, *(*section)->getLink(), (*section)->getInfo());
123
124        bool exist = false;
125        if (signature->nameSize() == 0 &&
126            ResolveInfo::Section == signature->type()) {
127          // if the signature is a section symbol in input object, we use the
128          // section name as group signature.
129          signatures().insert((*section)->name(), exist);
130        } else {
131          signatures().insert(signature->name(), exist);
132        }
133
134        if (exist) {
135          // if this is not the first time we see this group signature, then
136          // ignore all the members in this group (set Ignore)
137          llvm::StringRef region = pInput.memArea()->request(
138              pInput.fileOffset() + (*section)->offset(), (*section)->size());
139          const llvm::ELF::Elf32_Word* value =
140              reinterpret_cast<const llvm::ELF::Elf32_Word*>(region.begin());
141
142          size_t size = region.size() / sizeof(llvm::ELF::Elf32_Word);
143          if (llvm::ELF::GRP_COMDAT == *value) {
144            for (size_t index = 1; index < size; ++index) {
145              pInput.context()->getSection(value[index])->setKind(
146                  LDFileFormat::Ignore);
147            }
148          }
149        }
150        ResolveInfo::Destroy(signature);
151        break;
152      }
153      /** linkonce sections **/
154      case LDFileFormat::LinkOnce: {
155        bool exist = false;
156        // .gnu.linkonce + "." + type + "." + name
157        llvm::StringRef name(
158            llvm::StringRef((*section)->name()).drop_front(14));
159        signatures().insert(name.split(".").second, exist);
160        if (!exist) {
161          if (name.startswith("wi")) {
162            (*section)->setKind(LDFileFormat::Debug);
163            if (m_Config.options().stripDebug())
164              (*section)->setKind(LDFileFormat::Ignore);
165            else {
166              SectionData* sd = IRBuilder::CreateSectionData(**section);
167              if (!m_pELFReader->readRegularSection(pInput, *sd))
168                fatal(diag::err_cannot_read_section) << (*section)->name();
169            }
170          } else {
171            if (((*section)->flag() & llvm::ELF::SHF_EXECINSTR) != 0)
172              (*section)->setKind(LDFileFormat::TEXT);
173            else
174              (*section)->setKind(LDFileFormat::DATA);
175            SectionData* sd = IRBuilder::CreateSectionData(**section);
176            if (!m_pELFReader->readRegularSection(pInput, *sd))
177              fatal(diag::err_cannot_read_section) << (*section)->name();
178          }
179        } else {
180          (*section)->setKind(LDFileFormat::Ignore);
181        }
182        break;
183      }
184      /** relocation sections **/
185      case LDFileFormat::Relocation: {
186        assert((*section)->getLink() != NULL);
187        size_t link_index = (*section)->getLink()->index();
188        LDSection* link_sect = pInput.context()->getSection(link_index);
189        if (link_sect == NULL || link_sect->kind() == LDFileFormat::Ignore) {
190          // Relocation sections of group members should also be part of the
191          // group. Thus, if the associated member sections are ignored, the
192          // related relocations should be also ignored.
193          (*section)->setKind(LDFileFormat::Ignore);
194        }
195        break;
196      }
197      /** normal sections **/
198      // FIXME: support Version Kind
199      case LDFileFormat::Version:
200      // FIXME: support GCCExceptTable Kind
201      case LDFileFormat::GCCExceptTable:
202      /** Fall through **/
203      case LDFileFormat::TEXT:
204      case LDFileFormat::DATA:
205      case LDFileFormat::Note:
206      case LDFileFormat::MetaData: {
207        SectionData* sd = IRBuilder::CreateSectionData(**section);
208        if (!m_pELFReader->readRegularSection(pInput, *sd))
209          fatal(diag::err_cannot_read_section) << (*section)->name();
210        break;
211      }
212      case LDFileFormat::Debug:
213      case LDFileFormat::DebugString: {
214        if (m_Config.options().stripDebug()) {
215          (*section)->setKind(LDFileFormat::Ignore);
216        } else {
217          SectionData* sd = IRBuilder::CreateSectionData(**section);
218          if (!m_pELFReader->readRegularSection(pInput, *sd)) {
219            fatal(diag::err_cannot_read_section) << (*section)->name();
220          }
221        }
222        break;
223      }
224      case LDFileFormat::EhFrame: {
225        EhFrame* eh_frame = IRBuilder::CreateEhFrame(**section);
226
227        // We don't really parse EhFrame if this is a partial linking
228        if ((m_Config.codeGenType() != LinkerConfig::Object) &&
229            (m_ReadFlag & ParseEhFrame)) {
230          if (!m_pEhFrameReader->read<32, true>(pInput, *eh_frame)) {
231            // if we failed to parse a .eh_frame, we should not parse the rest
232            // .eh_frame.
233            m_ReadFlag ^= ParseEhFrame;
234          }
235        } else {
236          if (!m_pELFReader->readRegularSection(pInput,
237                                                *eh_frame->getSectionData())) {
238            fatal(diag::err_cannot_read_section) << (*section)->name();
239          }
240        }
241        break;
242      }
243      /** target dependent sections **/
244      case LDFileFormat::Target: {
245        SectionData* sd = IRBuilder::CreateSectionData(**section);
246        if (!m_Backend.readSection(pInput, *sd)) {
247          fatal(diag::err_cannot_read_target_section) << (*section)->name();
248        }
249        break;
250      }
251      /** BSS sections **/
252      case LDFileFormat::BSS: {
253        IRBuilder::CreateBSS(**section);
254        break;
255      }
256      // ignore
257      case LDFileFormat::Null:
258      case LDFileFormat::NamePool:
259      case LDFileFormat::Ignore:
260      case LDFileFormat::StackNote:
261        continue;
262      // warning
263      case LDFileFormat::EhFrameHdr:
264      default: {
265        warning(diag::warn_illegal_input_section)
266            << (*section)->name() << pInput.name() << pInput.path();
267        break;
268      }
269    }
270  }  // end of for all sections
271
272  return true;
273}
274
275/// readSymbols - read symbols from the input relocatable object.
276bool ELFObjectReader::readSymbols(Input& pInput) {
277  assert(pInput.hasMemArea());
278
279  LDSection* symtab_shdr = pInput.context()->getSection(".symtab");
280  if (symtab_shdr == NULL) {
281    note(diag::note_has_no_symtab) << pInput.name() << pInput.path()
282                                   << ".symtab";
283    return true;
284  }
285
286  LDSection* strtab_shdr = symtab_shdr->getLink();
287  if (strtab_shdr == NULL) {
288    fatal(diag::fatal_cannot_read_strtab) << pInput.name() << pInput.path()
289                                          << ".symtab";
290    return false;
291  }
292
293  llvm::StringRef symtab_region = pInput.memArea()->request(
294      pInput.fileOffset() + symtab_shdr->offset(), symtab_shdr->size());
295  llvm::StringRef strtab_region = pInput.memArea()->request(
296      pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
297  const char* strtab = strtab_region.begin();
298  bool result =
299      m_pELFReader->readSymbols(pInput, m_Builder, symtab_region, strtab);
300  return result;
301}
302
303bool ELFObjectReader::readRelocations(Input& pInput) {
304  assert(pInput.hasMemArea());
305
306  MemoryArea* mem = pInput.memArea();
307  LDContext::sect_iterator rs, rsEnd = pInput.context()->relocSectEnd();
308  for (rs = pInput.context()->relocSectBegin(); rs != rsEnd; ++rs) {
309    if (LDFileFormat::Ignore == (*rs)->kind())
310      continue;
311
312    uint32_t offset = pInput.fileOffset() + (*rs)->offset();
313    uint32_t size = (*rs)->size();
314    llvm::StringRef region = mem->request(offset, size);
315    IRBuilder::CreateRelocData(
316        **rs);  ///< create relocation data for the header
317    switch ((*rs)->type()) {
318      case llvm::ELF::SHT_RELA: {
319        if (!m_pELFReader->readRela(pInput, **rs, region)) {
320          return false;
321        }
322        break;
323      }
324      case llvm::ELF::SHT_REL: {
325        if (!m_pELFReader->readRel(pInput, **rs, region)) {
326          return false;
327        }
328        break;
329      }
330      default: {  ///< should not enter
331        return false;
332      }
333    }  // end of switch
334  }  // end of for all relocation data
335
336  return true;
337}
338
339}  // namespace mcld
340