Remove getRelocationAddress.
[oota-llvm.git] / include / llvm / Object / ELFObjectFile.h
1 //===- ELFObjectFile.h - ELF object file implementation ---------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file declares the ELFObjectFile template class.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_OBJECT_ELFOBJECTFILE_H
15 #define LLVM_OBJECT_ELFOBJECTFILE_H
16
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/PointerIntPair.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/Object/ELF.h"
23 #include "llvm/Object/ObjectFile.h"
24 #include "llvm/Support/Casting.h"
25 #include "llvm/Support/ELF.h"
26 #include "llvm/Support/Endian.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/raw_ostream.h"
30 #include <algorithm>
31 #include <cctype>
32 #include <limits>
33 #include <utility>
34
35 namespace llvm {
36 namespace object {
37
38 class elf_symbol_iterator;
39 class ELFSymbolRef;
40 class ELFRelocationRef;
41
42 class ELFObjectFileBase : public ObjectFile {
43   friend class ELFSymbolRef;
44   friend class ELFSectionRef;
45   friend class ELFRelocationRef;
46
47 protected:
48   ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source);
49
50   virtual uint64_t getSymbolSize(DataRefImpl Symb) const = 0;
51   virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0;
52   virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0;
53
54   virtual uint32_t getSectionType(DataRefImpl Sec) const = 0;
55   virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0;
56
57   virtual ErrorOr<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
58 public:
59
60   typedef iterator_range<elf_symbol_iterator> elf_symbol_iterator_range;
61   virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
62
63   elf_symbol_iterator_range symbols() const;
64
65   static inline bool classof(const Binary *v) { return v->isELF(); }
66 };
67
68 class ELFSectionRef : public SectionRef {
69 public:
70   ELFSectionRef(const SectionRef &B) : SectionRef(B) {
71     assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
72   }
73
74   const ELFObjectFileBase *getObject() const {
75     return cast<ELFObjectFileBase>(SectionRef::getObject());
76   }
77
78   uint32_t getType() const {
79     return getObject()->getSectionType(getRawDataRefImpl());
80   }
81
82   uint64_t getFlags() const {
83     return getObject()->getSectionFlags(getRawDataRefImpl());
84   }
85 };
86
87 class elf_section_iterator : public section_iterator {
88 public:
89   elf_section_iterator(const section_iterator &B) : section_iterator(B) {
90     assert(isa<ELFObjectFileBase>(B->getObject()));
91   }
92
93   const ELFSectionRef *operator->() const {
94     return static_cast<const ELFSectionRef *>(section_iterator::operator->());
95   }
96
97   const ELFSectionRef &operator*() const {
98     return static_cast<const ELFSectionRef &>(section_iterator::operator*());
99   }
100 };
101
102 class ELFSymbolRef : public SymbolRef {
103 public:
104   ELFSymbolRef(const SymbolRef &B) : SymbolRef(B) {
105     assert(isa<ELFObjectFileBase>(SymbolRef::getObject()));
106   }
107
108   const ELFObjectFileBase *getObject() const {
109     return cast<ELFObjectFileBase>(BasicSymbolRef::getObject());
110   }
111
112   uint64_t getSize() const {
113     return getObject()->getSymbolSize(getRawDataRefImpl());
114   }
115
116   uint8_t getOther() const {
117     return getObject()->getSymbolOther(getRawDataRefImpl());
118   }
119
120   uint8_t getELFType() const {
121     return getObject()->getSymbolELFType(getRawDataRefImpl());
122   }
123 };
124
125 class elf_symbol_iterator : public symbol_iterator {
126 public:
127   elf_symbol_iterator(const basic_symbol_iterator &B)
128       : symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
129                                   cast<ELFObjectFileBase>(B->getObject()))) {}
130
131   const ELFSymbolRef *operator->() const {
132     return static_cast<const ELFSymbolRef *>(symbol_iterator::operator->());
133   }
134
135   const ELFSymbolRef &operator*() const {
136     return static_cast<const ELFSymbolRef &>(symbol_iterator::operator*());
137   }
138 };
139
140 class ELFRelocationRef : public RelocationRef {
141 public:
142   ELFRelocationRef(const RelocationRef &B) : RelocationRef(B) {
143     assert(isa<ELFObjectFileBase>(RelocationRef::getObject()));
144   }
145
146   const ELFObjectFileBase *getObject() const {
147     return cast<ELFObjectFileBase>(RelocationRef::getObject());
148   }
149
150   ErrorOr<int64_t> getAddend() const {
151     return getObject()->getRelocationAddend(getRawDataRefImpl());
152   }
153 };
154
155 class elf_relocation_iterator : public relocation_iterator {
156 public:
157   elf_relocation_iterator(const relocation_iterator &B)
158       : relocation_iterator(RelocationRef(
159             B->getRawDataRefImpl(), cast<ELFObjectFileBase>(B->getObject()))) {}
160
161   const ELFRelocationRef *operator->() const {
162     return static_cast<const ELFRelocationRef *>(
163         relocation_iterator::operator->());
164   }
165
166   const ELFRelocationRef &operator*() const {
167     return static_cast<const ELFRelocationRef &>(
168         relocation_iterator::operator*());
169   }
170 };
171
172 inline ELFObjectFileBase::elf_symbol_iterator_range
173 ELFObjectFileBase::symbols() const {
174   return elf_symbol_iterator_range(symbol_begin(), symbol_end());
175 }
176
177 template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
178   uint64_t getSymbolSize(DataRefImpl Sym) const override;
179
180 public:
181   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
182
183   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
184
185   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
186   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
187   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
188   typedef typename ELFFile<ELFT>::Elf_Rel Elf_Rel;
189   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
190   typedef typename ELFFile<ELFT>::Elf_Dyn Elf_Dyn;
191
192   typedef typename ELFFile<ELFT>::Elf_Dyn_Iter Elf_Dyn_Iter;
193
194 protected:
195   ELFFile<ELFT> EF;
196
197   void moveSymbolNext(DataRefImpl &Symb) const override;
198   ErrorOr<StringRef> getSymbolName(DataRefImpl Symb) const override;
199   ErrorOr<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
200   uint64_t getSymbolValue(DataRefImpl Symb) const override;
201   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
202   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
203   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
204   uint8_t getSymbolOther(DataRefImpl Symb) const override;
205   uint8_t getSymbolELFType(DataRefImpl Symb) const override;
206   SymbolRef::Type getSymbolType(DataRefImpl Symb) const override;
207   section_iterator getSymbolSection(const Elf_Sym *Symb) const;
208   std::error_code getSymbolSection(DataRefImpl Symb,
209                                    section_iterator &Res) const override;
210
211   void moveSectionNext(DataRefImpl &Sec) const override;
212   std::error_code getSectionName(DataRefImpl Sec,
213                                  StringRef &Res) const override;
214   uint64_t getSectionAddress(DataRefImpl Sec) const override;
215   uint64_t getSectionSize(DataRefImpl Sec) const override;
216   std::error_code getSectionContents(DataRefImpl Sec,
217                                      StringRef &Res) const override;
218   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
219   bool isSectionText(DataRefImpl Sec) const override;
220   bool isSectionData(DataRefImpl Sec) const override;
221   bool isSectionBSS(DataRefImpl Sec) const override;
222   bool isSectionVirtual(DataRefImpl Sec) const override;
223   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
224   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
225   section_iterator getRelocatedSection(DataRefImpl Sec) const override;
226
227   void moveRelocationNext(DataRefImpl &Rel) const override;
228   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
229   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
230   uint64_t getRelocationType(DataRefImpl Rel) const override;
231   void getRelocationTypeName(DataRefImpl Rel,
232                              SmallVectorImpl<char> &Result) const override;
233
234   uint32_t getSectionType(DataRefImpl Sec) const override;
235   uint64_t getSectionFlags(DataRefImpl Sec) const override;
236   uint64_t getROffset(DataRefImpl Rel) const;
237   StringRef getRelocationTypeName(uint32_t Type) const;
238
239   /// \brief Get the relocation section that contains \a Rel.
240   const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
241     return *EF.getSection(Rel.d.a);
242   }
243
244   const Elf_Sym *toELFSymIter(DataRefImpl Sym) const {
245     return EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
246   }
247
248   DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
249     DataRefImpl DRI;
250     if (!SymTable) {
251       DRI.d.a = 0;
252       DRI.d.b = 0;
253       return DRI;
254     }
255     assert(SymTable->sh_type == ELF::SHT_SYMTAB ||
256            SymTable->sh_type == ELF::SHT_DYNSYM);
257
258     uintptr_t SHT = reinterpret_cast<uintptr_t>(EF.section_begin());
259     unsigned SymTableIndex =
260         (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr);
261
262     DRI.d.a = SymTableIndex;
263     DRI.d.b = SymbolNum;
264     return DRI;
265   }
266
267   const Elf_Shdr *toELFShdrIter(DataRefImpl Sec) const {
268     return reinterpret_cast<const Elf_Shdr *>(Sec.p);
269   }
270
271   DataRefImpl toDRI(const Elf_Shdr *Sec) const {
272     DataRefImpl DRI;
273     DRI.p = reinterpret_cast<uintptr_t>(Sec);
274     return DRI;
275   }
276
277   DataRefImpl toDRI(Elf_Dyn_Iter Dyn) const {
278     DataRefImpl DRI;
279     DRI.p = reinterpret_cast<uintptr_t>(Dyn.get());
280     return DRI;
281   }
282
283   bool isExportedToOtherDSO(const Elf_Sym *ESym) const {
284     unsigned char Binding = ESym->getBinding();
285     unsigned char Visibility = ESym->getVisibility();
286
287     // A symbol is exported if its binding is either GLOBAL or WEAK, and its
288     // visibility is either DEFAULT or PROTECTED. All other symbols are not
289     // exported.
290     if ((Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK) &&
291         (Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_PROTECTED))
292       return true;
293
294     return false;
295   }
296
297   // This flag is used for classof, to distinguish ELFObjectFile from
298   // its subclass. If more subclasses will be created, this flag will
299   // have to become an enum.
300   bool isDyldELFObject;
301
302 public:
303   ELFObjectFile(MemoryBufferRef Object, std::error_code &EC);
304
305   const Elf_Rel *getRel(DataRefImpl Rel) const;
306   const Elf_Rela *getRela(DataRefImpl Rela) const;
307
308   const Elf_Sym *getSymbol(DataRefImpl Symb) const;
309
310   basic_symbol_iterator symbol_begin_impl() const override;
311   basic_symbol_iterator symbol_end_impl() const override;
312
313   elf_symbol_iterator dynamic_symbol_begin() const;
314   elf_symbol_iterator dynamic_symbol_end() const;
315
316   section_iterator section_begin() const override;
317   section_iterator section_end() const override;
318
319   ErrorOr<int64_t> getRelocationAddend(DataRefImpl Rel) const override;
320
321   uint8_t getBytesInAddress() const override;
322   StringRef getFileFormatName() const override;
323   unsigned getArch() const override;
324   StringRef getLoadName() const;
325
326   std::error_code getPlatformFlags(unsigned &Result) const override {
327     Result = EF.getHeader()->e_flags;
328     return std::error_code();
329   }
330
331   const ELFFile<ELFT> *getELFFile() const { return &EF; }
332
333   bool isDyldType() const { return isDyldELFObject; }
334   static inline bool classof(const Binary *v) {
335     return v->getType() == getELFType(ELFT::TargetEndianness == support::little,
336                                       ELFT::Is64Bits);
337   }
338
339   elf_symbol_iterator_range getDynamicSymbolIterators() const override;
340
341   bool isRelocatableObject() const override;
342 };
343
344 typedef ELFObjectFile<ELFType<support::little, false>> ELF32LEObjectFile;
345 typedef ELFObjectFile<ELFType<support::little, true>> ELF64LEObjectFile;
346 typedef ELFObjectFile<ELFType<support::big, false>> ELF32BEObjectFile;
347 typedef ELFObjectFile<ELFType<support::big, true>> ELF64BEObjectFile;
348
349 template <class ELFT>
350 void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const {
351   ++Sym.d.b;
352 }
353
354 template <class ELFT>
355 ErrorOr<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const {
356   const Elf_Sym *ESym = toELFSymIter(Sym);
357   const Elf_Shdr *SymTableSec = *EF.getSection(Sym.d.a);
358   const Elf_Shdr *StringTableSec = *EF.getSection(SymTableSec->sh_link);
359   StringRef SymTable = *EF.getStringTable(StringTableSec);
360   return ESym->getName(SymTable);
361 }
362
363 template <class ELFT>
364 uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const {
365   return toELFShdrIter(Sec)->sh_flags;
366 }
367
368 template <class ELFT>
369 uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const {
370   return toELFShdrIter(Sec)->sh_type;
371 }
372
373 template <class ELFT>
374 uint64_t ELFObjectFile<ELFT>::getSymbolValue(DataRefImpl Symb) const {
375   const Elf_Sym *ESym = getSymbol(Symb);
376   switch (ESym->st_shndx) {
377   case ELF::SHN_COMMON:
378   case ELF::SHN_UNDEF:
379     return UnknownAddress;
380   case ELF::SHN_ABS:
381     return ESym->st_value;
382   }
383
384   const Elf_Ehdr *Header = EF.getHeader();
385   uint64_t Ret = ESym->st_value;
386
387   // Clear the ARM/Thumb or microMIPS indicator flag.
388   if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) &&
389       ESym->getType() == ELF::STT_FUNC)
390     Ret &= ~1;
391
392   return Ret;
393 }
394
395 template <class ELFT>
396 ErrorOr<uint64_t>
397 ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
398   uint64_t Result = getSymbolValue(Symb);
399   const Elf_Sym *ESym = getSymbol(Symb);
400   switch (ESym->st_shndx) {
401   case ELF::SHN_COMMON:
402   case ELF::SHN_UNDEF:
403   case ELF::SHN_ABS:
404     return Result;
405   }
406
407   const Elf_Ehdr *Header = EF.getHeader();
408
409   if (Header->e_type == ELF::ET_REL) {
410     ErrorOr<const Elf_Shdr *> SectionOrErr = EF.getSection(ESym);
411     if (std::error_code EC = SectionOrErr.getError())
412       return EC;
413     const Elf_Shdr *Section = *SectionOrErr;
414     if (Section)
415       Result += Section->sh_addr;
416   }
417
418   return Result;
419 }
420
421 template <class ELFT>
422 uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const {
423   const Elf_Sym *Sym = toELFSymIter(Symb);
424   if (Sym->st_shndx == ELF::SHN_COMMON)
425     return Sym->st_value;
426   return 0;
427 }
428
429 template <class ELFT>
430 uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const {
431   return toELFSymIter(Sym)->st_size;
432 }
433
434 template <class ELFT>
435 uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
436   return toELFSymIter(Symb)->st_size;
437 }
438
439 template <class ELFT>
440 uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const {
441   return toELFSymIter(Symb)->st_other;
442 }
443
444 template <class ELFT>
445 uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const {
446   return toELFSymIter(Symb)->getType();
447 }
448
449 template <class ELFT>
450 SymbolRef::Type ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const {
451   const Elf_Sym *ESym = getSymbol(Symb);
452
453   switch (ESym->getType()) {
454   case ELF::STT_NOTYPE:
455     return SymbolRef::ST_Unknown;
456   case ELF::STT_SECTION:
457     return SymbolRef::ST_Debug;
458   case ELF::STT_FILE:
459     return SymbolRef::ST_File;
460   case ELF::STT_FUNC:
461     return SymbolRef::ST_Function;
462   case ELF::STT_OBJECT:
463   case ELF::STT_COMMON:
464   case ELF::STT_TLS:
465     return SymbolRef::ST_Data;
466   default:
467     return SymbolRef::ST_Other;
468   }
469 }
470
471 template <class ELFT>
472 uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
473   const Elf_Sym *ESym = toELFSymIter(Sym);
474
475   uint32_t Result = SymbolRef::SF_None;
476
477   if (ESym->getBinding() != ELF::STB_LOCAL)
478     Result |= SymbolRef::SF_Global;
479
480   if (ESym->getBinding() == ELF::STB_WEAK)
481     Result |= SymbolRef::SF_Weak;
482
483   if (ESym->st_shndx == ELF::SHN_ABS)
484     Result |= SymbolRef::SF_Absolute;
485
486   if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION ||
487       ESym == EF.symbol_begin() || ESym == EF.dynamic_symbol_begin())
488     Result |= SymbolRef::SF_FormatSpecific;
489
490   if (EF.getHeader()->e_machine == ELF::EM_ARM) {
491     if (ErrorOr<StringRef> NameOrErr = getSymbolName(Sym)) {
492       StringRef Name = *NameOrErr;
493       if (Name.startswith("$d") || Name.startswith("$t") ||
494           Name.startswith("$a"))
495         Result |= SymbolRef::SF_FormatSpecific;
496     }
497   }
498
499   if (ESym->st_shndx == ELF::SHN_UNDEF)
500     Result |= SymbolRef::SF_Undefined;
501
502   if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON)
503     Result |= SymbolRef::SF_Common;
504
505   if (isExportedToOtherDSO(ESym))
506     Result |= SymbolRef::SF_Exported;
507
508   if (ESym->getVisibility() == ELF::STV_HIDDEN)
509     Result |= SymbolRef::SF_Hidden;
510
511   return Result;
512 }
513
514 template <class ELFT>
515 section_iterator
516 ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym) const {
517   ErrorOr<const Elf_Shdr *> ESecOrErr = EF.getSection(ESym);
518   if (std::error_code EC = ESecOrErr.getError())
519     report_fatal_error(EC.message());
520
521   const Elf_Shdr *ESec = *ESecOrErr;
522   if (!ESec)
523     return section_end();
524
525   DataRefImpl Sec;
526   Sec.p = reinterpret_cast<intptr_t>(ESec);
527   return section_iterator(SectionRef(Sec, this));
528 }
529
530 template <class ELFT>
531 std::error_code
532 ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb,
533                                       section_iterator &Res) const {
534   Res = getSymbolSection(getSymbol(Symb));
535   return std::error_code();
536 }
537
538 template <class ELFT>
539 void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
540   const Elf_Shdr *ESec = toELFShdrIter(Sec);
541   Sec = toDRI(++ESec);
542 }
543
544 template <class ELFT>
545 std::error_code ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec,
546                                                     StringRef &Result) const {
547   ErrorOr<StringRef> Name = EF.getSectionName(&*toELFShdrIter(Sec));
548   if (!Name)
549     return Name.getError();
550   Result = *Name;
551   return std::error_code();
552 }
553
554 template <class ELFT>
555 uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const {
556   return toELFShdrIter(Sec)->sh_addr;
557 }
558
559 template <class ELFT>
560 uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const {
561   return toELFShdrIter(Sec)->sh_size;
562 }
563
564 template <class ELFT>
565 std::error_code
566 ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec,
567                                         StringRef &Result) const {
568   const Elf_Shdr *EShdr = toELFShdrIter(Sec);
569   Result = StringRef((const char *)base() + EShdr->sh_offset, EShdr->sh_size);
570   return std::error_code();
571 }
572
573 template <class ELFT>
574 uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const {
575   return toELFShdrIter(Sec)->sh_addralign;
576 }
577
578 template <class ELFT>
579 bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const {
580   return toELFShdrIter(Sec)->sh_flags & ELF::SHF_EXECINSTR;
581 }
582
583 template <class ELFT>
584 bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const {
585   const Elf_Shdr *EShdr = toELFShdrIter(Sec);
586   return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) &&
587          EShdr->sh_type == ELF::SHT_PROGBITS;
588 }
589
590 template <class ELFT>
591 bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const {
592   const Elf_Shdr *EShdr = toELFShdrIter(Sec);
593   return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) &&
594          EShdr->sh_type == ELF::SHT_NOBITS;
595 }
596
597 template <class ELFT>
598 bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const {
599   return toELFShdrIter(Sec)->sh_type == ELF::SHT_NOBITS;
600 }
601
602 template <class ELFT>
603 relocation_iterator
604 ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
605   DataRefImpl RelData;
606   uintptr_t SHT = reinterpret_cast<uintptr_t>(EF.section_begin());
607   RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize;
608   RelData.d.b = 0;
609
610   const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
611   if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL)
612     return relocation_iterator(RelocationRef(RelData, this));
613
614   const Elf_Shdr *RelSec = getRelSection(RelData);
615   ErrorOr<const Elf_Shdr *> SymSecOrErr = EF.getSection(RelSec->sh_link);
616   if (std::error_code EC = SymSecOrErr.getError())
617     report_fatal_error(EC.message());
618   const Elf_Shdr *SymSec = *SymSecOrErr;
619   uint32_t SymSecType = SymSec->sh_type;
620   if (SymSecType != ELF::SHT_SYMTAB && SymSecType != ELF::SHT_DYNSYM)
621     report_fatal_error("Invalid symbol table section type!");
622   if (SymSecType == ELF::SHT_DYNSYM)
623     RelData.d.b = 1;
624
625   return relocation_iterator(RelocationRef(RelData, this));
626 }
627
628 template <class ELFT>
629 relocation_iterator
630 ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const {
631   const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
632   relocation_iterator Begin = section_rel_begin(Sec);
633   if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL)
634     return Begin;
635   DataRefImpl RelData = Begin->getRawDataRefImpl();
636   RelData.d.b += (S->sh_size / S->sh_entsize) << 1;
637   return relocation_iterator(RelocationRef(RelData, this));
638 }
639
640 template <class ELFT>
641 section_iterator
642 ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
643   if (EF.getHeader()->e_type != ELF::ET_REL)
644     return section_end();
645
646   const Elf_Shdr *EShdr = toELFShdrIter(Sec);
647   uintX_t Type = EShdr->sh_type;
648   if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
649     return section_end();
650
651   ErrorOr<const Elf_Shdr *> R = EF.getSection(EShdr->sh_info);
652   if (std::error_code EC = R.getError())
653     report_fatal_error(EC.message());
654   return section_iterator(SectionRef(toDRI(*R), this));
655 }
656
657 // Relocations
658 template <class ELFT>
659 void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const {
660   Rel.d.b += 2;
661 }
662
663 template <class ELFT>
664 symbol_iterator
665 ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const {
666   uint32_t symbolIdx;
667   const Elf_Shdr *sec = getRelSection(Rel);
668   if (sec->sh_type == ELF::SHT_REL)
669     symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL());
670   else
671     symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL());
672   if (!symbolIdx)
673     return symbol_end();
674
675   bool IsDyn = Rel.d.b & 1;
676   DataRefImpl SymbolData;
677   if (IsDyn)
678     SymbolData = toDRI(EF.getDotDynSymSec(), symbolIdx);
679   else
680     SymbolData = toDRI(EF.getDotSymtabSec(), symbolIdx);
681   return symbol_iterator(SymbolRef(SymbolData, this));
682 }
683
684 template <class ELFT>
685 uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const {
686   assert(EF.getHeader()->e_type == ELF::ET_REL &&
687          "Only relocatable object files have relocation offsets");
688   return getROffset(Rel);
689 }
690
691 template <class ELFT>
692 uint64_t ELFObjectFile<ELFT>::getROffset(DataRefImpl Rel) const {
693   const Elf_Shdr *sec = getRelSection(Rel);
694   if (sec->sh_type == ELF::SHT_REL)
695     return getRel(Rel)->r_offset;
696
697   return getRela(Rel)->r_offset;
698 }
699
700 template <class ELFT>
701 uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const {
702   const Elf_Shdr *sec = getRelSection(Rel);
703   if (sec->sh_type == ELF::SHT_REL)
704     return getRel(Rel)->getType(EF.isMips64EL());
705   else
706     return getRela(Rel)->getType(EF.isMips64EL());
707 }
708
709 template <class ELFT>
710 StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
711   return getELFRelocationTypeName(EF.getHeader()->e_machine, Type);
712 }
713
714 template <class ELFT>
715 void ELFObjectFile<ELFT>::getRelocationTypeName(
716     DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
717   uint32_t type = getRelocationType(Rel);
718   EF.getRelocationTypeName(type, Result);
719 }
720
721 template <class ELFT>
722 ErrorOr<int64_t>
723 ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const {
724   if (getRelSection(Rel)->sh_type != ELF::SHT_RELA)
725     return object_error::parse_failed;
726   return (int64_t)getRela(Rel)->r_addend;
727 }
728
729 template <class ELFT>
730 const typename ELFFile<ELFT>::Elf_Sym *
731 ELFObjectFile<ELFT>::getSymbol(DataRefImpl Symb) const {
732   return &*toELFSymIter(Symb);
733 }
734
735 template <class ELFT>
736 const typename ELFObjectFile<ELFT>::Elf_Rel *
737 ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const {
738   assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
739   return EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b >> 1);
740 }
741
742 template <class ELFT>
743 const typename ELFObjectFile<ELFT>::Elf_Rela *
744 ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const {
745   assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
746   return EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b >> 1);
747 }
748
749 template <class ELFT>
750 ELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, std::error_code &EC)
751     : ELFObjectFileBase(
752           getELFType(static_cast<endianness>(ELFT::TargetEndianness) ==
753                          support::little,
754                      ELFT::Is64Bits),
755           Object),
756       EF(Data.getBuffer(), EC) {}
757
758 template <class ELFT>
759 basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin_impl() const {
760   DataRefImpl Sym = toDRI(EF.getDotSymtabSec(), 0);
761   return basic_symbol_iterator(SymbolRef(Sym, this));
762 }
763
764 template <class ELFT>
765 basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end_impl() const {
766   const Elf_Shdr *SymTab = EF.getDotSymtabSec();
767   if (!SymTab)
768     return symbol_begin_impl();
769   DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
770   return basic_symbol_iterator(SymbolRef(Sym, this));
771 }
772
773 template <class ELFT>
774 elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const {
775   DataRefImpl Sym = toDRI(EF.getDotDynSymSec(), 0);
776   return symbol_iterator(SymbolRef(Sym, this));
777 }
778
779 template <class ELFT>
780 elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const {
781   const Elf_Shdr *SymTab = EF.getDotDynSymSec();
782   DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
783   return basic_symbol_iterator(SymbolRef(Sym, this));
784 }
785
786 template <class ELFT>
787 section_iterator ELFObjectFile<ELFT>::section_begin() const {
788   return section_iterator(SectionRef(toDRI(EF.section_begin()), this));
789 }
790
791 template <class ELFT>
792 section_iterator ELFObjectFile<ELFT>::section_end() const {
793   return section_iterator(SectionRef(toDRI(EF.section_end()), this));
794 }
795
796 template <class ELFT>
797 StringRef ELFObjectFile<ELFT>::getLoadName() const {
798   Elf_Dyn_Iter DI = EF.dynamic_table_begin();
799   Elf_Dyn_Iter DE = EF.dynamic_table_end();
800
801   while (DI != DE && DI->getTag() != ELF::DT_SONAME)
802     ++DI;
803
804   if (DI != DE)
805     return EF.getDynamicString(DI->getVal());
806   return "";
807 }
808
809 template <class ELFT>
810 uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const {
811   return ELFT::Is64Bits ? 8 : 4;
812 }
813
814 template <class ELFT>
815 StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
816   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
817   switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
818   case ELF::ELFCLASS32:
819     switch (EF.getHeader()->e_machine) {
820     case ELF::EM_386:
821       return "ELF32-i386";
822     case ELF::EM_X86_64:
823       return "ELF32-x86-64";
824     case ELF::EM_ARM:
825       return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
826     case ELF::EM_HEXAGON:
827       return "ELF32-hexagon";
828     case ELF::EM_MIPS:
829       return "ELF32-mips";
830     case ELF::EM_PPC:
831       return "ELF32-ppc";
832     case ELF::EM_SPARC:
833     case ELF::EM_SPARC32PLUS:
834       return "ELF32-sparc";
835     default:
836       return "ELF32-unknown";
837     }
838   case ELF::ELFCLASS64:
839     switch (EF.getHeader()->e_machine) {
840     case ELF::EM_386:
841       return "ELF64-i386";
842     case ELF::EM_X86_64:
843       return "ELF64-x86-64";
844     case ELF::EM_AARCH64:
845       return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big");
846     case ELF::EM_PPC64:
847       return "ELF64-ppc64";
848     case ELF::EM_S390:
849       return "ELF64-s390";
850     case ELF::EM_SPARCV9:
851       return "ELF64-sparc";
852     case ELF::EM_MIPS:
853       return "ELF64-mips";
854     default:
855       return "ELF64-unknown";
856     }
857   default:
858     // FIXME: Proper error handling.
859     report_fatal_error("Invalid ELFCLASS!");
860   }
861 }
862
863 template <class ELFT>
864 unsigned ELFObjectFile<ELFT>::getArch() const {
865   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
866   switch (EF.getHeader()->e_machine) {
867   case ELF::EM_386:
868     return Triple::x86;
869   case ELF::EM_X86_64:
870     return Triple::x86_64;
871   case ELF::EM_AARCH64:
872     return Triple::aarch64;
873   case ELF::EM_ARM:
874     return Triple::arm;
875   case ELF::EM_HEXAGON:
876     return Triple::hexagon;
877   case ELF::EM_MIPS:
878     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
879     case ELF::ELFCLASS32:
880       return IsLittleEndian ? Triple::mipsel : Triple::mips;
881     case ELF::ELFCLASS64:
882       return IsLittleEndian ? Triple::mips64el : Triple::mips64;
883     default:
884       report_fatal_error("Invalid ELFCLASS!");
885     }
886   case ELF::EM_PPC:
887     return Triple::ppc;
888   case ELF::EM_PPC64:
889     return IsLittleEndian ? Triple::ppc64le : Triple::ppc64;
890   case ELF::EM_S390:
891     return Triple::systemz;
892
893   case ELF::EM_SPARC:
894   case ELF::EM_SPARC32PLUS:
895     return IsLittleEndian ? Triple::sparcel : Triple::sparc;
896   case ELF::EM_SPARCV9:
897     return Triple::sparcv9;
898
899   default:
900     return Triple::UnknownArch;
901   }
902 }
903
904 template <class ELFT>
905 ELFObjectFileBase::elf_symbol_iterator_range
906 ELFObjectFile<ELFT>::getDynamicSymbolIterators() const {
907   return make_range(dynamic_symbol_begin(), dynamic_symbol_end());
908 }
909
910 template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
911   return EF.getHeader()->e_type == ELF::ET_REL;
912 }
913
914 }
915 }
916
917 #endif