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