Line data Source code
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/ArrayRef.h"
18 : #include "llvm/ADT/STLExtras.h"
19 : #include "llvm/ADT/SmallVector.h"
20 : #include "llvm/ADT/StringRef.h"
21 : #include "llvm/ADT/Triple.h"
22 : #include "llvm/ADT/iterator_range.h"
23 : #include "llvm/BinaryFormat/ELF.h"
24 : #include "llvm/MC/SubtargetFeature.h"
25 : #include "llvm/Object/Binary.h"
26 : #include "llvm/Object/ELF.h"
27 : #include "llvm/Object/ELFTypes.h"
28 : #include "llvm/Object/Error.h"
29 : #include "llvm/Object/ObjectFile.h"
30 : #include "llvm/Object/SymbolicFile.h"
31 : #include "llvm/Support/ARMAttributeParser.h"
32 : #include "llvm/Support/ARMBuildAttributes.h"
33 : #include "llvm/Support/Casting.h"
34 : #include "llvm/Support/Endian.h"
35 : #include "llvm/Support/Error.h"
36 : #include "llvm/Support/ErrorHandling.h"
37 : #include "llvm/Support/MemoryBuffer.h"
38 : #include <cassert>
39 : #include <cstdint>
40 : #include <system_error>
41 :
42 : namespace llvm {
43 : namespace object {
44 :
45 : class elf_symbol_iterator;
46 :
47 : class ELFObjectFileBase : public ObjectFile {
48 : friend class ELFRelocationRef;
49 : friend class ELFSectionRef;
50 : friend class ELFSymbolRef;
51 :
52 : protected:
53 : ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source);
54 :
55 : virtual uint16_t getEMachine() const = 0;
56 : virtual uint64_t getSymbolSize(DataRefImpl Symb) const = 0;
57 : virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0;
58 : virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0;
59 :
60 : virtual uint32_t getSectionType(DataRefImpl Sec) const = 0;
61 : virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0;
62 : virtual uint64_t getSectionOffset(DataRefImpl Sec) const = 0;
63 :
64 : virtual Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
65 :
66 : public:
67 : using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>;
68 :
69 : virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
70 :
71 : /// Returns platform-specific object flags, if any.
72 : virtual unsigned getPlatformFlags() const = 0;
73 :
74 : elf_symbol_iterator_range symbols() const;
75 :
76 17277 : static bool classof(const Binary *v) { return v->isELF(); }
77 :
78 : SubtargetFeatures getFeatures() const override;
79 :
80 : SubtargetFeatures getMIPSFeatures() const;
81 :
82 : SubtargetFeatures getARMFeatures() const;
83 :
84 : SubtargetFeatures getRISCVFeatures() const;
85 :
86 : void setARMSubArch(Triple &TheTriple) const override;
87 :
88 : virtual uint16_t getEType() const = 0;
89 :
90 : std::vector<std::pair<DataRefImpl, uint64_t>> getPltAddresses() const;
91 : };
92 :
93 : class ELFSectionRef : public SectionRef {
94 : public:
95 2818 : ELFSectionRef(const SectionRef &B) : SectionRef(B) {
96 : assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
97 : }
98 :
99 : const ELFObjectFileBase *getObject() const {
100 472 : return cast<ELFObjectFileBase>(SectionRef::getObject());
101 : }
102 :
103 : uint32_t getType() const {
104 2548 : return getObject()->getSectionType(getRawDataRefImpl());
105 : }
106 :
107 : uint64_t getFlags() const {
108 4938 : return getObject()->getSectionFlags(getRawDataRefImpl());
109 : }
110 :
111 : uint64_t getOffset() const {
112 : return getObject()->getSectionOffset(getRawDataRefImpl());
113 : }
114 : };
115 :
116 : class elf_section_iterator : public section_iterator {
117 : public:
118 472 : elf_section_iterator(const section_iterator &B) : section_iterator(B) {
119 : assert(isa<ELFObjectFileBase>(B->getObject()));
120 : }
121 :
122 : const ELFSectionRef *operator->() const {
123 : return static_cast<const ELFSectionRef *>(section_iterator::operator->());
124 : }
125 :
126 : const ELFSectionRef &operator*() const {
127 : return static_cast<const ELFSectionRef &>(section_iterator::operator*());
128 : }
129 : };
130 :
131 : class ELFSymbolRef : public SymbolRef {
132 : public:
133 732 : ELFSymbolRef(const SymbolRef &B) : SymbolRef(B) {
134 : assert(isa<ELFObjectFileBase>(SymbolRef::getObject()));
135 : }
136 :
137 : const ELFObjectFileBase *getObject() const {
138 63 : return cast<ELFObjectFileBase>(BasicSymbolRef::getObject());
139 : }
140 :
141 : uint64_t getSize() const {
142 26345326 : return getObject()->getSymbolSize(getRawDataRefImpl());
143 : }
144 :
145 : uint8_t getOther() const {
146 0 : return getObject()->getSymbolOther(getRawDataRefImpl());
147 : }
148 :
149 : uint8_t getELFType() const {
150 186 : return getObject()->getSymbolELFType(getRawDataRefImpl());
151 : }
152 : };
153 :
154 : class elf_symbol_iterator : public symbol_iterator {
155 : public:
156 2425 : elf_symbol_iterator(const basic_symbol_iterator &B)
157 2425 : : symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
158 9700 : cast<ELFObjectFileBase>(B->getObject()))) {}
159 :
160 : const ELFSymbolRef *operator->() const {
161 : return static_cast<const ELFSymbolRef *>(symbol_iterator::operator->());
162 : }
163 :
164 : const ELFSymbolRef &operator*() const {
165 : return static_cast<const ELFSymbolRef &>(symbol_iterator::operator*());
166 : }
167 : };
168 :
169 : class ELFRelocationRef : public RelocationRef {
170 : public:
171 12854 : ELFRelocationRef(const RelocationRef &B) : RelocationRef(B) {
172 : assert(isa<ELFObjectFileBase>(RelocationRef::getObject()));
173 : }
174 :
175 : const ELFObjectFileBase *getObject() const {
176 0 : return cast<ELFObjectFileBase>(RelocationRef::getObject());
177 : }
178 :
179 : Expected<int64_t> getAddend() const {
180 25708 : return getObject()->getRelocationAddend(getRawDataRefImpl());
181 : }
182 : };
183 :
184 : class elf_relocation_iterator : public relocation_iterator {
185 : public:
186 : elf_relocation_iterator(const relocation_iterator &B)
187 : : relocation_iterator(RelocationRef(
188 0 : B->getRawDataRefImpl(), cast<ELFObjectFileBase>(B->getObject()))) {}
189 :
190 : const ELFRelocationRef *operator->() const {
191 : return static_cast<const ELFRelocationRef *>(
192 : relocation_iterator::operator->());
193 : }
194 :
195 : const ELFRelocationRef &operator*() const {
196 : return static_cast<const ELFRelocationRef &>(
197 : relocation_iterator::operator*());
198 : }
199 : };
200 :
201 : inline ELFObjectFileBase::elf_symbol_iterator_range
202 185 : ELFObjectFileBase::symbols() const {
203 185 : return elf_symbol_iterator_range(symbol_begin(), symbol_end());
204 : }
205 :
206 : template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
207 : uint16_t getEMachine() const override;
208 : uint16_t getEType() const override;
209 : uint64_t getSymbolSize(DataRefImpl Sym) const override;
210 :
211 : public:
212 : LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
213 :
214 : using uintX_t = typename ELFT::uint;
215 :
216 : using Elf_Sym = typename ELFT::Sym;
217 : using Elf_Shdr = typename ELFT::Shdr;
218 : using Elf_Ehdr = typename ELFT::Ehdr;
219 : using Elf_Rel = typename ELFT::Rel;
220 : using Elf_Rela = typename ELFT::Rela;
221 : using Elf_Dyn = typename ELFT::Dyn;
222 :
223 : private:
224 : ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF,
225 : const Elf_Shdr *DotDynSymSec, const Elf_Shdr *DotSymtabSec,
226 : ArrayRef<Elf_Word> ShndxTable);
227 :
228 : protected:
229 : ELFFile<ELFT> EF;
230 :
231 : const Elf_Shdr *DotDynSymSec = nullptr; // Dynamic symbol table section.
232 : const Elf_Shdr *DotSymtabSec = nullptr; // Symbol table section.
233 : ArrayRef<Elf_Word> ShndxTable;
234 :
235 : void moveSymbolNext(DataRefImpl &Symb) const override;
236 : Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
237 : Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
238 : uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
239 : uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
240 : uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
241 : uint32_t getSymbolFlags(DataRefImpl Symb) const override;
242 : uint8_t getSymbolOther(DataRefImpl Symb) const override;
243 : uint8_t getSymbolELFType(DataRefImpl Symb) const override;
244 : Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
245 : Expected<section_iterator> getSymbolSection(const Elf_Sym *Symb,
246 : const Elf_Shdr *SymTab) const;
247 : Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
248 :
249 : void moveSectionNext(DataRefImpl &Sec) const override;
250 : std::error_code getSectionName(DataRefImpl Sec,
251 : StringRef &Res) const override;
252 : uint64_t getSectionAddress(DataRefImpl Sec) const override;
253 : uint64_t getSectionIndex(DataRefImpl Sec) const override;
254 : uint64_t getSectionSize(DataRefImpl Sec) const override;
255 : std::error_code getSectionContents(DataRefImpl Sec,
256 : StringRef &Res) const override;
257 : uint64_t getSectionAlignment(DataRefImpl Sec) const override;
258 : bool isSectionCompressed(DataRefImpl Sec) const override;
259 : bool isSectionText(DataRefImpl Sec) const override;
260 : bool isSectionData(DataRefImpl Sec) const override;
261 : bool isSectionBSS(DataRefImpl Sec) const override;
262 : bool isSectionVirtual(DataRefImpl Sec) const override;
263 : relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
264 : relocation_iterator section_rel_end(DataRefImpl Sec) const override;
265 : std::vector<SectionRef> dynamic_relocation_sections() const override;
266 : section_iterator getRelocatedSection(DataRefImpl Sec) const override;
267 :
268 : void moveRelocationNext(DataRefImpl &Rel) const override;
269 : uint64_t getRelocationOffset(DataRefImpl Rel) const override;
270 : symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
271 : uint64_t getRelocationType(DataRefImpl Rel) const override;
272 : void getRelocationTypeName(DataRefImpl Rel,
273 : SmallVectorImpl<char> &Result) const override;
274 :
275 : uint32_t getSectionType(DataRefImpl Sec) const override;
276 : uint64_t getSectionFlags(DataRefImpl Sec) const override;
277 : uint64_t getSectionOffset(DataRefImpl Sec) const override;
278 : StringRef getRelocationTypeName(uint32_t Type) const;
279 :
280 : /// Get the relocation section that contains \a Rel.
281 61524 : const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
282 61524 : auto RelSecOrErr = EF.getSection(Rel.d.a);
283 61524 : if (!RelSecOrErr)
284 0 : report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message());
285 61524 : return *RelSecOrErr;
286 : }
287 3070 :
288 3070 : DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
289 3070 : DataRefImpl DRI;
290 0 : if (!SymTable) {
291 3070 : DRI.d.a = 0;
292 : DRI.d.b = 0;
293 1168 : return DRI;
294 1168 : }
295 1168 : assert(SymTable->sh_type == ELF::SHT_SYMTAB ||
296 0 : SymTable->sh_type == ELF::SHT_DYNSYM);
297 1168 :
298 0 : auto SectionsOrErr = EF.sections();
299 56205 : if (!SectionsOrErr) {
300 56205 : DRI.d.a = 0;
301 56205 : DRI.d.b = 0;
302 0 : return DRI;
303 56205 : }
304 0 : uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
305 1081 : unsigned SymTableIndex =
306 1081 : (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr);
307 1081 :
308 0 : DRI.d.a = SymTableIndex;
309 1081 : DRI.d.b = SymbolNum;
310 0 : return DRI;
311 : }
312 20918 :
313 : const Elf_Shdr *toELFShdrIter(DataRefImpl Sec) const {
314 20918 : return reinterpret_cast<const Elf_Shdr *>(Sec.p);
315 : }
316 :
317 278 : DataRefImpl toDRI(const Elf_Shdr *Sec) const {
318 : DataRefImpl DRI;
319 : DRI.p = reinterpret_cast<uintptr_t>(Sec);
320 : return DRI;
321 : }
322 20640 :
323 20640 : DataRefImpl toDRI(const Elf_Dyn *Dyn) const {
324 : DataRefImpl DRI;
325 : DRI.p = reinterpret_cast<uintptr_t>(Dyn);
326 0 : return DRI;
327 : }
328 20640 :
329 20640 : bool isExportedToOtherDSO(const Elf_Sym *ESym) const {
330 20640 : unsigned char Binding = ESym->getBinding();
331 : unsigned char Visibility = ESym->getVisibility();
332 20640 :
333 20640 : // A symbol is exported if its binding is either GLOBAL or WEAK, and its
334 20640 : // visibility is either DEFAULT or PROTECTED. All other symbols are not
335 : // exported.
336 1614 : return ((Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK) &&
337 : (Visibility == ELF::STV_DEFAULT ||
338 1614 : Visibility == ELF::STV_PROTECTED));
339 : }
340 :
341 196 : // This flag is used for classof, to distinguish ELFObjectFile from
342 : // its subclass. If more subclasses will be created, this flag will
343 : // have to become an enum.
344 : bool isDyldELFObject;
345 :
346 1418 : public:
347 1418 : ELFObjectFile(ELFObjectFile<ELFT> &&Other);
348 : static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object);
349 :
350 0 : const Elf_Rel *getRel(DataRefImpl Rel) const;
351 : const Elf_Rela *getRela(DataRefImpl Rela) const;
352 1418 :
353 1418 : const Elf_Sym *getSymbol(DataRefImpl Sym) const {
354 1418 : auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
355 : if (!Ret)
356 1418 : report_fatal_error(errorToErrorCode(Ret.takeError()).message());
357 1418 : return *Ret;
358 1418 : }
359 :
360 415 : const Elf_Shdr *getSection(DataRefImpl Sec) const {
361 : return reinterpret_cast<const Elf_Shdr *>(Sec.p);
362 415 : }
363 :
364 : basic_symbol_iterator symbol_begin() const override;
365 8 : basic_symbol_iterator symbol_end() const override;
366 :
367 : elf_symbol_iterator dynamic_symbol_begin() const;
368 : elf_symbol_iterator dynamic_symbol_end() const;
369 :
370 407 : section_iterator section_begin() const override;
371 407 : section_iterator section_end() const override;
372 :
373 : Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const override;
374 0 :
375 : uint8_t getBytesInAddress() const override;
376 407 : StringRef getFileFormatName() const override;
377 407 : Triple::ArchType getArch() const override;
378 407 : Expected<uint64_t> getStartAddress() const override;
379 :
380 407 : unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; }
381 407 :
382 407 : std::error_code getBuildAttributes(ARMAttributeParser &Attributes) const override {
383 : auto SectionsOrErr = EF.sections();
384 18530 : if (!SectionsOrErr)
385 : return errorToErrorCode(SectionsOrErr.takeError());
386 18530 :
387 : for (const Elf_Shdr &Sec : *SectionsOrErr) {
388 : if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) {
389 72 : auto ErrorOrContents = EF.getSectionContents(&Sec);
390 : if (!ErrorOrContents)
391 : return errorToErrorCode(ErrorOrContents.takeError());
392 :
393 : auto Contents = ErrorOrContents.get();
394 18458 : if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)
395 18458 : return std::error_code();
396 :
397 : Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
398 0 : break;
399 : }
400 18458 : }
401 18458 : return std::error_code();
402 18458 : }
403 :
404 21032 : const ELFFile<ELFT> *getELFFile() const { return &EF; }
405 18458 :
406 18458 : bool isDyldType() const { return isDyldELFObject; }
407 : static bool classof(const Binary *v) {
408 2963 : return v->getType() == getELFType(ELFT::TargetEndianness == support::little,
409 0 : ELFT::Is64Bits);
410 359 : }
411 :
412 : elf_symbol_iterator_range getDynamicSymbolIterators() const override;
413 2 :
414 : bool isRelocatableObject() const override;
415 0 : };
416 0 :
417 : using ELF32LEObjectFile = ELFObjectFile<ELF32LE>;
418 357 : using ELF64LEObjectFile = ELFObjectFile<ELF64LE>;
419 357 : using ELF32BEObjectFile = ELFObjectFile<ELF32BE>;
420 0 : using ELF64BEObjectFile = ELFObjectFile<ELF64BE>;
421 0 :
422 0 : template <class ELFT>
423 0 : void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const {
424 357 : ++Sym.d.b;
425 357 : }
426 357 :
427 : template <class ELFT>
428 357 : Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const {
429 357 : const Elf_Sym *ESym = getSymbol(Sym);
430 357 : auto SymTabOrErr = EF.getSection(Sym.d.a);
431 0 : if (!SymTabOrErr)
432 : return SymTabOrErr.takeError();
433 0 : const Elf_Shdr *SymTableSec = *SymTabOrErr;
434 : auto StrTabOrErr = EF.getSection(SymTableSec->sh_link);
435 0 : if (!StrTabOrErr)
436 0 : return StrTabOrErr.takeError();
437 0 : const Elf_Shdr *StringTableSec = *StrTabOrErr;
438 : auto SymStrTabOrErr = EF.getStringTable(StringTableSec);
439 101163 : if (!SymStrTabOrErr)
440 0 : return SymStrTabOrErr.takeError();
441 : return ESym->getName(*SymStrTabOrErr);
442 0 : }
443 :
444 0 : template <class ELFT>
445 0 : uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const {
446 : return getSection(Sec)->sh_flags;
447 0 : }
448 :
449 0 : template <class ELFT>
450 0 : uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const {
451 : return getSection(Sec)->sh_type;
452 0 : }
453 :
454 0 : template <class ELFT>
455 0 : uint64_t ELFObjectFile<ELFT>::getSectionOffset(DataRefImpl Sec) const {
456 : return getSection(Sec)->sh_offset;
457 0 : }
458 :
459 0 : template <class ELFT>
460 0 : uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const {
461 : const Elf_Sym *ESym = getSymbol(Symb);
462 : uint64_t Ret = ESym->st_value;
463 : if (ESym->st_shndx == ELF::SHN_ABS)
464 : return Ret;
465 :
466 : const Elf_Ehdr *Header = EF.getHeader();
467 : // Clear the ARM/Thumb or microMIPS indicator flag.
468 : if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) &&
469 10959 : ESym->getType() == ELF::STT_FUNC)
470 10959 : Ret &= ~1;
471 13392726 :
472 0 : return Ret;
473 10959 : }
474 :
475 340 : template <class ELFT>
476 13382107 : Expected<uint64_t>
477 2469636 : ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
478 1234648 : uint64_t Result = getSymbolValue(Symb);
479 340 : const Elf_Sym *ESym = getSymbol(Symb);
480 0 : switch (ESym->st_shndx) {
481 408 : case ELF::SHN_COMMON:
482 408 : case ELF::SHN_UNDEF:
483 408 : case ELF::SHN_ABS:
484 0 : return Result;
485 408 : }
486 :
487 2823 : const Elf_Ehdr *Header = EF.getHeader();
488 2823 : auto SymTabOrErr = EF.getSection(Symb.d.a);
489 2823 : if (!SymTabOrErr)
490 0 : return SymTabOrErr.takeError();
491 2823 : const Elf_Shdr *SymTab = *SymTabOrErr;
492 0 :
493 7388 : if (Header->e_type == ELF::ET_REL) {
494 7388 : auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable);
495 7388 : if (!SectionOrErr)
496 0 : return SectionOrErr.takeError();
497 7388 : const Elf_Shdr *Section = *SectionOrErr;
498 0 : if (Section)
499 0 : Result += Section->sh_addr;
500 0 : }
501 234 :
502 0 : return Result;
503 0 : }
504 0 :
505 : template <class ELFT>
506 0 : uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const {
507 0 : const Elf_Sym *Sym = getSymbol(Symb);
508 : if (Sym->st_shndx == ELF::SHN_COMMON)
509 0 : return Sym->st_value;
510 0 : return 0;
511 0 : }
512 0 :
513 0 : template <class ELFT>
514 0 : uint16_t ELFObjectFile<ELFT>::getEMachine() const {
515 0 : return EF.getHeader()->e_machine;
516 : }
517 :
518 : template <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const {
519 : return EF.getHeader()->e_type;
520 0 : }
521 0 :
522 0 : template <class ELFT>
523 : uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const {
524 : return getSymbol(Sym)->st_size;
525 : }
526 :
527 : template <class ELFT>
528 : uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
529 : return getSymbol(Symb)->st_size;
530 : }
531 :
532 : template <class ELFT>
533 : uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const {
534 : return getSymbol(Symb)->st_other;
535 : }
536 :
537 79475649 : template <class ELFT>
538 79475649 : uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const {
539 79475649 : return getSymbol(Symb)->getType();
540 0 : }
541 79475649 :
542 : template <class ELFT>
543 47458 : Expected<SymbolRef::Type>
544 47458 : ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const {
545 47458 : const Elf_Sym *ESym = getSymbol(Symb);
546 0 :
547 47458 : switch (ESym->getType()) {
548 : case ELF::STT_NOTYPE:
549 4343 : return SymbolRef::ST_Unknown;
550 4343 : case ELF::STT_SECTION:
551 4343 : return SymbolRef::ST_Debug;
552 0 : case ELF::STT_FILE:
553 4343 : return SymbolRef::ST_File;
554 : case ELF::STT_FUNC:
555 79420848 : return SymbolRef::ST_Function;
556 79421738 : case ELF::STT_OBJECT:
557 79420848 : case ELF::STT_COMMON:
558 0 : case ELF::STT_TLS:
559 79420848 : return SymbolRef::ST_Data;
560 11079 : default:
561 3000 : return SymbolRef::ST_Other;
562 3000 : }
563 3000 : }
564 0 :
565 3000 : template <class ELFT>
566 : uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
567 : const Elf_Sym *ESym = getSymbol(Sym);
568 0 :
569 23889 : uint32_t Result = SymbolRef::SF_None;
570 :
571 0 : if (ESym->getBinding() != ELF::STB_LOCAL)
572 0 : Result |= SymbolRef::SF_Global;
573 :
574 0 : if (ESym->getBinding() == ELF::STB_WEAK)
575 0 : Result |= SymbolRef::SF_Weak;
576 :
577 0 : if (ESym->st_shndx == ELF::SHN_ABS)
578 0 : Result |= SymbolRef::SF_Absolute;
579 :
580 0 : if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION)
581 0 : Result |= SymbolRef::SF_FormatSpecific;
582 :
583 : auto DotSymtabSecSyms = EF.symbols(DotSymtabSec);
584 : if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin())
585 : Result |= SymbolRef::SF_FormatSpecific;
586 : auto DotDynSymSecSyms = EF.symbols(DotDynSymSec);
587 : if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin())
588 : Result |= SymbolRef::SF_FormatSpecific;
589 :
590 : if (EF.getHeader()->e_machine == ELF::EM_ARM) {
591 : if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) {
592 : StringRef Name = *NameOrErr;
593 : if (Name.startswith("$d") || Name.startswith("$t") ||
594 : Name.startswith("$a"))
595 : Result |= SymbolRef::SF_FormatSpecific;
596 : } else {
597 : // TODO: Actually report errors helpfully.
598 : consumeError(NameOrErr.takeError());
599 : }
600 290 : if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 1)
601 : Result |= SymbolRef::SF_Thumb;
602 234 : }
603 234 :
604 234 : if (ESym->st_shndx == ELF::SHN_UNDEF)
605 0 : Result |= SymbolRef::SF_Undefined;
606 :
607 1640 : if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON)
608 1563 : Result |= SymbolRef::SF_Common;
609 :
610 157 : if (isExportedToOtherDSO(ESym))
611 0 : Result |= SymbolRef::SF_Exported;
612 :
613 157 : if (ESym->getVisibility() == ELF::STV_HIDDEN)
614 157 : Result |= SymbolRef::SF_Hidden;
615 0 :
616 : return Result;
617 157 : }
618 :
619 : template <class ELFT>
620 : Expected<section_iterator>
621 234 : ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
622 : const Elf_Shdr *SymTab) const {
623 234 : auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
624 234 : if (!ESecOrErr)
625 234 : return ESecOrErr.takeError();
626 0 :
627 : const Elf_Shdr *ESec = *ESecOrErr;
628 1640 : if (!ESec)
629 1563 : return section_end();
630 :
631 157 : DataRefImpl Sec;
632 0 : Sec.p = reinterpret_cast<intptr_t>(ESec);
633 : return section_iterator(SectionRef(Sec, this));
634 157 : }
635 157 :
636 0 : template <class ELFT>
637 : Expected<section_iterator>
638 157 : ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const {
639 : const Elf_Sym *Sym = getSymbol(Symb);
640 : auto SymTabOrErr = EF.getSection(Symb.d.a);
641 : if (!SymTabOrErr)
642 234 : return SymTabOrErr.takeError();
643 : const Elf_Shdr *SymTab = *SymTabOrErr;
644 0 : return getSymbolSection(Sym, SymTab);
645 0 : }
646 0 :
647 0 : template <class ELFT>
648 : void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
649 0 : const Elf_Shdr *ESec = getSection(Sec);
650 0 : Sec = toDRI(++ESec);
651 : }
652 0 :
653 0 : template <class ELFT>
654 : std::error_code ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec,
655 0 : StringRef &Result) const {
656 0 : auto Name = EF.getSectionName(&*getSection(Sec));
657 0 : if (!Name)
658 : return errorToErrorCode(Name.takeError());
659 0 : Result = *Name;
660 : return std::error_code();
661 : }
662 :
663 0 : template <class ELFT>
664 : uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const {
665 0 : return getSection(Sec)->sh_addr;
666 0 : }
667 0 :
668 0 : template <class ELFT>
669 : uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const {
670 0 : auto SectionsOrErr = EF.sections();
671 0 : handleAllErrors(std::move(SectionsOrErr.takeError()),
672 : [](const ErrorInfoBase &) {
673 0 : llvm_unreachable("unable to get section index");
674 0 : });
675 : const Elf_Shdr *First = SectionsOrErr->begin();
676 0 : return getSection(Sec) - First;
677 0 : }
678 0 :
679 : template <class ELFT>
680 0 : uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const {
681 : return getSection(Sec)->sh_size;
682 : }
683 :
684 0 : template <class ELFT>
685 : std::error_code
686 0 : ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec,
687 0 : StringRef &Result) const {
688 0 : const Elf_Shdr *EShdr = getSection(Sec);
689 0 : if (std::error_code EC =
690 : checkOffset(getMemoryBufferRef(),
691 0 : (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size))
692 0 : return EC;
693 : Result = StringRef((const char *)base() + EShdr->sh_offset, EShdr->sh_size);
694 0 : return std::error_code();
695 0 : }
696 :
697 0 : template <class ELFT>
698 0 : uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const {
699 0 : return getSection(Sec)->sh_addralign;
700 : }
701 0 :
702 : template <class ELFT>
703 : bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const {
704 : return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED;
705 0 : }
706 :
707 : template <class ELFT>
708 : bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const {
709 : return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR;
710 : }
711 :
712 : template <class ELFT>
713 : bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const {
714 : const Elf_Shdr *EShdr = getSection(Sec);
715 : return EShdr->sh_type == ELF::SHT_PROGBITS &&
716 : EShdr->sh_flags & ELF::SHF_ALLOC &&
717 : !(EShdr->sh_flags & ELF::SHF_EXECINSTR);
718 : }
719 :
720 : template <class ELFT>
721 : bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const {
722 : const Elf_Shdr *EShdr = getSection(Sec);
723 : return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) &&
724 : EShdr->sh_type == ELF::SHT_NOBITS;
725 : }
726 :
727 13307106 : template <class ELFT>
728 13307106 : std::vector<SectionRef>
729 13307106 : ELFObjectFile<ELFT>::dynamic_relocation_sections() const {
730 8241 : std::vector<SectionRef> Res;
731 8241 : std::vector<uintptr_t> Offsets;
732 8241 :
733 716 : auto SectionsOrErr = EF.sections();
734 716 : if (!SectionsOrErr)
735 716 : return Res;
736 13297591 :
737 13297591 : for (const Elf_Shdr &Sec : *SectionsOrErr) {
738 13297591 : if (Sec.sh_type != ELF::SHT_DYNAMIC)
739 558 : continue;
740 558 : Elf_Dyn *Dynamic =
741 558 : reinterpret_cast<Elf_Dyn *>((uintptr_t)base() + Sec.sh_offset);
742 : for (; Dynamic->d_tag != ELF::DT_NULL; Dynamic++) {
743 : if (Dynamic->d_tag == ELF::DT_REL || Dynamic->d_tag == ELF::DT_RELA ||
744 13261136 : Dynamic->d_tag == ELF::DT_JMPREL) {
745 13261136 : Offsets.push_back(Dynamic->d_un.d_val);
746 13261136 : }
747 13261136 : }
748 : }
749 13261136 : for (const Elf_Shdr &Sec : *SectionsOrErr) {
750 13261136 : if (is_contained(Offsets, Sec.sh_offset))
751 13261136 : Res.emplace_back(toDRI(&Sec), this);
752 : }
753 13261136 : return Res;
754 13261136 : }
755 13261136 :
756 : template <class ELFT>
757 13261136 : bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const {
758 : return getSection(Sec)->sh_type == ELF::SHT_NOBITS;
759 14471 : }
760 14471 :
761 14471 : template <class ELFT>
762 14471 : relocation_iterator
763 : ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
764 14471 : DataRefImpl RelData;
765 14471 : auto SectionsOrErr = EF.sections();
766 14471 : if (!SectionsOrErr)
767 : return relocation_iterator(RelocationRef());
768 14471 : uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
769 14471 : RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize;
770 14471 : RelData.d.b = 0;
771 : return relocation_iterator(RelocationRef(RelData, this));
772 14471 : }
773 :
774 707 : template <class ELFT>
775 707 : relocation_iterator
776 707 : ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const {
777 707 : const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
778 : relocation_iterator Begin = section_rel_begin(Sec);
779 707 : if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL)
780 707 : return Begin;
781 707 : DataRefImpl RelData = Begin->getRawDataRefImpl();
782 : const Elf_Shdr *RelSec = getRelSection(RelData);
783 707 :
784 707 : // Error check sh_link here so that getRelocationSymbol can just use it.
785 707 : auto SymSecOrErr = EF.getSection(RelSec->sh_link);
786 : if (!SymSecOrErr)
787 707 : report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message());
788 :
789 13245455 : RelData.d.b += S->sh_size / S->sh_entsize;
790 13245455 : return relocation_iterator(RelocationRef(RelData, this));
791 13245455 : }
792 13245455 :
793 : template <class ELFT>
794 13245455 : section_iterator
795 13245455 : ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
796 13245455 : if (EF.getHeader()->e_type != ELF::ET_REL)
797 : return section_end();
798 13245455 :
799 13245455 : const Elf_Shdr *EShdr = getSection(Sec);
800 13245455 : uintX_t Type = EShdr->sh_type;
801 : if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
802 13245455 : return section_end();
803 :
804 503 : auto R = EF.getSection(EShdr->sh_info);
805 503 : if (!R)
806 503 : report_fatal_error(errorToErrorCode(R.takeError()).message());
807 503 : return section_iterator(SectionRef(toDRI(*R), this));
808 : }
809 503 :
810 503 : // Relocations
811 503 : template <class ELFT>
812 : void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const {
813 503 : ++Rel.d.b;
814 503 : }
815 503 :
816 : template <class ELFT>
817 503 : symbol_iterator
818 : ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const {
819 : uint32_t symbolIdx;
820 : const Elf_Shdr *sec = getRelSection(Rel);
821 2469 : if (sec->sh_type == ELF::SHT_REL)
822 2469 : symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL());
823 : else
824 71 : symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL());
825 71 : if (!symbolIdx)
826 : return symbol_end();
827 36 :
828 36 : // FIXME: error check symbolIdx
829 : DataRefImpl SymbolData;
830 2318 : SymbolData.d.a = sec->sh_link;
831 2318 : SymbolData.d.b = symbolIdx;
832 : return symbol_iterator(SymbolRef(SymbolData, this));
833 44 : }
834 44 :
835 : template <class ELFT>
836 : uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const {
837 : const Elf_Shdr *sec = getRelSection(Rel);
838 1274 : if (sec->sh_type == ELF::SHT_REL)
839 1274 : return getRel(Rel)->r_offset;
840 :
841 54 : return getRela(Rel)->r_offset;
842 54 : }
843 :
844 18 : template <class ELFT>
845 18 : uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const {
846 : const Elf_Shdr *sec = getRelSection(Rel);
847 1180 : if (sec->sh_type == ELF::SHT_REL)
848 1180 : return getRel(Rel)->getType(EF.isMips64EL());
849 : else
850 22 : return getRela(Rel)->getType(EF.isMips64EL());
851 22 : }
852 :
853 : template <class ELFT>
854 : StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
855 0 : return getELFRelocationTypeName(EF.getHeader()->e_machine, Type);
856 0 : }
857 :
858 0 : template <class ELFT>
859 0 : void ELFObjectFile<ELFT>::getRelocationTypeName(
860 : DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
861 0 : uint32_t type = getRelocationType(Rel);
862 0 : EF.getRelocationTypeName(type, Result);
863 : }
864 0 :
865 0 : template <class ELFT>
866 : Expected<int64_t>
867 0 : ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const {
868 0 : if (getRelSection(Rel)->sh_type != ELF::SHT_RELA)
869 : return createError("Section is not SHT_RELA");
870 : return (int64_t)getRela(Rel)->r_addend;
871 : }
872 13214351 :
873 13214351 : template <class ELFT>
874 8120 : const typename ELFObjectFile<ELFT>::Elf_Rel *
875 13214351 : ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const {
876 : assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
877 : auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b);
878 : if (!Ret)
879 : report_fatal_error(errorToErrorCode(Ret.takeError()).message());
880 13210987 : return *Ret;
881 6930 : }
882 3017 :
883 : template <class ELFT>
884 : const typename ELFObjectFile<ELFT>::Elf_Rela *
885 : ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const {
886 7529 : assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
887 7529 : auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b);
888 7529 : if (!Ret)
889 7529 : report_fatal_error(errorToErrorCode(Ret.takeError()).message());
890 : return *Ret;
891 : }
892 :
893 : template <class ELFT>
894 7379 : Expected<ELFObjectFile<ELFT>>
895 6204 : ELFObjectFile<ELFT>::create(MemoryBufferRef Object) {
896 2838 : auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer());
897 : if (Error E = EFOrErr.takeError())
898 : return std::move(E);
899 : auto EF = std::move(*EFOrErr);
900 591 :
901 591 : auto SectionsOrErr = EF.sections();
902 591 : if (!SectionsOrErr)
903 591 : return SectionsOrErr.takeError();
904 :
905 : const Elf_Shdr *DotDynSymSec = nullptr;
906 : const Elf_Shdr *DotSymtabSec = nullptr;
907 : ArrayRef<Elf_Word> ShndxTable;
908 561 : for (const Elf_Shdr &Sec : *SectionsOrErr) {
909 539 : switch (Sec.sh_type) {
910 138 : case ELF::SHT_DYNSYM: {
911 : if (DotDynSymSec)
912 : return createError("More than one dynamic symbol table!");
913 : DotDynSymSec = &Sec;
914 13205830 : break;
915 13205830 : }
916 : case ELF::SHT_SYMTAB: {
917 13205830 : if (DotSymtabSec)
918 : return createError("More than one static symbol table!");
919 : DotSymtabSec = &Sec;
920 : break;
921 : }
922 13202661 : case ELF::SHT_SYMTAB_SHNDX: {
923 60 : auto TableOrErr = EF.getSHNDXTable(Sec);
924 30 : if (!TableOrErr)
925 : return TableOrErr.takeError();
926 : ShndxTable = *TableOrErr;
927 : break;
928 401 : }
929 401 : }
930 : }
931 401 : return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec,
932 : ShndxTable);
933 : }
934 :
935 : template <class ELFT>
936 386 : ELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF,
937 127 : const Elf_Shdr *DotDynSymSec,
938 11 : const Elf_Shdr *DotSymtabSec,
939 : ArrayRef<Elf_Word> ShndxTable)
940 : : ELFObjectFileBase(
941 : getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits),
942 : Object),
943 : EF(EF), DotDynSymSec(DotDynSymSec), DotSymtabSec(DotSymtabSec),
944 : ShndxTable(ShndxTable) {}
945 13251267 :
946 13251267 : template <class ELFT>
947 13251267 : ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other)
948 13251267 : : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec,
949 : Other.DotSymtabSec, Other.ShndxTable) {}
950 :
951 : template <class ELFT>
952 : basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const {
953 : DataRefImpl Sym = toDRI(DotSymtabSec, 0);
954 : return basic_symbol_iterator(SymbolRef(Sym, this));
955 : }
956 13210987 :
957 13210987 : template <class ELFT>
958 : basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const {
959 13210987 : const Elf_Shdr *SymTab = DotSymtabSec;
960 : if (!SymTab)
961 13210987 : return symbol_begin();
962 6153 : DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
963 6153 : return basic_symbol_iterator(SymbolRef(Sym, this));
964 : }
965 6153 :
966 6153 : template <class ELFT>
967 6152 : elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const {
968 : DataRefImpl Sym = toDRI(DotDynSymSec, 0);
969 : return symbol_iterator(SymbolRef(Sym, this));
970 : }
971 :
972 8180 : template <class ELFT>
973 8180 : elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const {
974 8180 : const Elf_Shdr *SymTab = DotDynSymSec;
975 8180 : if (!SymTab)
976 : return dynamic_symbol_begin();
977 : DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
978 : return basic_symbol_iterator(SymbolRef(Sym, this));
979 : }
980 :
981 : template <class ELFT>
982 : section_iterator ELFObjectFile<ELFT>::section_begin() const {
983 7379 : auto SectionsOrErr = EF.sections();
984 7379 : if (!SectionsOrErr)
985 : return section_iterator(SectionRef());
986 7379 : return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this));
987 : }
988 7379 :
989 1754 : template <class ELFT>
990 1754 : section_iterator ELFObjectFile<ELFT>::section_end() const {
991 : auto SectionsOrErr = EF.sections();
992 1754 : if (!SectionsOrErr)
993 1754 : return section_iterator(SectionRef());
994 1753 : return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this));
995 : }
996 :
997 : template <class ELFT>
998 : uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const {
999 726 : return ELFT::Is64Bits ? 8 : 4;
1000 726 : }
1001 726 :
1002 726 : template <class ELFT>
1003 : StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
1004 : bool IsLittleEndian = ELFT::TargetEndianness == support::little;
1005 : switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
1006 : case ELF::ELFCLASS32:
1007 : switch (EF.getHeader()->e_machine) {
1008 : case ELF::EM_386:
1009 : return "ELF32-i386";
1010 561 : case ELF::EM_IAMCU:
1011 561 : return "ELF32-iamcu";
1012 : case ELF::EM_X86_64:
1013 561 : return "ELF32-x86-64";
1014 : case ELF::EM_ARM:
1015 561 : return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
1016 220 : case ELF::EM_AVR:
1017 220 : return "ELF32-avr";
1018 : case ELF::EM_HEXAGON:
1019 220 : return "ELF32-hexagon";
1020 220 : case ELF::EM_LANAI:
1021 220 : return "ELF32-lanai";
1022 : case ELF::EM_MIPS:
1023 : return "ELF32-mips";
1024 : case ELF::EM_PPC:
1025 : return "ELF32-ppc";
1026 13241858 : case ELF::EM_RISCV:
1027 13241858 : return "ELF32-riscv";
1028 13241858 : case ELF::EM_SPARC:
1029 13241858 : case ELF::EM_SPARC32PLUS:
1030 : return "ELF32-sparc";
1031 : case ELF::EM_AMDGPU:
1032 : return "ELF32-amdgpu";
1033 : default:
1034 : return "ELF32-unknown";
1035 : }
1036 : case ELF::ELFCLASS64:
1037 13206663 : switch (EF.getHeader()->e_machine) {
1038 13202661 : case ELF::EM_386:
1039 4002 : return "ELF64-i386";
1040 13206663 : case ELF::EM_X86_64:
1041 0 : return "ELF64-x86-64";
1042 13206663 : case ELF::EM_AARCH64:
1043 4048 : return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big");
1044 4500 : case ELF::EM_PPC64:
1045 : return "ELF64-ppc64";
1046 4500 : case ELF::EM_RISCV:
1047 4500 : return "ELF64-riscv";
1048 4048 : case ELF::EM_S390:
1049 452 : return "ELF64-s390";
1050 : case ELF::EM_SPARCV9:
1051 402 : return "ELF64-sparc";
1052 : case ELF::EM_MIPS:
1053 905 : return "ELF64-mips";
1054 905 : case ELF::EM_AMDGPU:
1055 503 : return "ELF64-amdgpu";
1056 905 : case ELF::EM_BPF:
1057 : return "ELF64-BPF";
1058 2210 : default:
1059 : return "ELF64-unknown";
1060 2210 : }
1061 2210 : default:
1062 0 : // FIXME: Proper error handling.
1063 2210 : report_fatal_error("Invalid ELFCLASS!");
1064 386 : }
1065 1324 : }
1066 :
1067 1324 : template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
1068 938 : bool IsLittleEndian = ELFT::TargetEndianness == support::little;
1069 386 : switch (EF.getHeader()->e_machine) {
1070 1069 : case ELF::EM_386:
1071 131 : case ELF::EM_IAMCU:
1072 : return Triple::x86;
1073 131 : case ELF::EM_X86_64:
1074 131 : return Triple::x86_64;
1075 131 : case ELF::EM_AARCH64:
1076 : return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be;
1077 : case ELF::EM_ARM:
1078 : return Triple::arm;
1079 : case ELF::EM_AVR:
1080 : return Triple::avr;
1081 : case ELF::EM_HEXAGON:
1082 169 : return Triple::hexagon;
1083 169 : case ELF::EM_LANAI:
1084 169 : return Triple::lanai;
1085 169 : case ELF::EM_MIPS:
1086 : switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
1087 : case ELF::ELFCLASS32:
1088 6 : return IsLittleEndian ? Triple::mipsel : Triple::mips;
1089 6 : case ELF::ELFCLASS64:
1090 6 : return IsLittleEndian ? Triple::mips64el : Triple::mips64;
1091 6 : default:
1092 : report_fatal_error("Invalid ELFCLASS!");
1093 : }
1094 4 : case ELF::EM_PPC:
1095 4 : return Triple::ppc;
1096 4 : case ELF::EM_PPC64:
1097 4 : return IsLittleEndian ? Triple::ppc64le : Triple::ppc64;
1098 : case ELF::EM_RISCV:
1099 : switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
1100 157 : case ELF::ELFCLASS32:
1101 157 : return Triple::riscv32;
1102 157 : case ELF::ELFCLASS64:
1103 157 : return Triple::riscv64;
1104 : default:
1105 : report_fatal_error("Invalid ELFCLASS!");
1106 2 : }
1107 2 : case ELF::EM_S390:
1108 2 : return Triple::systemz;
1109 2 :
1110 : case ELF::EM_SPARC:
1111 : case ELF::EM_SPARC32PLUS:
1112 : return IsLittleEndian ? Triple::sparcel : Triple::sparc;
1113 : case ELF::EM_SPARCV9:
1114 1433 : return Triple::sparcv9;
1115 1433 :
1116 : case ELF::EM_AMDGPU: {
1117 383 : if (!IsLittleEndian)
1118 383 : return Triple::UnknownArch;
1119 :
1120 67 : unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH;
1121 67 : if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST &&
1122 : MACH <= ELF::EF_AMDGPU_MACH_R600_LAST)
1123 930 : return Triple::r600;
1124 930 : if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST &&
1125 : MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST)
1126 53 : return Triple::amdgcn;
1127 53 :
1128 : return Triple::UnknownArch;
1129 : }
1130 0 :
1131 0 : case ELF::EM_BPF:
1132 : return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
1133 0 :
1134 0 : default:
1135 : return Triple::UnknownArch;
1136 0 : }
1137 0 : }
1138 :
1139 0 : template <class ELFT>
1140 0 : Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const {
1141 : return EF.getHeader()->e_entry;
1142 0 : }
1143 0 :
1144 : template <class ELFT>
1145 : ELFObjectFileBase::elf_symbol_iterator_range
1146 : ELFObjectFile<ELFT>::getDynamicSymbolIterators() const {
1147 13172663 : return make_range(dynamic_symbol_begin(), dynamic_symbol_end());
1148 13172663 : }
1149 0 :
1150 197 : template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
1151 197 : return EF.getHeader()->e_type == ELF::ET_REL;
1152 0 : }
1153 175 :
1154 175 : } // end namespace object
1155 0 : } // end namespace llvm
1156 13172227 :
1157 13172227 : #endif // LLVM_OBJECT_ELFOBJECTFILE_H
|
