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