1 //===- ELFObjectFile.cpp - ELF object file implementation -------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ELFObjectFile class.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/ADT/SmallVector.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/ADT/Triple.h"
17 #include "llvm/Object/ObjectFile.h"
18 #include "llvm/Support/ELF.h"
19 #include "llvm/Support/Endian.h"
20 #include "llvm/Support/ErrorHandling.h"
21 #include "llvm/Support/MemoryBuffer.h"
26 using namespace object;
28 // Templates to choose Elf_Addr and Elf_Off depending on is64Bits.
30 template<support::endianness target_endianness>
31 struct ELFDataTypeTypedefHelperCommon {
32 typedef support::detail::packed_endian_specific_integral
33 <uint16_t, target_endianness, support::aligned> Elf_Half;
34 typedef support::detail::packed_endian_specific_integral
35 <uint32_t, target_endianness, support::aligned> Elf_Word;
36 typedef support::detail::packed_endian_specific_integral
37 <int32_t, target_endianness, support::aligned> Elf_Sword;
38 typedef support::detail::packed_endian_specific_integral
39 <uint64_t, target_endianness, support::aligned> Elf_Xword;
40 typedef support::detail::packed_endian_specific_integral
41 <int64_t, target_endianness, support::aligned> Elf_Sxword;
46 template<support::endianness target_endianness, bool is64Bits>
47 struct ELFDataTypeTypedefHelper;
50 template<support::endianness target_endianness>
51 struct ELFDataTypeTypedefHelper<target_endianness, false>
52 : ELFDataTypeTypedefHelperCommon<target_endianness> {
53 typedef support::detail::packed_endian_specific_integral
54 <uint32_t, target_endianness, support::aligned> Elf_Addr;
55 typedef support::detail::packed_endian_specific_integral
56 <uint32_t, target_endianness, support::aligned> Elf_Off;
60 template<support::endianness target_endianness>
61 struct ELFDataTypeTypedefHelper<target_endianness, true>
62 : ELFDataTypeTypedefHelperCommon<target_endianness>{
63 typedef support::detail::packed_endian_specific_integral
64 <uint64_t, target_endianness, support::aligned> Elf_Addr;
65 typedef support::detail::packed_endian_specific_integral
66 <uint64_t, target_endianness, support::aligned> Elf_Off;
70 // I really don't like doing this, but the alternative is copypasta.
71 #define LLVM_ELF_IMPORT_TYPES(target_endianness, is64Bits) \
73 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Addr Elf_Addr; \
75 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Off Elf_Off; \
77 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Half Elf_Half; \
79 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Word Elf_Word; \
81 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Sword Elf_Sword; \
83 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Xword Elf_Xword; \
85 ELFDataTypeTypedefHelper<target_endianness, is64Bits>::Elf_Sxword Elf_Sxword;
89 template<support::endianness target_endianness, bool is64Bits>
92 template<support::endianness target_endianness>
93 struct Elf_Shdr_Base<target_endianness, false> {
94 LLVM_ELF_IMPORT_TYPES(target_endianness, false)
95 Elf_Word sh_name; // Section name (index into string table)
96 Elf_Word sh_type; // Section type (SHT_*)
97 Elf_Word sh_flags; // Section flags (SHF_*)
98 Elf_Addr sh_addr; // Address where section is to be loaded
99 Elf_Off sh_offset; // File offset of section data, in bytes
100 Elf_Word sh_size; // Size of section, in bytes
101 Elf_Word sh_link; // Section type-specific header table index link
102 Elf_Word sh_info; // Section type-specific extra information
103 Elf_Word sh_addralign;// Section address alignment
104 Elf_Word sh_entsize; // Size of records contained within the section
107 template<support::endianness target_endianness>
108 struct Elf_Shdr_Base<target_endianness, true> {
109 LLVM_ELF_IMPORT_TYPES(target_endianness, true)
110 Elf_Word sh_name; // Section name (index into string table)
111 Elf_Word sh_type; // Section type (SHT_*)
112 Elf_Xword sh_flags; // Section flags (SHF_*)
113 Elf_Addr sh_addr; // Address where section is to be loaded
114 Elf_Off sh_offset; // File offset of section data, in bytes
115 Elf_Xword sh_size; // Size of section, in bytes
116 Elf_Word sh_link; // Section type-specific header table index link
117 Elf_Word sh_info; // Section type-specific extra information
118 Elf_Xword sh_addralign;// Section address alignment
119 Elf_Xword sh_entsize; // Size of records contained within the section
122 template<support::endianness target_endianness, bool is64Bits>
123 struct Elf_Shdr_Impl : Elf_Shdr_Base<target_endianness, is64Bits> {
124 using Elf_Shdr_Base<target_endianness, is64Bits>::sh_entsize;
125 using Elf_Shdr_Base<target_endianness, is64Bits>::sh_size;
127 /// @brief Get the number of entities this section contains if it has any.
128 unsigned getEntityCount() const {
131 return sh_size / sh_entsize;
137 template<support::endianness target_endianness, bool is64Bits>
140 template<support::endianness target_endianness>
141 struct Elf_Sym_Base<target_endianness, false> {
142 LLVM_ELF_IMPORT_TYPES(target_endianness, false)
143 Elf_Word st_name; // Symbol name (index into string table)
144 Elf_Addr st_value; // Value or address associated with the symbol
145 Elf_Word st_size; // Size of the symbol
146 unsigned char st_info; // Symbol's type and binding attributes
147 unsigned char st_other; // Must be zero; reserved
148 Elf_Half st_shndx; // Which section (header table index) it's defined in
151 template<support::endianness target_endianness>
152 struct Elf_Sym_Base<target_endianness, true> {
153 LLVM_ELF_IMPORT_TYPES(target_endianness, true)
154 Elf_Word st_name; // Symbol name (index into string table)
155 unsigned char st_info; // Symbol's type and binding attributes
156 unsigned char st_other; // Must be zero; reserved
157 Elf_Half st_shndx; // Which section (header table index) it's defined in
158 Elf_Addr st_value; // Value or address associated with the symbol
159 Elf_Xword st_size; // Size of the symbol
162 template<support::endianness target_endianness, bool is64Bits>
163 struct Elf_Sym_Impl : Elf_Sym_Base<target_endianness, is64Bits> {
164 using Elf_Sym_Base<target_endianness, is64Bits>::st_info;
166 // These accessors and mutators correspond to the ELF32_ST_BIND,
167 // ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification:
168 unsigned char getBinding() const { return st_info >> 4; }
169 unsigned char getType() const { return st_info & 0x0f; }
170 void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
171 void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
172 void setBindingAndType(unsigned char b, unsigned char t) {
173 st_info = (b << 4) + (t & 0x0f);
179 template<support::endianness target_endianness, bool is64Bits>
180 class ELFObjectFile : public ObjectFile {
181 LLVM_ELF_IMPORT_TYPES(target_endianness, is64Bits)
183 typedef Elf_Shdr_Impl<target_endianness, is64Bits> Elf_Shdr;
184 typedef Elf_Sym_Impl<target_endianness, is64Bits> Elf_Sym;
187 unsigned char e_ident[ELF::EI_NIDENT]; // ELF Identification bytes
188 Elf_Half e_type; // Type of file (see ET_*)
189 Elf_Half e_machine; // Required architecture for this file (see EM_*)
190 Elf_Word e_version; // Must be equal to 1
191 Elf_Addr e_entry; // Address to jump to in order to start program
192 Elf_Off e_phoff; // Program header table's file offset, in bytes
193 Elf_Off e_shoff; // Section header table's file offset, in bytes
194 Elf_Word e_flags; // Processor-specific flags
195 Elf_Half e_ehsize; // Size of ELF header, in bytes
196 Elf_Half e_phentsize;// Size of an entry in the program header table
197 Elf_Half e_phnum; // Number of entries in the program header table
198 Elf_Half e_shentsize;// Size of an entry in the section header table
199 Elf_Half e_shnum; // Number of entries in the section header table
200 Elf_Half e_shstrndx; // Section header table index of section name
202 bool checkMagic() const {
203 return (memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
205 unsigned char getFileClass() const { return e_ident[ELF::EI_CLASS]; }
206 unsigned char getDataEncoding() const { return e_ident[ELF::EI_DATA]; }
209 typedef SmallVector<const Elf_Shdr*, 1> SymbolTableSections_t;
211 const Elf_Ehdr *Header;
212 const Elf_Shdr *SectionHeaderTable;
213 const Elf_Shdr *dot_shstrtab_sec; // Section header string table.
214 const Elf_Shdr *dot_strtab_sec; // Symbol header string table.
215 SymbolTableSections_t SymbolTableSections;
217 void validateSymbol(DataRefImpl Symb) const;
218 const Elf_Sym *getSymbol(DataRefImpl Symb) const;
219 const Elf_Shdr *getSection(DataRefImpl index) const;
220 const Elf_Shdr *getSection(uint16_t index) const;
221 const char *getString(uint16_t section, uint32_t offset) const;
222 const char *getString(const Elf_Shdr *section, uint32_t offset) const;
225 virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const;
226 virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const;
227 virtual error_code getSymbolAddress(DataRefImpl Symb, uint64_t &Res) const;
228 virtual error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const;
229 virtual error_code getSymbolNMTypeChar(DataRefImpl Symb, char &Res) const;
230 virtual error_code isSymbolInternal(DataRefImpl Symb, bool &Res) const;
232 virtual error_code getSectionNext(DataRefImpl Sec, SectionRef &Res) const;
233 virtual error_code getSectionName(DataRefImpl Sec, StringRef &Res) const;
234 virtual error_code getSectionAddress(DataRefImpl Sec, uint64_t &Res) const;
235 virtual error_code getSectionSize(DataRefImpl Sec, uint64_t &Res) const;
236 virtual error_code getSectionContents(DataRefImpl Sec, StringRef &Res) const;
237 virtual error_code isSectionText(DataRefImpl Sec, bool &Res) const;
238 virtual error_code sectionContainsSymbol(DataRefImpl Sec, DataRefImpl Symb,
242 ELFObjectFile(MemoryBuffer *Object, error_code &ec);
243 virtual symbol_iterator begin_symbols() const;
244 virtual symbol_iterator end_symbols() const;
245 virtual section_iterator begin_sections() const;
246 virtual section_iterator end_sections() const;
248 virtual uint8_t getBytesInAddress() const;
249 virtual StringRef getFileFormatName() const;
250 virtual unsigned getArch() const;
254 template<support::endianness target_endianness, bool is64Bits>
255 void ELFObjectFile<target_endianness, is64Bits>
256 ::validateSymbol(DataRefImpl Symb) const {
257 const Elf_Sym *symb = getSymbol(Symb);
258 const Elf_Shdr *SymbolTableSection = SymbolTableSections[Symb.d.b];
259 // FIXME: We really need to do proper error handling in the case of an invalid
260 // input file. Because we don't use exceptions, I think we'll just pass
261 // an error object around.
263 && SymbolTableSection
264 && symb >= (const Elf_Sym*)(base()
265 + SymbolTableSection->sh_offset)
266 && symb < (const Elf_Sym*)(base()
267 + SymbolTableSection->sh_offset
268 + SymbolTableSection->sh_size)))
269 // FIXME: Proper error handling.
270 report_fatal_error("Symb must point to a valid symbol!");
273 template<support::endianness target_endianness, bool is64Bits>
274 error_code ELFObjectFile<target_endianness, is64Bits>
275 ::getSymbolNext(DataRefImpl Symb,
276 SymbolRef &Result) const {
277 validateSymbol(Symb);
278 const Elf_Shdr *SymbolTableSection = SymbolTableSections[Symb.d.b];
281 // Check to see if we are at the end of this symbol table.
282 if (Symb.d.a >= SymbolTableSection->getEntityCount()) {
283 // We are at the end. If there are other symbol tables, jump to them.
285 Symb.d.a = 1; // The 0th symbol in ELF is fake.
286 // Otherwise return the terminator.
287 if (Symb.d.b >= SymbolTableSections.size()) {
288 Symb.d.a = std::numeric_limits<uint32_t>::max();
289 Symb.d.b = std::numeric_limits<uint32_t>::max();
293 Result = SymbolRef(Symb, this);
294 return object_error::success;
297 template<support::endianness target_endianness, bool is64Bits>
298 error_code ELFObjectFile<target_endianness, is64Bits>
299 ::getSymbolName(DataRefImpl Symb,
300 StringRef &Result) const {
301 validateSymbol(Symb);
302 const Elf_Sym *symb = getSymbol(Symb);
303 if (symb->st_name == 0) {
304 const Elf_Shdr *section = getSection(symb->st_shndx);
308 Result = getString(dot_shstrtab_sec, section->sh_name);
309 return object_error::success;
312 // Use the default symbol table name section.
313 Result = getString(dot_strtab_sec, symb->st_name);
314 return object_error::success;
317 template<support::endianness target_endianness, bool is64Bits>
318 error_code ELFObjectFile<target_endianness, is64Bits>
319 ::getSymbolAddress(DataRefImpl Symb,
320 uint64_t &Result) const {
321 validateSymbol(Symb);
322 const Elf_Sym *symb = getSymbol(Symb);
323 const Elf_Shdr *Section;
324 switch (symb->st_shndx) {
325 case ELF::SHN_COMMON:
326 // Undefined symbols have no address yet.
328 Result = UnknownAddressOrSize;
329 return object_error::success;
331 Result = symb->st_value;
332 return object_error::success;
333 default: Section = getSection(symb->st_shndx);
336 switch (symb->getType()) {
337 case ELF::STT_SECTION:
338 Result = Section ? Section->sh_addr : UnknownAddressOrSize;
339 return object_error::success;
341 case ELF::STT_OBJECT:
342 case ELF::STT_NOTYPE:
343 Result = symb->st_value;
344 return object_error::success;
346 Result = UnknownAddressOrSize;
347 return object_error::success;
351 template<support::endianness target_endianness, bool is64Bits>
352 error_code ELFObjectFile<target_endianness, is64Bits>
353 ::getSymbolSize(DataRefImpl Symb,
354 uint64_t &Result) const {
355 validateSymbol(Symb);
356 const Elf_Sym *symb = getSymbol(Symb);
357 if (symb->st_size == 0)
358 Result = UnknownAddressOrSize;
359 Result = symb->st_size;
360 return object_error::success;
363 template<support::endianness target_endianness, bool is64Bits>
364 error_code ELFObjectFile<target_endianness, is64Bits>
365 ::getSymbolNMTypeChar(DataRefImpl Symb,
366 char &Result) const {
367 validateSymbol(Symb);
368 const Elf_Sym *symb = getSymbol(Symb);
369 const Elf_Shdr *Section = getSection(symb->st_shndx);
374 switch (Section->sh_type) {
375 case ELF::SHT_PROGBITS:
376 case ELF::SHT_DYNAMIC:
377 switch (Section->sh_flags) {
378 case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR):
380 case (ELF::SHF_ALLOC | ELF::SHF_WRITE):
383 case (ELF::SHF_ALLOC | ELF::SHF_MERGE):
384 case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS):
388 case ELF::SHT_NOBITS: ret = 'b';
392 switch (symb->st_shndx) {
397 case ELF::SHN_ABS: ret = 'a'; break;
398 case ELF::SHN_COMMON: ret = 'c'; break;
401 switch (symb->getBinding()) {
402 case ELF::STB_GLOBAL: ret = ::toupper(ret); break;
404 if (symb->st_shndx == ELF::SHN_UNDEF)
407 if (symb->getType() == ELF::STT_OBJECT)
413 if (ret == '?' && symb->getType() == ELF::STT_SECTION) {
415 if (error_code ec = getSymbolName(Symb, name))
417 Result = StringSwitch<char>(name)
418 .StartsWith(".debug", 'N')
419 .StartsWith(".note", 'n');
420 return object_error::success;
424 return object_error::success;
427 template<support::endianness target_endianness, bool is64Bits>
428 error_code ELFObjectFile<target_endianness, is64Bits>
429 ::isSymbolInternal(DataRefImpl Symb,
430 bool &Result) const {
431 validateSymbol(Symb);
432 const Elf_Sym *symb = getSymbol(Symb);
434 if ( symb->getType() == ELF::STT_FILE
435 || symb->getType() == ELF::STT_SECTION)
438 return object_error::success;
441 template<support::endianness target_endianness, bool is64Bits>
442 error_code ELFObjectFile<target_endianness, is64Bits>
443 ::getSectionNext(DataRefImpl Sec, SectionRef &Result) const {
444 const uint8_t *sec = reinterpret_cast<const uint8_t *>(Sec.p);
445 sec += Header->e_shentsize;
446 Sec.p = reinterpret_cast<intptr_t>(sec);
447 Result = SectionRef(Sec, this);
448 return object_error::success;
451 template<support::endianness target_endianness, bool is64Bits>
452 error_code ELFObjectFile<target_endianness, is64Bits>
453 ::getSectionName(DataRefImpl Sec,
454 StringRef &Result) const {
455 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p);
456 Result = StringRef(getString(dot_shstrtab_sec, sec->sh_name));
457 return object_error::success;
460 template<support::endianness target_endianness, bool is64Bits>
461 error_code ELFObjectFile<target_endianness, is64Bits>
462 ::getSectionAddress(DataRefImpl Sec,
463 uint64_t &Result) const {
464 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p);
465 Result = sec->sh_addr;
466 return object_error::success;
469 template<support::endianness target_endianness, bool is64Bits>
470 error_code ELFObjectFile<target_endianness, is64Bits>
471 ::getSectionSize(DataRefImpl Sec,
472 uint64_t &Result) const {
473 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p);
474 Result = sec->sh_size;
475 return object_error::success;
478 template<support::endianness target_endianness, bool is64Bits>
479 error_code ELFObjectFile<target_endianness, is64Bits>
480 ::getSectionContents(DataRefImpl Sec,
481 StringRef &Result) const {
482 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p);
483 const char *start = (const char*)base() + sec->sh_offset;
484 Result = StringRef(start, sec->sh_size);
485 return object_error::success;
488 template<support::endianness target_endianness, bool is64Bits>
489 error_code ELFObjectFile<target_endianness, is64Bits>
490 ::isSectionText(DataRefImpl Sec,
491 bool &Result) const {
492 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p);
493 if (sec->sh_flags & ELF::SHF_EXECINSTR)
497 return object_error::success;
500 template<support::endianness target_endianness, bool is64Bits>
501 error_code ELFObjectFile<target_endianness, is64Bits>
502 ::sectionContainsSymbol(DataRefImpl Sec,
504 bool &Result) const {
505 // FIXME: Unimplemented.
507 return object_error::success;
510 template<support::endianness target_endianness, bool is64Bits>
511 ELFObjectFile<target_endianness, is64Bits>::ELFObjectFile(MemoryBuffer *Object
513 : ObjectFile(Binary::isELF, Object, ec)
514 , SectionHeaderTable(0)
515 , dot_shstrtab_sec(0)
516 , dot_strtab_sec(0) {
517 Header = reinterpret_cast<const Elf_Ehdr *>(base());
519 if (Header->e_shoff == 0)
523 reinterpret_cast<const Elf_Shdr *>(base() + Header->e_shoff);
524 uint32_t SectionTableSize = Header->e_shnum * Header->e_shentsize;
525 if (!( (const uint8_t *)SectionHeaderTable + SectionTableSize
526 <= base() + Data->getBufferSize()))
527 // FIXME: Proper error handling.
528 report_fatal_error("Section table goes past end of file!");
531 // To find the symbol tables we walk the section table to find SHT_STMTAB.
532 for (const char *i = reinterpret_cast<const char *>(SectionHeaderTable),
533 *e = i + Header->e_shnum * Header->e_shentsize;
534 i != e; i += Header->e_shentsize) {
535 const Elf_Shdr *sh = reinterpret_cast<const Elf_Shdr*>(i);
536 if (sh->sh_type == ELF::SHT_SYMTAB) {
537 SymbolTableSections.push_back(sh);
541 // Get string table sections.
542 dot_shstrtab_sec = getSection(Header->e_shstrndx);
543 if (dot_shstrtab_sec) {
544 // Verify that the last byte in the string table in a null.
545 if (((const char*)base() + dot_shstrtab_sec->sh_offset)
546 [dot_shstrtab_sec->sh_size - 1] != 0)
547 // FIXME: Proper error handling.
548 report_fatal_error("String table must end with a null terminator!");
551 // Merge this into the above loop.
552 for (const char *i = reinterpret_cast<const char *>(SectionHeaderTable),
553 *e = i + Header->e_shnum * Header->e_shentsize;
554 i != e; i += Header->e_shentsize) {
555 const Elf_Shdr *sh = reinterpret_cast<const Elf_Shdr*>(i);
556 if (sh->sh_type == ELF::SHT_STRTAB) {
557 StringRef SectionName(getString(dot_shstrtab_sec, sh->sh_name));
558 if (SectionName == ".strtab") {
559 if (dot_strtab_sec != 0)
560 // FIXME: Proper error handling.
561 report_fatal_error("Already found section named .strtab!");
563 const char *dot_strtab = (const char*)base() + sh->sh_offset;
564 if (dot_strtab[sh->sh_size - 1] != 0)
565 // FIXME: Proper error handling.
566 report_fatal_error("String table must end with a null terminator!");
572 template<support::endianness target_endianness, bool is64Bits>
573 ObjectFile::symbol_iterator ELFObjectFile<target_endianness, is64Bits>
574 ::begin_symbols() const {
575 DataRefImpl SymbolData;
576 memset(&SymbolData, 0, sizeof(SymbolData));
577 if (SymbolTableSections.size() == 0) {
578 SymbolData.d.a = std::numeric_limits<uint32_t>::max();
579 SymbolData.d.b = std::numeric_limits<uint32_t>::max();
581 SymbolData.d.a = 1; // The 0th symbol in ELF is fake.
584 return symbol_iterator(SymbolRef(SymbolData, this));
587 template<support::endianness target_endianness, bool is64Bits>
588 ObjectFile::symbol_iterator ELFObjectFile<target_endianness, is64Bits>
589 ::end_symbols() const {
590 DataRefImpl SymbolData;
591 memset(&SymbolData, 0, sizeof(SymbolData));
592 SymbolData.d.a = std::numeric_limits<uint32_t>::max();
593 SymbolData.d.b = std::numeric_limits<uint32_t>::max();
594 return symbol_iterator(SymbolRef(SymbolData, this));
597 template<support::endianness target_endianness, bool is64Bits>
598 ObjectFile::section_iterator ELFObjectFile<target_endianness, is64Bits>
599 ::begin_sections() const {
601 memset(&ret, 0, sizeof(DataRefImpl));
602 ret.p = reinterpret_cast<intptr_t>(base() + Header->e_shoff);
603 return section_iterator(SectionRef(ret, this));
606 template<support::endianness target_endianness, bool is64Bits>
607 ObjectFile::section_iterator ELFObjectFile<target_endianness, is64Bits>
608 ::end_sections() const {
610 memset(&ret, 0, sizeof(DataRefImpl));
611 ret.p = reinterpret_cast<intptr_t>(base()
613 + (Header->e_shentsize * Header->e_shnum));
614 return section_iterator(SectionRef(ret, this));
617 template<support::endianness target_endianness, bool is64Bits>
618 uint8_t ELFObjectFile<target_endianness, is64Bits>::getBytesInAddress() const {
619 return is64Bits ? 8 : 4;
622 template<support::endianness target_endianness, bool is64Bits>
623 StringRef ELFObjectFile<target_endianness, is64Bits>
624 ::getFileFormatName() const {
625 switch(Header->e_ident[ELF::EI_CLASS]) {
626 case ELF::ELFCLASS32:
627 switch(Header->e_machine) {
631 return "ELF32-x86-64";
633 return "ELF32-unknown";
635 case ELF::ELFCLASS64:
636 switch(Header->e_machine) {
640 return "ELF64-x86-64";
642 return "ELF64-unknown";
645 // FIXME: Proper error handling.
646 report_fatal_error("Invalid ELFCLASS!");
650 template<support::endianness target_endianness, bool is64Bits>
651 unsigned ELFObjectFile<target_endianness, is64Bits>::getArch() const {
652 switch(Header->e_machine) {
656 return Triple::x86_64;
658 return Triple::UnknownArch;
662 template<support::endianness target_endianness, bool is64Bits>
663 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Sym *
664 ELFObjectFile<target_endianness, is64Bits>::getSymbol(DataRefImpl Symb) const {
665 const Elf_Shdr *sec = SymbolTableSections[Symb.d.b];
666 return reinterpret_cast<const Elf_Sym *>(
669 + (Symb.d.a * sec->sh_entsize));
672 template<support::endianness target_endianness, bool is64Bits>
673 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Shdr *
674 ELFObjectFile<target_endianness, is64Bits>::getSection(DataRefImpl Symb) const {
675 const Elf_Shdr *sec = getSection(Symb.d.b);
676 if (sec->sh_type != ELF::SHT_SYMTAB)
677 // FIXME: Proper error handling.
678 report_fatal_error("Invalid symbol table section!");
682 template<support::endianness target_endianness, bool is64Bits>
683 const typename ELFObjectFile<target_endianness, is64Bits>::Elf_Shdr *
684 ELFObjectFile<target_endianness, is64Bits>::getSection(uint16_t index) const {
685 if (index == 0 || index >= ELF::SHN_LORESERVE)
687 if (!SectionHeaderTable || index >= Header->e_shnum)
688 // FIXME: Proper error handling.
689 report_fatal_error("Invalid section index!");
691 return reinterpret_cast<const Elf_Shdr *>(
692 reinterpret_cast<const char *>(SectionHeaderTable)
693 + (index * Header->e_shentsize));
696 template<support::endianness target_endianness, bool is64Bits>
697 const char *ELFObjectFile<target_endianness, is64Bits>
698 ::getString(uint16_t section,
699 ELF::Elf32_Word offset) const {
700 return getString(getSection(section), offset);
703 template<support::endianness target_endianness, bool is64Bits>
704 const char *ELFObjectFile<target_endianness, is64Bits>
705 ::getString(const Elf_Shdr *section,
706 ELF::Elf32_Word offset) const {
707 assert(section && section->sh_type == ELF::SHT_STRTAB && "Invalid section!");
708 if (offset >= section->sh_size)
709 // FIXME: Proper error handling.
710 report_fatal_error("Symbol name offset outside of string table!");
711 return (const char *)base() + section->sh_offset + offset;
714 // EI_CLASS, EI_DATA.
715 static std::pair<unsigned char, unsigned char>
716 getElfArchType(MemoryBuffer *Object) {
717 if (Object->getBufferSize() < ELF::EI_NIDENT)
718 return std::make_pair((uint8_t)ELF::ELFCLASSNONE,(uint8_t)ELF::ELFDATANONE);
719 return std::make_pair( (uint8_t)Object->getBufferStart()[ELF::EI_CLASS]
720 , (uint8_t)Object->getBufferStart()[ELF::EI_DATA]);
725 ObjectFile *ObjectFile::createELFObjectFile(MemoryBuffer *Object) {
726 std::pair<unsigned char, unsigned char> Ident = getElfArchType(Object);
728 if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB)
729 return new ELFObjectFile<support::little, false>(Object, ec);
730 else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB)
731 return new ELFObjectFile<support::big, false>(Object, ec);
732 else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB)
733 return new ELFObjectFile<support::little, true>(Object, ec);
734 else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB)
735 return new ELFObjectFile<support::big, true>(Object, ec);
736 // FIXME: Proper error handling.
737 report_fatal_error("Not an ELF object file!");
740 } // end namespace llvm