1259698Sdim//===- ELFObjectFile.h - ELF object file implementation ---------*- C++ -*-===// 2259698Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6259698Sdim// 7259698Sdim//===----------------------------------------------------------------------===// 8259698Sdim// 9259698Sdim// This file declares the ELFObjectFile template class. 10259698Sdim// 11259698Sdim//===----------------------------------------------------------------------===// 12259698Sdim 13280031Sdim#ifndef LLVM_OBJECT_ELFOBJECTFILE_H 14280031Sdim#define LLVM_OBJECT_ELFOBJECTFILE_H 15259698Sdim 16309124Sdim#include "llvm/ADT/ArrayRef.h" 17341825Sdim#include "llvm/ADT/STLExtras.h" 18259698Sdim#include "llvm/ADT/SmallVector.h" 19309124Sdim#include "llvm/ADT/StringRef.h" 20259698Sdim#include "llvm/ADT/Triple.h" 21309124Sdim#include "llvm/ADT/iterator_range.h" 22321369Sdim#include "llvm/BinaryFormat/ELF.h" 23309124Sdim#include "llvm/MC/SubtargetFeature.h" 24309124Sdim#include "llvm/Object/Binary.h" 25259698Sdim#include "llvm/Object/ELF.h" 26309124Sdim#include "llvm/Object/ELFTypes.h" 27309124Sdim#include "llvm/Object/Error.h" 28259698Sdim#include "llvm/Object/ObjectFile.h" 29309124Sdim#include "llvm/Object/SymbolicFile.h" 30321369Sdim#include "llvm/Support/ARMAttributeParser.h" 31321369Sdim#include "llvm/Support/ARMBuildAttributes.h" 32259698Sdim#include "llvm/Support/Casting.h" 33259698Sdim#include "llvm/Support/Endian.h" 34309124Sdim#include "llvm/Support/Error.h" 35259698Sdim#include "llvm/Support/ErrorHandling.h" 36259698Sdim#include "llvm/Support/MemoryBuffer.h" 37309124Sdim#include <cassert> 38309124Sdim#include <cstdint> 39309124Sdim#include <system_error> 40259698Sdim 41259698Sdimnamespace llvm { 42259698Sdimnamespace object { 43259698Sdim 44360784Sdimconstexpr int NumElfSymbolTypes = 16; 45353358Sdimextern const llvm::EnumEntry<unsigned> ElfSymbolTypes[NumElfSymbolTypes]; 46353358Sdim 47288943Sdimclass elf_symbol_iterator; 48288943Sdim 49280031Sdimclass ELFObjectFileBase : public ObjectFile { 50321369Sdim friend class ELFRelocationRef; 51321369Sdim friend class ELFSectionRef; 52288943Sdim friend class ELFSymbolRef; 53288943Sdim 54280031Sdimprotected: 55280031Sdim ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source); 56280031Sdim 57288943Sdim virtual uint64_t getSymbolSize(DataRefImpl Symb) const = 0; 58353358Sdim virtual uint8_t getSymbolBinding(DataRefImpl Symb) const = 0; 59288943Sdim virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0; 60288943Sdim virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0; 61288943Sdim 62288943Sdim virtual uint32_t getSectionType(DataRefImpl Sec) const = 0; 63288943Sdim virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0; 64314564Sdim virtual uint64_t getSectionOffset(DataRefImpl Sec) const = 0; 65288943Sdim 66327952Sdim virtual Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0; 67353358Sdim virtual Error getBuildAttributes(ARMAttributeParser &Attributes) const = 0; 68309124Sdim 69259698Sdimpublic: 70321369Sdim using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>; 71321369Sdim 72288943Sdim virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0; 73280031Sdim 74341825Sdim /// Returns platform-specific object flags, if any. 75341825Sdim virtual unsigned getPlatformFlags() const = 0; 76341825Sdim 77288943Sdim elf_symbol_iterator_range symbols() const; 78280031Sdim 79321369Sdim static bool classof(const Binary *v) { return v->isELF(); } 80309124Sdim 81309124Sdim SubtargetFeatures getFeatures() const override; 82321369Sdim 83321369Sdim SubtargetFeatures getMIPSFeatures() const; 84321369Sdim 85321369Sdim SubtargetFeatures getARMFeatures() const; 86321369Sdim 87341825Sdim SubtargetFeatures getRISCVFeatures() const; 88341825Sdim 89321369Sdim void setARMSubArch(Triple &TheTriple) const override; 90341825Sdim 91341825Sdim virtual uint16_t getEType() const = 0; 92344779Sdim 93353358Sdim virtual uint16_t getEMachine() const = 0; 94353358Sdim 95344779Sdim std::vector<std::pair<DataRefImpl, uint64_t>> getPltAddresses() const; 96280031Sdim}; 97280031Sdim 98288943Sdimclass ELFSectionRef : public SectionRef { 99288943Sdimpublic: 100288943Sdim ELFSectionRef(const SectionRef &B) : SectionRef(B) { 101288943Sdim assert(isa<ELFObjectFileBase>(SectionRef::getObject())); 102288943Sdim } 103288943Sdim 104288943Sdim const ELFObjectFileBase *getObject() const { 105288943Sdim return cast<ELFObjectFileBase>(SectionRef::getObject()); 106288943Sdim } 107288943Sdim 108288943Sdim uint32_t getType() const { 109288943Sdim return getObject()->getSectionType(getRawDataRefImpl()); 110288943Sdim } 111288943Sdim 112288943Sdim uint64_t getFlags() const { 113288943Sdim return getObject()->getSectionFlags(getRawDataRefImpl()); 114288943Sdim } 115314564Sdim 116314564Sdim uint64_t getOffset() const { 117314564Sdim return getObject()->getSectionOffset(getRawDataRefImpl()); 118314564Sdim } 119288943Sdim}; 120288943Sdim 121288943Sdimclass elf_section_iterator : public section_iterator { 122288943Sdimpublic: 123288943Sdim elf_section_iterator(const section_iterator &B) : section_iterator(B) { 124288943Sdim assert(isa<ELFObjectFileBase>(B->getObject())); 125288943Sdim } 126288943Sdim 127288943Sdim const ELFSectionRef *operator->() const { 128288943Sdim return static_cast<const ELFSectionRef *>(section_iterator::operator->()); 129288943Sdim } 130288943Sdim 131288943Sdim const ELFSectionRef &operator*() const { 132288943Sdim return static_cast<const ELFSectionRef &>(section_iterator::operator*()); 133288943Sdim } 134288943Sdim}; 135288943Sdim 136288943Sdimclass ELFSymbolRef : public SymbolRef { 137288943Sdimpublic: 138288943Sdim ELFSymbolRef(const SymbolRef &B) : SymbolRef(B) { 139288943Sdim assert(isa<ELFObjectFileBase>(SymbolRef::getObject())); 140288943Sdim } 141288943Sdim 142288943Sdim const ELFObjectFileBase *getObject() const { 143288943Sdim return cast<ELFObjectFileBase>(BasicSymbolRef::getObject()); 144288943Sdim } 145288943Sdim 146288943Sdim uint64_t getSize() const { 147288943Sdim return getObject()->getSymbolSize(getRawDataRefImpl()); 148288943Sdim } 149288943Sdim 150353358Sdim uint8_t getBinding() const { 151353358Sdim return getObject()->getSymbolBinding(getRawDataRefImpl()); 152353358Sdim } 153353358Sdim 154288943Sdim uint8_t getOther() const { 155288943Sdim return getObject()->getSymbolOther(getRawDataRefImpl()); 156288943Sdim } 157288943Sdim 158288943Sdim uint8_t getELFType() const { 159288943Sdim return getObject()->getSymbolELFType(getRawDataRefImpl()); 160288943Sdim } 161353358Sdim 162353358Sdim StringRef getELFTypeName() const { 163353358Sdim uint8_t Type = getELFType(); 164353358Sdim for (auto &EE : ElfSymbolTypes) { 165353358Sdim if (EE.Value == Type) { 166353358Sdim return EE.AltName; 167353358Sdim } 168353358Sdim } 169353358Sdim return ""; 170353358Sdim } 171288943Sdim}; 172288943Sdim 173288943Sdimclass elf_symbol_iterator : public symbol_iterator { 174288943Sdimpublic: 175288943Sdim elf_symbol_iterator(const basic_symbol_iterator &B) 176288943Sdim : symbol_iterator(SymbolRef(B->getRawDataRefImpl(), 177288943Sdim cast<ELFObjectFileBase>(B->getObject()))) {} 178288943Sdim 179288943Sdim const ELFSymbolRef *operator->() const { 180288943Sdim return static_cast<const ELFSymbolRef *>(symbol_iterator::operator->()); 181288943Sdim } 182288943Sdim 183288943Sdim const ELFSymbolRef &operator*() const { 184288943Sdim return static_cast<const ELFSymbolRef &>(symbol_iterator::operator*()); 185288943Sdim } 186288943Sdim}; 187288943Sdim 188288943Sdimclass ELFRelocationRef : public RelocationRef { 189288943Sdimpublic: 190288943Sdim ELFRelocationRef(const RelocationRef &B) : RelocationRef(B) { 191288943Sdim assert(isa<ELFObjectFileBase>(RelocationRef::getObject())); 192288943Sdim } 193288943Sdim 194288943Sdim const ELFObjectFileBase *getObject() const { 195288943Sdim return cast<ELFObjectFileBase>(RelocationRef::getObject()); 196288943Sdim } 197288943Sdim 198327952Sdim Expected<int64_t> getAddend() const { 199288943Sdim return getObject()->getRelocationAddend(getRawDataRefImpl()); 200288943Sdim } 201288943Sdim}; 202288943Sdim 203288943Sdimclass elf_relocation_iterator : public relocation_iterator { 204288943Sdimpublic: 205288943Sdim elf_relocation_iterator(const relocation_iterator &B) 206288943Sdim : relocation_iterator(RelocationRef( 207288943Sdim B->getRawDataRefImpl(), cast<ELFObjectFileBase>(B->getObject()))) {} 208288943Sdim 209288943Sdim const ELFRelocationRef *operator->() const { 210288943Sdim return static_cast<const ELFRelocationRef *>( 211288943Sdim relocation_iterator::operator->()); 212288943Sdim } 213288943Sdim 214288943Sdim const ELFRelocationRef &operator*() const { 215288943Sdim return static_cast<const ELFRelocationRef &>( 216288943Sdim relocation_iterator::operator*()); 217288943Sdim } 218288943Sdim}; 219288943Sdim 220288943Sdiminline ELFObjectFileBase::elf_symbol_iterator_range 221288943SdimELFObjectFileBase::symbols() const { 222288943Sdim return elf_symbol_iterator_range(symbol_begin(), symbol_end()); 223288943Sdim} 224288943Sdim 225280031Sdimtemplate <class ELFT> class ELFObjectFile : public ELFObjectFileBase { 226309124Sdim uint16_t getEMachine() const override; 227341825Sdim uint16_t getEType() const override; 228288943Sdim uint64_t getSymbolSize(DataRefImpl Sym) const override; 229288943Sdim 230280031Sdimpublic: 231259698Sdim LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 232259698Sdim 233341825Sdim using uintX_t = typename ELFT::uint; 234259698Sdim 235341825Sdim using Elf_Sym = typename ELFT::Sym; 236341825Sdim using Elf_Shdr = typename ELFT::Shdr; 237341825Sdim using Elf_Ehdr = typename ELFT::Ehdr; 238341825Sdim using Elf_Rel = typename ELFT::Rel; 239341825Sdim using Elf_Rela = typename ELFT::Rela; 240341825Sdim using Elf_Dyn = typename ELFT::Dyn; 241259698Sdim 242360784Sdim SectionRef toSectionRef(const Elf_Shdr *Sec) const { 243360784Sdim return SectionRef(toDRI(Sec), this); 244360784Sdim } 245360784Sdim 246327952Sdimprivate: 247327952Sdim ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF, 248327952Sdim const Elf_Shdr *DotDynSymSec, const Elf_Shdr *DotSymtabSec, 249327952Sdim ArrayRef<Elf_Word> ShndxTable); 250327952Sdim 251259698Sdimprotected: 252259698Sdim ELFFile<ELFT> EF; 253259698Sdim 254296417Sdim const Elf_Shdr *DotDynSymSec = nullptr; // Dynamic symbol table section. 255296417Sdim const Elf_Shdr *DotSymtabSec = nullptr; // Symbol table section. 256296417Sdim ArrayRef<Elf_Word> ShndxTable; 257296417Sdim 258276479Sdim void moveSymbolNext(DataRefImpl &Symb) const override; 259309124Sdim Expected<StringRef> getSymbolName(DataRefImpl Symb) const override; 260309124Sdim Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override; 261288943Sdim uint64_t getSymbolValueImpl(DataRefImpl Symb) const override; 262288943Sdim uint32_t getSymbolAlignment(DataRefImpl Symb) const override; 263288943Sdim uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override; 264276479Sdim uint32_t getSymbolFlags(DataRefImpl Symb) const override; 265353358Sdim uint8_t getSymbolBinding(DataRefImpl Symb) const override; 266288943Sdim uint8_t getSymbolOther(DataRefImpl Symb) const override; 267288943Sdim uint8_t getSymbolELFType(DataRefImpl Symb) const override; 268309124Sdim Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override; 269309124Sdim Expected<section_iterator> getSymbolSection(const Elf_Sym *Symb, 270309124Sdim const Elf_Shdr *SymTab) const; 271309124Sdim Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override; 272259698Sdim 273276479Sdim void moveSectionNext(DataRefImpl &Sec) const override; 274353358Sdim Expected<StringRef> getSectionName(DataRefImpl Sec) const override; 275280031Sdim uint64_t getSectionAddress(DataRefImpl Sec) const override; 276321369Sdim uint64_t getSectionIndex(DataRefImpl Sec) const override; 277280031Sdim uint64_t getSectionSize(DataRefImpl Sec) const override; 278353358Sdim Expected<ArrayRef<uint8_t>> 279353358Sdim getSectionContents(DataRefImpl Sec) const override; 280280031Sdim uint64_t getSectionAlignment(DataRefImpl Sec) const override; 281309124Sdim bool isSectionCompressed(DataRefImpl Sec) const override; 282280031Sdim bool isSectionText(DataRefImpl Sec) const override; 283280031Sdim bool isSectionData(DataRefImpl Sec) const override; 284280031Sdim bool isSectionBSS(DataRefImpl Sec) const override; 285280031Sdim bool isSectionVirtual(DataRefImpl Sec) const override; 286344779Sdim bool isBerkeleyText(DataRefImpl Sec) const override; 287344779Sdim bool isBerkeleyData(DataRefImpl Sec) const override; 288276479Sdim relocation_iterator section_rel_begin(DataRefImpl Sec) const override; 289276479Sdim relocation_iterator section_rel_end(DataRefImpl Sec) const override; 290341825Sdim std::vector<SectionRef> dynamic_relocation_sections() const override; 291360784Sdim Expected<section_iterator> 292360784Sdim getRelocatedSection(DataRefImpl Sec) const override; 293259698Sdim 294276479Sdim void moveRelocationNext(DataRefImpl &Rel) const override; 295288943Sdim uint64_t getRelocationOffset(DataRefImpl Rel) const override; 296276479Sdim symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override; 297288943Sdim uint64_t getRelocationType(DataRefImpl Rel) const override; 298288943Sdim void getRelocationTypeName(DataRefImpl Rel, 299288943Sdim SmallVectorImpl<char> &Result) const override; 300259698Sdim 301288943Sdim uint32_t getSectionType(DataRefImpl Sec) const override; 302288943Sdim uint64_t getSectionFlags(DataRefImpl Sec) const override; 303314564Sdim uint64_t getSectionOffset(DataRefImpl Sec) const override; 304259698Sdim StringRef getRelocationTypeName(uint32_t Type) const; 305259698Sdim 306341825Sdim /// Get the relocation section that contains \a Rel. 307259698Sdim const Elf_Shdr *getRelSection(DataRefImpl Rel) const { 308314564Sdim auto RelSecOrErr = EF.getSection(Rel.d.a); 309314564Sdim if (!RelSecOrErr) 310314564Sdim report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message()); 311314564Sdim return *RelSecOrErr; 312259698Sdim } 313259698Sdim 314288943Sdim DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const { 315259698Sdim DataRefImpl DRI; 316288943Sdim if (!SymTable) { 317288943Sdim DRI.d.a = 0; 318288943Sdim DRI.d.b = 0; 319288943Sdim return DRI; 320288943Sdim } 321288943Sdim assert(SymTable->sh_type == ELF::SHT_SYMTAB || 322288943Sdim SymTable->sh_type == ELF::SHT_DYNSYM); 323288943Sdim 324314564Sdim auto SectionsOrErr = EF.sections(); 325314564Sdim if (!SectionsOrErr) { 326314564Sdim DRI.d.a = 0; 327314564Sdim DRI.d.b = 0; 328314564Sdim return DRI; 329314564Sdim } 330314564Sdim uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); 331288943Sdim unsigned SymTableIndex = 332288943Sdim (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr); 333288943Sdim 334288943Sdim DRI.d.a = SymTableIndex; 335288943Sdim DRI.d.b = SymbolNum; 336259698Sdim return DRI; 337259698Sdim } 338259698Sdim 339288943Sdim const Elf_Shdr *toELFShdrIter(DataRefImpl Sec) const { 340288943Sdim return reinterpret_cast<const Elf_Shdr *>(Sec.p); 341259698Sdim } 342259698Sdim 343259698Sdim DataRefImpl toDRI(const Elf_Shdr *Sec) const { 344259698Sdim DataRefImpl DRI; 345259698Sdim DRI.p = reinterpret_cast<uintptr_t>(Sec); 346259698Sdim return DRI; 347259698Sdim } 348259698Sdim 349296417Sdim DataRefImpl toDRI(const Elf_Dyn *Dyn) const { 350259698Sdim DataRefImpl DRI; 351296417Sdim DRI.p = reinterpret_cast<uintptr_t>(Dyn); 352259698Sdim return DRI; 353259698Sdim } 354259698Sdim 355288943Sdim bool isExportedToOtherDSO(const Elf_Sym *ESym) const { 356288943Sdim unsigned char Binding = ESym->getBinding(); 357288943Sdim unsigned char Visibility = ESym->getVisibility(); 358288943Sdim 359288943Sdim // A symbol is exported if its binding is either GLOBAL or WEAK, and its 360288943Sdim // visibility is either DEFAULT or PROTECTED. All other symbols are not 361288943Sdim // exported. 362344779Sdim return ( 363344779Sdim (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK || 364344779Sdim Binding == ELF::STB_GNU_UNIQUE) && 365344779Sdim (Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_PROTECTED)); 366288943Sdim } 367288943Sdim 368353358Sdim Error getBuildAttributes(ARMAttributeParser &Attributes) const override { 369353358Sdim auto SectionsOrErr = EF.sections(); 370353358Sdim if (!SectionsOrErr) 371353358Sdim return SectionsOrErr.takeError(); 372353358Sdim 373353358Sdim for (const Elf_Shdr &Sec : *SectionsOrErr) { 374353358Sdim if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) { 375353358Sdim auto ErrorOrContents = EF.getSectionContents(&Sec); 376353358Sdim if (!ErrorOrContents) 377353358Sdim return ErrorOrContents.takeError(); 378353358Sdim 379353358Sdim auto Contents = ErrorOrContents.get(); 380353358Sdim if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1) 381353358Sdim return Error::success(); 382353358Sdim 383353358Sdim Attributes.Parse(Contents, ELFT::TargetEndianness == support::little); 384353358Sdim break; 385353358Sdim } 386353358Sdim } 387353358Sdim return Error::success(); 388353358Sdim } 389353358Sdim 390259698Sdim // This flag is used for classof, to distinguish ELFObjectFile from 391259698Sdim // its subclass. If more subclasses will be created, this flag will 392259698Sdim // have to become an enum. 393259698Sdim bool isDyldELFObject; 394259698Sdim 395259698Sdimpublic: 396327952Sdim ELFObjectFile(ELFObjectFile<ELFT> &&Other); 397327952Sdim static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object); 398259698Sdim 399288943Sdim const Elf_Rel *getRel(DataRefImpl Rel) const; 400288943Sdim const Elf_Rela *getRela(DataRefImpl Rela) const; 401288943Sdim 402296417Sdim const Elf_Sym *getSymbol(DataRefImpl Sym) const { 403314564Sdim auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b); 404314564Sdim if (!Ret) 405314564Sdim report_fatal_error(errorToErrorCode(Ret.takeError()).message()); 406314564Sdim return *Ret; 407296417Sdim } 408259698Sdim 409296417Sdim const Elf_Shdr *getSection(DataRefImpl Sec) const { 410296417Sdim return reinterpret_cast<const Elf_Shdr *>(Sec.p); 411296417Sdim } 412296417Sdim 413314564Sdim basic_symbol_iterator symbol_begin() const override; 414314564Sdim basic_symbol_iterator symbol_end() const override; 415259698Sdim 416288943Sdim elf_symbol_iterator dynamic_symbol_begin() const; 417288943Sdim elf_symbol_iterator dynamic_symbol_end() const; 418259698Sdim 419276479Sdim section_iterator section_begin() const override; 420276479Sdim section_iterator section_end() const override; 421259698Sdim 422327952Sdim Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const override; 423259698Sdim 424276479Sdim uint8_t getBytesInAddress() const override; 425276479Sdim StringRef getFileFormatName() const override; 426327952Sdim Triple::ArchType getArch() const override; 427341825Sdim Expected<uint64_t> getStartAddress() const override; 428259698Sdim 429341825Sdim unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; } 430276479Sdim 431259698Sdim const ELFFile<ELFT> *getELFFile() const { return &EF; } 432259698Sdim 433259698Sdim bool isDyldType() const { return isDyldELFObject; } 434321369Sdim static bool classof(const Binary *v) { 435259698Sdim return v->getType() == getELFType(ELFT::TargetEndianness == support::little, 436259698Sdim ELFT::Is64Bits); 437259698Sdim } 438280031Sdim 439288943Sdim elf_symbol_iterator_range getDynamicSymbolIterators() const override; 440280031Sdim 441280031Sdim bool isRelocatableObject() const override; 442259698Sdim}; 443259698Sdim 444341825Sdimusing ELF32LEObjectFile = ELFObjectFile<ELF32LE>; 445341825Sdimusing ELF64LEObjectFile = ELFObjectFile<ELF64LE>; 446341825Sdimusing ELF32BEObjectFile = ELFObjectFile<ELF32BE>; 447341825Sdimusing ELF64BEObjectFile = ELFObjectFile<ELF64BE>; 448259698Sdim 449259698Sdimtemplate <class ELFT> 450288943Sdimvoid ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const { 451288943Sdim ++Sym.d.b; 452259698Sdim} 453259698Sdim 454259698Sdimtemplate <class ELFT> 455309124SdimExpected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const { 456296417Sdim const Elf_Sym *ESym = getSymbol(Sym); 457314564Sdim auto SymTabOrErr = EF.getSection(Sym.d.a); 458314564Sdim if (!SymTabOrErr) 459314564Sdim return SymTabOrErr.takeError(); 460314564Sdim const Elf_Shdr *SymTableSec = *SymTabOrErr; 461314564Sdim auto StrTabOrErr = EF.getSection(SymTableSec->sh_link); 462314564Sdim if (!StrTabOrErr) 463314564Sdim return StrTabOrErr.takeError(); 464314564Sdim const Elf_Shdr *StringTableSec = *StrTabOrErr; 465314564Sdim auto SymStrTabOrErr = EF.getStringTable(StringTableSec); 466314564Sdim if (!SymStrTabOrErr) 467314564Sdim return SymStrTabOrErr.takeError(); 468353358Sdim Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr); 469360784Sdim if (Name && !Name->empty()) 470360784Sdim return Name; 471353358Sdim 472353358Sdim // If the symbol name is empty use the section name. 473360784Sdim if (ESym->getType() == ELF::STT_SECTION) { 474360784Sdim if (Expected<section_iterator> SecOrErr = getSymbolSection(Sym)) { 475360784Sdim consumeError(Name.takeError()); 476360784Sdim return (*SecOrErr)->getName(); 477360784Sdim } 478353358Sdim } 479353358Sdim return Name; 480259698Sdim} 481259698Sdim 482259698Sdimtemplate <class ELFT> 483288943Sdimuint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const { 484296417Sdim return getSection(Sec)->sh_flags; 485259698Sdim} 486259698Sdim 487259698Sdimtemplate <class ELFT> 488288943Sdimuint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const { 489296417Sdim return getSection(Sec)->sh_type; 490280031Sdim} 491280031Sdim 492280031Sdimtemplate <class ELFT> 493314564Sdimuint64_t ELFObjectFile<ELFT>::getSectionOffset(DataRefImpl Sec) const { 494314564Sdim return getSection(Sec)->sh_offset; 495314564Sdim} 496314564Sdim 497314564Sdimtemplate <class ELFT> 498288943Sdimuint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const { 499288943Sdim const Elf_Sym *ESym = getSymbol(Symb); 500288943Sdim uint64_t Ret = ESym->st_value; 501288943Sdim if (ESym->st_shndx == ELF::SHN_ABS) 502288943Sdim return Ret; 503288943Sdim 504288943Sdim const Elf_Ehdr *Header = EF.getHeader(); 505288943Sdim // Clear the ARM/Thumb or microMIPS indicator flag. 506288943Sdim if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) && 507288943Sdim ESym->getType() == ELF::STT_FUNC) 508288943Sdim Ret &= ~1; 509288943Sdim 510288943Sdim return Ret; 511280031Sdim} 512280031Sdim 513280031Sdimtemplate <class ELFT> 514309124SdimExpected<uint64_t> 515288943SdimELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const { 516288943Sdim uint64_t Result = getSymbolValue(Symb); 517259698Sdim const Elf_Sym *ESym = getSymbol(Symb); 518288943Sdim switch (ESym->st_shndx) { 519259698Sdim case ELF::SHN_COMMON: 520259698Sdim case ELF::SHN_UNDEF: 521259698Sdim case ELF::SHN_ABS: 522288943Sdim return Result; 523259698Sdim } 524259698Sdim 525276479Sdim const Elf_Ehdr *Header = EF.getHeader(); 526314564Sdim auto SymTabOrErr = EF.getSection(Symb.d.a); 527314564Sdim if (!SymTabOrErr) 528314564Sdim return SymTabOrErr.takeError(); 529314564Sdim const Elf_Shdr *SymTab = *SymTabOrErr; 530259698Sdim 531288943Sdim if (Header->e_type == ELF::ET_REL) { 532314564Sdim auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable); 533314564Sdim if (!SectionOrErr) 534314564Sdim return SectionOrErr.takeError(); 535288943Sdim const Elf_Shdr *Section = *SectionOrErr; 536288943Sdim if (Section) 537288943Sdim Result += Section->sh_addr; 538288943Sdim } 539259698Sdim 540288943Sdim return Result; 541259698Sdim} 542259698Sdim 543259698Sdimtemplate <class ELFT> 544288943Sdimuint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const { 545296417Sdim const Elf_Sym *Sym = getSymbol(Symb); 546259698Sdim if (Sym->st_shndx == ELF::SHN_COMMON) 547288943Sdim return Sym->st_value; 548288943Sdim return 0; 549259698Sdim} 550259698Sdim 551259698Sdimtemplate <class ELFT> 552309124Sdimuint16_t ELFObjectFile<ELFT>::getEMachine() const { 553309124Sdim return EF.getHeader()->e_machine; 554309124Sdim} 555309124Sdim 556341825Sdimtemplate <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const { 557341825Sdim return EF.getHeader()->e_type; 558341825Sdim} 559341825Sdim 560309124Sdimtemplate <class ELFT> 561288943Sdimuint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const { 562296417Sdim return getSymbol(Sym)->st_size; 563259698Sdim} 564259698Sdim 565259698Sdimtemplate <class ELFT> 566288943Sdimuint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const { 567296417Sdim return getSymbol(Symb)->st_size; 568276479Sdim} 569276479Sdim 570276479Sdimtemplate <class ELFT> 571353358Sdimuint8_t ELFObjectFile<ELFT>::getSymbolBinding(DataRefImpl Symb) const { 572353358Sdim return getSymbol(Symb)->getBinding(); 573353358Sdim} 574353358Sdim 575353358Sdimtemplate <class ELFT> 576288943Sdimuint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const { 577296417Sdim return getSymbol(Symb)->st_other; 578288943Sdim} 579288943Sdim 580288943Sdimtemplate <class ELFT> 581288943Sdimuint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const { 582296417Sdim return getSymbol(Symb)->getType(); 583288943Sdim} 584288943Sdim 585288943Sdimtemplate <class ELFT> 586309124SdimExpected<SymbolRef::Type> 587309124SdimELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const { 588259698Sdim const Elf_Sym *ESym = getSymbol(Symb); 589259698Sdim 590259698Sdim switch (ESym->getType()) { 591259698Sdim case ELF::STT_NOTYPE: 592288943Sdim return SymbolRef::ST_Unknown; 593259698Sdim case ELF::STT_SECTION: 594288943Sdim return SymbolRef::ST_Debug; 595259698Sdim case ELF::STT_FILE: 596288943Sdim return SymbolRef::ST_File; 597259698Sdim case ELF::STT_FUNC: 598288943Sdim return SymbolRef::ST_Function; 599259698Sdim case ELF::STT_OBJECT: 600259698Sdim case ELF::STT_COMMON: 601259698Sdim case ELF::STT_TLS: 602288943Sdim return SymbolRef::ST_Data; 603259698Sdim default: 604288943Sdim return SymbolRef::ST_Other; 605259698Sdim } 606259698Sdim} 607259698Sdim 608259698Sdimtemplate <class ELFT> 609288943Sdimuint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const { 610296417Sdim const Elf_Sym *ESym = getSymbol(Sym); 611259698Sdim 612276479Sdim uint32_t Result = SymbolRef::SF_None; 613259698Sdim 614259698Sdim if (ESym->getBinding() != ELF::STB_LOCAL) 615259698Sdim Result |= SymbolRef::SF_Global; 616259698Sdim 617259698Sdim if (ESym->getBinding() == ELF::STB_WEAK) 618259698Sdim Result |= SymbolRef::SF_Weak; 619259698Sdim 620259698Sdim if (ESym->st_shndx == ELF::SHN_ABS) 621259698Sdim Result |= SymbolRef::SF_Absolute; 622259698Sdim 623314564Sdim if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION) 624259698Sdim Result |= SymbolRef::SF_FormatSpecific; 625259698Sdim 626314564Sdim auto DotSymtabSecSyms = EF.symbols(DotSymtabSec); 627314564Sdim if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin()) 628314564Sdim Result |= SymbolRef::SF_FormatSpecific; 629314564Sdim auto DotDynSymSecSyms = EF.symbols(DotDynSymSec); 630314564Sdim if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin()) 631314564Sdim Result |= SymbolRef::SF_FormatSpecific; 632314564Sdim 633288943Sdim if (EF.getHeader()->e_machine == ELF::EM_ARM) { 634309124Sdim if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) { 635288943Sdim StringRef Name = *NameOrErr; 636288943Sdim if (Name.startswith("$d") || Name.startswith("$t") || 637288943Sdim Name.startswith("$a")) 638288943Sdim Result |= SymbolRef::SF_FormatSpecific; 639309124Sdim } else { 640309124Sdim // TODO: Actually report errors helpfully. 641309124Sdim consumeError(NameOrErr.takeError()); 642288943Sdim } 643309124Sdim if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 1) 644309124Sdim Result |= SymbolRef::SF_Thumb; 645288943Sdim } 646288943Sdim 647288943Sdim if (ESym->st_shndx == ELF::SHN_UNDEF) 648259698Sdim Result |= SymbolRef::SF_Undefined; 649259698Sdim 650288943Sdim if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON) 651259698Sdim Result |= SymbolRef::SF_Common; 652259698Sdim 653288943Sdim if (isExportedToOtherDSO(ESym)) 654288943Sdim Result |= SymbolRef::SF_Exported; 655288943Sdim 656288943Sdim if (ESym->getVisibility() == ELF::STV_HIDDEN) 657288943Sdim Result |= SymbolRef::SF_Hidden; 658288943Sdim 659276479Sdim return Result; 660259698Sdim} 661259698Sdim 662259698Sdimtemplate <class ELFT> 663309124SdimExpected<section_iterator> 664296417SdimELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym, 665296417Sdim const Elf_Shdr *SymTab) const { 666314564Sdim auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable); 667314564Sdim if (!ESecOrErr) 668314564Sdim return ESecOrErr.takeError(); 669288943Sdim 670288943Sdim const Elf_Shdr *ESec = *ESecOrErr; 671288943Sdim if (!ESec) 672288943Sdim return section_end(); 673288943Sdim 674288943Sdim DataRefImpl Sec; 675288943Sdim Sec.p = reinterpret_cast<intptr_t>(ESec); 676288943Sdim return section_iterator(SectionRef(Sec, this)); 677288943Sdim} 678288943Sdim 679288943Sdimtemplate <class ELFT> 680309124SdimExpected<section_iterator> 681296417SdimELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const { 682296417Sdim const Elf_Sym *Sym = getSymbol(Symb); 683314564Sdim auto SymTabOrErr = EF.getSection(Symb.d.a); 684314564Sdim if (!SymTabOrErr) 685314564Sdim return SymTabOrErr.takeError(); 686314564Sdim const Elf_Shdr *SymTab = *SymTabOrErr; 687296417Sdim return getSymbolSection(Sym, SymTab); 688259698Sdim} 689259698Sdim 690259698Sdimtemplate <class ELFT> 691276479Sdimvoid ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const { 692296417Sdim const Elf_Shdr *ESec = getSection(Sec); 693288943Sdim Sec = toDRI(++ESec); 694259698Sdim} 695259698Sdim 696259698Sdimtemplate <class ELFT> 697353358SdimExpected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const { 698353358Sdim return EF.getSectionName(&*getSection(Sec)); 699259698Sdim} 700259698Sdim 701259698Sdimtemplate <class ELFT> 702280031Sdimuint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const { 703296417Sdim return getSection(Sec)->sh_addr; 704259698Sdim} 705259698Sdim 706259698Sdimtemplate <class ELFT> 707321369Sdimuint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const { 708321369Sdim auto SectionsOrErr = EF.sections(); 709321369Sdim handleAllErrors(std::move(SectionsOrErr.takeError()), 710321369Sdim [](const ErrorInfoBase &) { 711321369Sdim llvm_unreachable("unable to get section index"); 712321369Sdim }); 713321369Sdim const Elf_Shdr *First = SectionsOrErr->begin(); 714321369Sdim return getSection(Sec) - First; 715321369Sdim} 716321369Sdim 717321369Sdimtemplate <class ELFT> 718280031Sdimuint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const { 719296417Sdim return getSection(Sec)->sh_size; 720259698Sdim} 721259698Sdim 722259698Sdimtemplate <class ELFT> 723353358SdimExpected<ArrayRef<uint8_t>> 724353358SdimELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec) const { 725296417Sdim const Elf_Shdr *EShdr = getSection(Sec); 726360784Sdim if (EShdr->sh_type == ELF::SHT_NOBITS) 727360784Sdim return makeArrayRef((const uint8_t *)base(), 0); 728327952Sdim if (std::error_code EC = 729327952Sdim checkOffset(getMemoryBufferRef(), 730327952Sdim (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size)) 731353358Sdim return errorCodeToError(EC); 732353358Sdim return makeArrayRef((const uint8_t *)base() + EShdr->sh_offset, 733353358Sdim EShdr->sh_size); 734259698Sdim} 735259698Sdim 736259698Sdimtemplate <class ELFT> 737280031Sdimuint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const { 738296417Sdim return getSection(Sec)->sh_addralign; 739259698Sdim} 740259698Sdim 741259698Sdimtemplate <class ELFT> 742309124Sdimbool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const { 743309124Sdim return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED; 744309124Sdim} 745309124Sdim 746309124Sdimtemplate <class ELFT> 747280031Sdimbool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const { 748296417Sdim return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR; 749259698Sdim} 750259698Sdim 751259698Sdimtemplate <class ELFT> 752280031Sdimbool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const { 753296417Sdim const Elf_Shdr *EShdr = getSection(Sec); 754341825Sdim return EShdr->sh_type == ELF::SHT_PROGBITS && 755341825Sdim EShdr->sh_flags & ELF::SHF_ALLOC && 756341825Sdim !(EShdr->sh_flags & ELF::SHF_EXECINSTR); 757259698Sdim} 758259698Sdim 759259698Sdimtemplate <class ELFT> 760280031Sdimbool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const { 761296417Sdim const Elf_Shdr *EShdr = getSection(Sec); 762280031Sdim return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) && 763280031Sdim EShdr->sh_type == ELF::SHT_NOBITS; 764259698Sdim} 765259698Sdim 766259698Sdimtemplate <class ELFT> 767341825Sdimstd::vector<SectionRef> 768341825SdimELFObjectFile<ELFT>::dynamic_relocation_sections() const { 769341825Sdim std::vector<SectionRef> Res; 770341825Sdim std::vector<uintptr_t> Offsets; 771341825Sdim 772341825Sdim auto SectionsOrErr = EF.sections(); 773341825Sdim if (!SectionsOrErr) 774341825Sdim return Res; 775341825Sdim 776341825Sdim for (const Elf_Shdr &Sec : *SectionsOrErr) { 777341825Sdim if (Sec.sh_type != ELF::SHT_DYNAMIC) 778341825Sdim continue; 779341825Sdim Elf_Dyn *Dynamic = 780341825Sdim reinterpret_cast<Elf_Dyn *>((uintptr_t)base() + Sec.sh_offset); 781341825Sdim for (; Dynamic->d_tag != ELF::DT_NULL; Dynamic++) { 782341825Sdim if (Dynamic->d_tag == ELF::DT_REL || Dynamic->d_tag == ELF::DT_RELA || 783341825Sdim Dynamic->d_tag == ELF::DT_JMPREL) { 784341825Sdim Offsets.push_back(Dynamic->d_un.d_val); 785341825Sdim } 786341825Sdim } 787341825Sdim } 788341825Sdim for (const Elf_Shdr &Sec : *SectionsOrErr) { 789353358Sdim if (is_contained(Offsets, Sec.sh_addr)) 790341825Sdim Res.emplace_back(toDRI(&Sec), this); 791341825Sdim } 792341825Sdim return Res; 793341825Sdim} 794341825Sdim 795341825Sdimtemplate <class ELFT> 796280031Sdimbool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const { 797296417Sdim return getSection(Sec)->sh_type == ELF::SHT_NOBITS; 798259698Sdim} 799259698Sdim 800259698Sdimtemplate <class ELFT> 801344779Sdimbool ELFObjectFile<ELFT>::isBerkeleyText(DataRefImpl Sec) const { 802344779Sdim return getSection(Sec)->sh_flags & ELF::SHF_ALLOC && 803344779Sdim (getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR || 804344779Sdim !(getSection(Sec)->sh_flags & ELF::SHF_WRITE)); 805344779Sdim} 806344779Sdim 807344779Sdimtemplate <class ELFT> 808344779Sdimbool ELFObjectFile<ELFT>::isBerkeleyData(DataRefImpl Sec) const { 809344779Sdim const Elf_Shdr *EShdr = getSection(Sec); 810344779Sdim return !isBerkeleyText(Sec) && EShdr->sh_type != ELF::SHT_NOBITS && 811344779Sdim EShdr->sh_flags & ELF::SHF_ALLOC; 812344779Sdim} 813344779Sdim 814344779Sdimtemplate <class ELFT> 815259698Sdimrelocation_iterator 816259698SdimELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const { 817259698Sdim DataRefImpl RelData; 818314564Sdim auto SectionsOrErr = EF.sections(); 819314564Sdim if (!SectionsOrErr) 820314564Sdim return relocation_iterator(RelocationRef()); 821314564Sdim uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin()); 822259698Sdim RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize; 823259698Sdim RelData.d.b = 0; 824259698Sdim return relocation_iterator(RelocationRef(RelData, this)); 825259698Sdim} 826259698Sdim 827259698Sdimtemplate <class ELFT> 828259698Sdimrelocation_iterator 829259698SdimELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const { 830259698Sdim const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); 831288943Sdim relocation_iterator Begin = section_rel_begin(Sec); 832259698Sdim if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL) 833288943Sdim return Begin; 834288943Sdim DataRefImpl RelData = Begin->getRawDataRefImpl(); 835309124Sdim const Elf_Shdr *RelSec = getRelSection(RelData); 836309124Sdim 837309124Sdim // Error check sh_link here so that getRelocationSymbol can just use it. 838314564Sdim auto SymSecOrErr = EF.getSection(RelSec->sh_link); 839314564Sdim if (!SymSecOrErr) 840314564Sdim report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message()); 841309124Sdim 842309124Sdim RelData.d.b += S->sh_size / S->sh_entsize; 843259698Sdim return relocation_iterator(RelocationRef(RelData, this)); 844259698Sdim} 845259698Sdim 846259698Sdimtemplate <class ELFT> 847360784SdimExpected<section_iterator> 848259698SdimELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const { 849259698Sdim if (EF.getHeader()->e_type != ELF::ET_REL) 850276479Sdim return section_end(); 851259698Sdim 852296417Sdim const Elf_Shdr *EShdr = getSection(Sec); 853259698Sdim uintX_t Type = EShdr->sh_type; 854259698Sdim if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA) 855276479Sdim return section_end(); 856259698Sdim 857360784Sdim Expected<const Elf_Shdr *> SecOrErr = EF.getSection(EShdr->sh_info); 858360784Sdim if (!SecOrErr) 859360784Sdim return SecOrErr.takeError(); 860360784Sdim return section_iterator(SectionRef(toDRI(*SecOrErr), this)); 861259698Sdim} 862259698Sdim 863259698Sdim// Relocations 864259698Sdimtemplate <class ELFT> 865276479Sdimvoid ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const { 866309124Sdim ++Rel.d.b; 867259698Sdim} 868259698Sdim 869259698Sdimtemplate <class ELFT> 870259698Sdimsymbol_iterator 871259698SdimELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const { 872259698Sdim uint32_t symbolIdx; 873259698Sdim const Elf_Shdr *sec = getRelSection(Rel); 874288943Sdim if (sec->sh_type == ELF::SHT_REL) 875259698Sdim symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL()); 876288943Sdim else 877259698Sdim symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL()); 878259698Sdim if (!symbolIdx) 879276479Sdim return symbol_end(); 880259698Sdim 881309124Sdim // FIXME: error check symbolIdx 882259698Sdim DataRefImpl SymbolData; 883309124Sdim SymbolData.d.a = sec->sh_link; 884309124Sdim SymbolData.d.b = symbolIdx; 885259698Sdim return symbol_iterator(SymbolRef(SymbolData, this)); 886259698Sdim} 887259698Sdim 888259698Sdimtemplate <class ELFT> 889288943Sdimuint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const { 890259698Sdim const Elf_Shdr *sec = getRelSection(Rel); 891288943Sdim if (sec->sh_type == ELF::SHT_REL) 892259698Sdim return getRel(Rel)->r_offset; 893288943Sdim 894288943Sdim return getRela(Rel)->r_offset; 895259698Sdim} 896259698Sdim 897259698Sdimtemplate <class ELFT> 898288943Sdimuint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const { 899259698Sdim const Elf_Shdr *sec = getRelSection(Rel); 900288943Sdim if (sec->sh_type == ELF::SHT_REL) 901288943Sdim return getRel(Rel)->getType(EF.isMips64EL()); 902288943Sdim else 903288943Sdim return getRela(Rel)->getType(EF.isMips64EL()); 904259698Sdim} 905259698Sdim 906259698Sdimtemplate <class ELFT> 907259698SdimStringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const { 908259698Sdim return getELFRelocationTypeName(EF.getHeader()->e_machine, Type); 909259698Sdim} 910259698Sdim 911259698Sdimtemplate <class ELFT> 912288943Sdimvoid ELFObjectFile<ELFT>::getRelocationTypeName( 913259698Sdim DataRefImpl Rel, SmallVectorImpl<char> &Result) const { 914288943Sdim uint32_t type = getRelocationType(Rel); 915259698Sdim EF.getRelocationTypeName(type, Result); 916259698Sdim} 917259698Sdim 918259698Sdimtemplate <class ELFT> 919327952SdimExpected<int64_t> 920288943SdimELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const { 921288943Sdim if (getRelSection(Rel)->sh_type != ELF::SHT_RELA) 922327952Sdim return createError("Section is not SHT_RELA"); 923288943Sdim return (int64_t)getRela(Rel)->r_addend; 924259698Sdim} 925259698Sdim 926259698Sdimtemplate <class ELFT> 927259698Sdimconst typename ELFObjectFile<ELFT>::Elf_Rel * 928259698SdimELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const { 929288943Sdim assert(getRelSection(Rel)->sh_type == ELF::SHT_REL); 930314564Sdim auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b); 931314564Sdim if (!Ret) 932314564Sdim report_fatal_error(errorToErrorCode(Ret.takeError()).message()); 933314564Sdim return *Ret; 934259698Sdim} 935259698Sdim 936259698Sdimtemplate <class ELFT> 937259698Sdimconst typename ELFObjectFile<ELFT>::Elf_Rela * 938259698SdimELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const { 939288943Sdim assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA); 940314564Sdim auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b); 941314564Sdim if (!Ret) 942314564Sdim report_fatal_error(errorToErrorCode(Ret.takeError()).message()); 943314564Sdim return *Ret; 944259698Sdim} 945259698Sdim 946259698Sdimtemplate <class ELFT> 947327952SdimExpected<ELFObjectFile<ELFT>> 948327952SdimELFObjectFile<ELFT>::create(MemoryBufferRef Object) { 949327952Sdim auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer()); 950327952Sdim if (Error E = EFOrErr.takeError()) 951327952Sdim return std::move(E); 952327952Sdim auto EF = std::move(*EFOrErr); 953327952Sdim 954314564Sdim auto SectionsOrErr = EF.sections(); 955327952Sdim if (!SectionsOrErr) 956327952Sdim return SectionsOrErr.takeError(); 957327952Sdim 958327952Sdim const Elf_Shdr *DotDynSymSec = nullptr; 959327952Sdim const Elf_Shdr *DotSymtabSec = nullptr; 960327952Sdim ArrayRef<Elf_Word> ShndxTable; 961314564Sdim for (const Elf_Shdr &Sec : *SectionsOrErr) { 962296417Sdim switch (Sec.sh_type) { 963296417Sdim case ELF::SHT_DYNSYM: { 964353358Sdim if (!DotDynSymSec) 965353358Sdim DotDynSymSec = &Sec; 966296417Sdim break; 967296417Sdim } 968296417Sdim case ELF::SHT_SYMTAB: { 969353358Sdim if (!DotSymtabSec) 970353358Sdim DotSymtabSec = &Sec; 971296417Sdim break; 972296417Sdim } 973296417Sdim case ELF::SHT_SYMTAB_SHNDX: { 974314564Sdim auto TableOrErr = EF.getSHNDXTable(Sec); 975327952Sdim if (!TableOrErr) 976327952Sdim return TableOrErr.takeError(); 977296417Sdim ShndxTable = *TableOrErr; 978296417Sdim break; 979296417Sdim } 980296417Sdim } 981296417Sdim } 982327952Sdim return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec, 983327952Sdim ShndxTable); 984296417Sdim} 985259698Sdim 986259698Sdimtemplate <class ELFT> 987327952SdimELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF, 988327952Sdim const Elf_Shdr *DotDynSymSec, 989327952Sdim const Elf_Shdr *DotSymtabSec, 990327952Sdim ArrayRef<Elf_Word> ShndxTable) 991327952Sdim : ELFObjectFileBase( 992327952Sdim getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits), 993327952Sdim Object), 994327952Sdim EF(EF), DotDynSymSec(DotDynSymSec), DotSymtabSec(DotSymtabSec), 995327952Sdim ShndxTable(ShndxTable) {} 996327952Sdim 997327952Sdimtemplate <class ELFT> 998327952SdimELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other) 999327952Sdim : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec, 1000327952Sdim Other.DotSymtabSec, Other.ShndxTable) {} 1001327952Sdim 1002327952Sdimtemplate <class ELFT> 1003314564Sdimbasic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const { 1004353358Sdim DataRefImpl Sym = 1005353358Sdim toDRI(DotSymtabSec, 1006353358Sdim DotSymtabSec && DotSymtabSec->sh_size >= sizeof(Elf_Sym) ? 1 : 0); 1007288943Sdim return basic_symbol_iterator(SymbolRef(Sym, this)); 1008259698Sdim} 1009259698Sdim 1010259698Sdimtemplate <class ELFT> 1011314564Sdimbasic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const { 1012296417Sdim const Elf_Shdr *SymTab = DotSymtabSec; 1013288943Sdim if (!SymTab) 1014314564Sdim return symbol_begin(); 1015288943Sdim DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); 1016288943Sdim return basic_symbol_iterator(SymbolRef(Sym, this)); 1017259698Sdim} 1018259698Sdim 1019259698Sdimtemplate <class ELFT> 1020288943Sdimelf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const { 1021296417Sdim DataRefImpl Sym = toDRI(DotDynSymSec, 0); 1022288943Sdim return symbol_iterator(SymbolRef(Sym, this)); 1023259698Sdim} 1024259698Sdim 1025259698Sdimtemplate <class ELFT> 1026288943Sdimelf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const { 1027296417Sdim const Elf_Shdr *SymTab = DotDynSymSec; 1028321369Sdim if (!SymTab) 1029321369Sdim return dynamic_symbol_begin(); 1030288943Sdim DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym)); 1031288943Sdim return basic_symbol_iterator(SymbolRef(Sym, this)); 1032259698Sdim} 1033259698Sdim 1034259698Sdimtemplate <class ELFT> 1035276479Sdimsection_iterator ELFObjectFile<ELFT>::section_begin() const { 1036314564Sdim auto SectionsOrErr = EF.sections(); 1037314564Sdim if (!SectionsOrErr) 1038314564Sdim return section_iterator(SectionRef()); 1039314564Sdim return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this)); 1040259698Sdim} 1041259698Sdim 1042259698Sdimtemplate <class ELFT> 1043276479Sdimsection_iterator ELFObjectFile<ELFT>::section_end() const { 1044314564Sdim auto SectionsOrErr = EF.sections(); 1045314564Sdim if (!SectionsOrErr) 1046314564Sdim return section_iterator(SectionRef()); 1047314564Sdim return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this)); 1048259698Sdim} 1049259698Sdim 1050259698Sdimtemplate <class ELFT> 1051259698Sdimuint8_t ELFObjectFile<ELFT>::getBytesInAddress() const { 1052259698Sdim return ELFT::Is64Bits ? 8 : 4; 1053259698Sdim} 1054259698Sdim 1055259698Sdimtemplate <class ELFT> 1056259698SdimStringRef ELFObjectFile<ELFT>::getFileFormatName() const { 1057280031Sdim bool IsLittleEndian = ELFT::TargetEndianness == support::little; 1058259698Sdim switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { 1059259698Sdim case ELF::ELFCLASS32: 1060259698Sdim switch (EF.getHeader()->e_machine) { 1061259698Sdim case ELF::EM_386: 1062259698Sdim return "ELF32-i386"; 1063296417Sdim case ELF::EM_IAMCU: 1064296417Sdim return "ELF32-iamcu"; 1065259698Sdim case ELF::EM_X86_64: 1066259698Sdim return "ELF32-x86-64"; 1067259698Sdim case ELF::EM_ARM: 1068280031Sdim return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big"); 1069296417Sdim case ELF::EM_AVR: 1070296417Sdim return "ELF32-avr"; 1071259698Sdim case ELF::EM_HEXAGON: 1072259698Sdim return "ELF32-hexagon"; 1073309124Sdim case ELF::EM_LANAI: 1074309124Sdim return "ELF32-lanai"; 1075259698Sdim case ELF::EM_MIPS: 1076259698Sdim return "ELF32-mips"; 1077344779Sdim case ELF::EM_MSP430: 1078344779Sdim return "ELF32-msp430"; 1079259698Sdim case ELF::EM_PPC: 1080259698Sdim return "ELF32-ppc"; 1081314564Sdim case ELF::EM_RISCV: 1082314564Sdim return "ELF32-riscv"; 1083262613Sdim case ELF::EM_SPARC: 1084262613Sdim case ELF::EM_SPARC32PLUS: 1085262613Sdim return "ELF32-sparc"; 1086309124Sdim case ELF::EM_AMDGPU: 1087309124Sdim return "ELF32-amdgpu"; 1088259698Sdim default: 1089259698Sdim return "ELF32-unknown"; 1090259698Sdim } 1091259698Sdim case ELF::ELFCLASS64: 1092259698Sdim switch (EF.getHeader()->e_machine) { 1093259698Sdim case ELF::EM_386: 1094259698Sdim return "ELF64-i386"; 1095259698Sdim case ELF::EM_X86_64: 1096259698Sdim return "ELF64-x86-64"; 1097259698Sdim case ELF::EM_AARCH64: 1098280031Sdim return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big"); 1099259698Sdim case ELF::EM_PPC64: 1100259698Sdim return "ELF64-ppc64"; 1101314564Sdim case ELF::EM_RISCV: 1102314564Sdim return "ELF64-riscv"; 1103259698Sdim case ELF::EM_S390: 1104259698Sdim return "ELF64-s390"; 1105262613Sdim case ELF::EM_SPARCV9: 1106262613Sdim return "ELF64-sparc"; 1107276479Sdim case ELF::EM_MIPS: 1108276479Sdim return "ELF64-mips"; 1109309124Sdim case ELF::EM_AMDGPU: 1110327952Sdim return "ELF64-amdgpu"; 1111309124Sdim case ELF::EM_BPF: 1112309124Sdim return "ELF64-BPF"; 1113259698Sdim default: 1114259698Sdim return "ELF64-unknown"; 1115259698Sdim } 1116259698Sdim default: 1117259698Sdim // FIXME: Proper error handling. 1118259698Sdim report_fatal_error("Invalid ELFCLASS!"); 1119259698Sdim } 1120259698Sdim} 1121259698Sdim 1122327952Sdimtemplate <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const { 1123276479Sdim bool IsLittleEndian = ELFT::TargetEndianness == support::little; 1124259698Sdim switch (EF.getHeader()->e_machine) { 1125259698Sdim case ELF::EM_386: 1126296417Sdim case ELF::EM_IAMCU: 1127259698Sdim return Triple::x86; 1128259698Sdim case ELF::EM_X86_64: 1129259698Sdim return Triple::x86_64; 1130259698Sdim case ELF::EM_AARCH64: 1131314564Sdim return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be; 1132259698Sdim case ELF::EM_ARM: 1133259698Sdim return Triple::arm; 1134296417Sdim case ELF::EM_AVR: 1135296417Sdim return Triple::avr; 1136259698Sdim case ELF::EM_HEXAGON: 1137259698Sdim return Triple::hexagon; 1138309124Sdim case ELF::EM_LANAI: 1139309124Sdim return Triple::lanai; 1140259698Sdim case ELF::EM_MIPS: 1141276479Sdim switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { 1142276479Sdim case ELF::ELFCLASS32: 1143276479Sdim return IsLittleEndian ? Triple::mipsel : Triple::mips; 1144276479Sdim case ELF::ELFCLASS64: 1145276479Sdim return IsLittleEndian ? Triple::mips64el : Triple::mips64; 1146276479Sdim default: 1147276479Sdim report_fatal_error("Invalid ELFCLASS!"); 1148276479Sdim } 1149344779Sdim case ELF::EM_MSP430: 1150344779Sdim return Triple::msp430; 1151280031Sdim case ELF::EM_PPC: 1152280031Sdim return Triple::ppc; 1153259698Sdim case ELF::EM_PPC64: 1154276479Sdim return IsLittleEndian ? Triple::ppc64le : Triple::ppc64; 1155314564Sdim case ELF::EM_RISCV: 1156314564Sdim switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) { 1157314564Sdim case ELF::ELFCLASS32: 1158314564Sdim return Triple::riscv32; 1159314564Sdim case ELF::ELFCLASS64: 1160314564Sdim return Triple::riscv64; 1161314564Sdim default: 1162314564Sdim report_fatal_error("Invalid ELFCLASS!"); 1163314564Sdim } 1164259698Sdim case ELF::EM_S390: 1165259698Sdim return Triple::systemz; 1166262613Sdim 1167262613Sdim case ELF::EM_SPARC: 1168262613Sdim case ELF::EM_SPARC32PLUS: 1169288943Sdim return IsLittleEndian ? Triple::sparcel : Triple::sparc; 1170262613Sdim case ELF::EM_SPARCV9: 1171262613Sdim return Triple::sparcv9; 1172262613Sdim 1173327952Sdim case ELF::EM_AMDGPU: { 1174327952Sdim if (!IsLittleEndian) 1175327952Sdim return Triple::UnknownArch; 1176309124Sdim 1177341825Sdim unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH; 1178341825Sdim if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST && 1179341825Sdim MACH <= ELF::EF_AMDGPU_MACH_R600_LAST) 1180327952Sdim return Triple::r600; 1181341825Sdim if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST && 1182341825Sdim MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST) 1183327952Sdim return Triple::amdgcn; 1184341825Sdim 1185341825Sdim return Triple::UnknownArch; 1186327952Sdim } 1187327952Sdim 1188309124Sdim case ELF::EM_BPF: 1189309124Sdim return IsLittleEndian ? Triple::bpfel : Triple::bpfeb; 1190309124Sdim 1191259698Sdim default: 1192259698Sdim return Triple::UnknownArch; 1193259698Sdim } 1194259698Sdim} 1195259698Sdim 1196280031Sdimtemplate <class ELFT> 1197341825SdimExpected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const { 1198341825Sdim return EF.getHeader()->e_entry; 1199341825Sdim} 1200341825Sdim 1201341825Sdimtemplate <class ELFT> 1202288943SdimELFObjectFileBase::elf_symbol_iterator_range 1203288943SdimELFObjectFile<ELFT>::getDynamicSymbolIterators() const { 1204288943Sdim return make_range(dynamic_symbol_begin(), dynamic_symbol_end()); 1205280031Sdim} 1206280031Sdim 1207280031Sdimtemplate <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const { 1208280031Sdim return EF.getHeader()->e_type == ELF::ET_REL; 1209280031Sdim} 1210280031Sdim 1211309124Sdim} // end namespace object 1212309124Sdim} // end namespace llvm 1213276479Sdim 1214309124Sdim#endif // LLVM_OBJECT_ELFOBJECTFILE_H 1215