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 
29 namespace mcld {
30 
31 //===----------------------------------------------------------------------===//
32 // ELFObjectReader
33 //===----------------------------------------------------------------------===//
34 /// constructor
ELFObjectReader(GNULDBackend & pBackend,IRBuilder & pBuilder,const LinkerConfig & pConfig)35 ELFObjectReader::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
~ELFObjectReader()56 ELFObjectReader::~ELFObjectReader() {
57   delete m_pELFReader;
58   delete m_pEhFrameReader;
59 }
60 
61 /// isMyFormat
isMyFormat(Input & pInput,bool & pContinue) const62 bool 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.
readHeader(Input & pInput)93 bool 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.
readSections(Input & pInput)109 bool 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.
readSymbols(Input & pInput)276 bool 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 
readRelocations(Input & pInput)303 bool 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