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