ELFObjectFile.cpp Source File (original) (raw)

29#include

30#include

31#include

32#include

33#include

34#include

35#include

37using namespace llvm;

38using namespace object;

48 {"Unknown", ": 7", 7},

49 {"Unknown", ": 8", 8},

50 {"Unknown", ": 9", 9},

52 {"OS Specific", ": 11", 11},

53 {"OS Specific", ": 12", 12},

54 {"Proc Specific", ": 13", 13},

55 {"Proc Specific", ": 14", 14},

56 {"Proc Specific", ": 15", 15}

57};

62template

66 if (Error E = Ret.takeError())

67 return std::move(E);

68 return std::make_unique<ELFObjectFile>(std::move(*Ret));

69}

73 std::pair<unsigned char, unsigned char> Ident =

75 std::size_t MaxAlignment =

79 if (MaxAlignment < 2)

80 return createError("Insufficient alignment");

84 return createPtr(Obj, InitContent);

86 return createPtr(Obj, InitContent);

87 else

91 return createPtr(Obj, InitContent);

93 return createPtr(Obj, InitContent);

94 else

96 }

98}

103

106 break;

109 break;

112 break;

115 break;

118 break;

121 break;

124 break;

127 break;

130 break;

133 break;

136 break;

137 default:

139 }

140

143

144 break;

147 break;

148 default:

150 }

151

156

157 return Features;

158}

159

166 }

167

168

169 bool isV7 = false;

170 std::optional Attr =

172 if (Attr)

174

176 if (Attr) {

177 switch (*Attr) {

180 break;

183 if (isV7)

185 break;

188 if (isV7)

190 break;

191 }

192 }

193

195 if (Attr) {

196 switch (*Attr) {

197 default:

198 break;

201 Features.AddFeature("thumb2", false);

202 break;

205 break;

206 }

207 }

208

210 if (Attr) {

211 switch (*Attr) {

212 default:

213 break;

215 Features.AddFeature("vfp2sp", false);

216 Features.AddFeature("vfp3d16sp", false);

217 Features.AddFeature("vfp4d16sp", false);

218 break;

221 break;

225 break;

229 break;

230 }

231 }

232

234 if (Attr) {

235 switch (*Attr) {

236 default:

237 break;

241 break;

244 break;

248 break;

249 }

250 }

251

253 if (Attr) {

254 switch (*Attr) {

255 default:

256 break;

259 Features.AddFeature("mve.fp", false);

260 break;

262 Features.AddFeature("mve.fp", false);

264 break;

267 break;

268 }

269 }

270

272 if (Attr) {

273 switch (*Attr) {

274 default:

275 break;

278 Features.AddFeature("hwdiv-arm", false);

279 break;

283 break;

284 }

285 }

286

287 return Features;

288}

289

291 switch (Attr) {

292 case 5:

293 return "v5";

294 case 55:

295 return "v55";

296 case 60:

297 return "v60";

298 case 62:

299 return "v62";

300 case 65:

301 return "v65";

302 case 67:

303 return "v67";

304 case 68:

305 return "v68";

306 case 69:

307 return "v69";

308 case 71:

309 return "v71";

310 case 73:

311 return "v73";

312 case 75:

313 return "v75";

314 default:

315 return {};

316 }

317}

318

323

324

326 return Features;

327 }

328 std::optional Attr;

329

331 if (std::optionalstd::string FeatureString =

334 }

335

337 std::optionalstd::string FeatureString =

339

340 if (FeatureString && *Attr >= 60)

341 Features.AddFeature("hvx" + *FeatureString);

342 }

343

345 if (*Attr)

347

349 if (*Attr)

351

353 if (*Attr)

355

357 if (*Attr)

359

361 if (*Attr)

363

364 return Features;

365}

366

370

373 }

374

377 return std::move(E);

378 }

379

380 std::optional Attr =

382 if (Attr) {

387

388 if (ISAInfo->getXLen() == 32)

390 else if (ISAInfo->getXLen() == 64)

392 else

394

396 }

397

398 return Features;

399}

400

401SubtargetFeatures ELFObjectFileBase::getLoongArchFeatures() const {

403

406 break;

409

410 [[fallthrough]];

413 break;

414 }

415

416 return Features;

417}

418

422 return getMIPSFeatures();

424 return getARMFeatures();

426 return getRISCVFeatures();

428 return getLoongArchFeatures();

430 return getHexagonFeatures();

431 default:

433 }

434}

435

439 return getAMDGPUCPUName();

441 return getNVPTXCPUName();

447 default:

448 return std::nullopt;

449 }

450}

451

452StringRef ELFObjectFileBase::getAMDGPUCPUName() const {

455

456 switch (CPU) {

457

459 return "r600";

461 return "r630";

463 return "rs880";

465 return "rv670";

466

467

469 return "rv710";

471 return "rv730";

473 return "rv770";

474

475

477 return "cedar";

479 return "cypress";

481 return "juniper";

483 return "redwood";

485 return "sumo";

486

487

489 return "barts";

491 return "caicos";

493 return "cayman";

495 return "turks";

496

497

499 return "gfx600";

501 return "gfx601";

503 return "gfx602";

504

505

507 return "gfx700";

509 return "gfx701";

511 return "gfx702";

513 return "gfx703";

515 return "gfx704";

517 return "gfx705";

518

519

521 return "gfx801";

523 return "gfx802";

525 return "gfx803";

527 return "gfx805";

529 return "gfx810";

530

531

533 return "gfx900";

535 return "gfx902";

537 return "gfx904";

539 return "gfx906";

541 return "gfx908";

543 return "gfx909";

545 return "gfx90a";

547 return "gfx90c";

549 return "gfx940";

551 return "gfx941";

553 return "gfx942";

555 return "gfx950";

556

557

559 return "gfx1010";

561 return "gfx1011";

563 return "gfx1012";

565 return "gfx1013";

567 return "gfx1030";

569 return "gfx1031";

571 return "gfx1032";

573 return "gfx1033";

575 return "gfx1034";

577 return "gfx1035";

579 return "gfx1036";

580

581

583 return "gfx1100";

585 return "gfx1101";

587 return "gfx1102";

589 return "gfx1103";

591 return "gfx1150";

593 return "gfx1151";

595 return "gfx1152";

597 return "gfx1153";

598

599

601 return "gfx1200";

603 return "gfx1201";

604

605

607 return "gfx9-generic";

609 return "gfx9-4-generic";

611 return "gfx10-1-generic";

613 return "gfx10-3-generic";

615 return "gfx11-generic";

617 return "gfx12-generic";

618 default:

620 }

621}

622

623StringRef ELFObjectFileBase::getNVPTXCPUName() const {

626

627 switch (SM) {

628

630 return "sm_20";

632 return "sm_21";

633

634

636 return "sm_30";

638 return "sm_32";

640 return "sm_35";

642 return "sm_37";

643

644

646 return "sm_50";

648 return "sm_52";

650 return "sm_53";

651

652

654 return "sm_60";

656 return "sm_61";

658 return "sm_62";

659

660

662 return "sm_70";

664 return "sm_72";

665

666

668 return "sm_75";

669

670

672 return "sm_80";

674 return "sm_86";

676 return "sm_87";

677

678

680 return "sm_89";

681

682

685 default:

687 }

688}

689

690

693 return;

694

697

699 return;

700 }

701

703

706 else

708

709 std::optional Attr =

711 if (Attr) {

712 switch (*Attr) {

715 break;

718 break;

721 break;

724 break;

727 break;

730 break;

733 break;

736 break;

739 break;

741 std::optional ArchProfileAttr =

743 if (ArchProfileAttr &&

746 else

748 break;

749 }

752 break;

755 break;

758 break;

761 break;

764 break;

766 Triple += "v8m.base";

767 break;

769 Triple += "v8m.main";

770 break;

772 Triple += "v8.1m.main";

773 break;

776 break;

777 }

778 }

781

783}

784

786 std::string Err;

789 if ()

790 return {};

791 uint32_t JumpSlotReloc = 0, GlobDatReloc = 0;

794 JumpSlotReloc = ELF::R_386_JUMP_SLOT;

795 GlobDatReloc = ELF::R_386_GLOB_DAT;

796 break;

798 JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;

799 GlobDatReloc = ELF::R_X86_64_GLOB_DAT;

800 break;

803 JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;

804 break;

805 default:

806 return {};

807 }

808 std::unique_ptr MII(T->createMCInstrInfo());

809 std::unique_ptr MIA(

810 T->createMCInstrAnalysis(MII.get()));

811 if (!MIA)

812 return {};

813 std::vector<std::pair<uint64_t, uint64_t>> PltEntries;

814 std::optional RelaPlt, RelaDyn;

818 if (!NameOrErr) {

820 continue;

821 }

823

824 if (Name == ".rela.plt" || Name == ".rel.plt") {

825 RelaPlt = Section;

826 } else if (Name == ".rela.dyn" || Name == ".rel.dyn") {

827 RelaDyn = Section;

828 } else if (Name == ".got.plt") {

829 GotBaseVA = Section.getAddress();

830 } else if (Name == ".plt" || Name == ".plt.got") {

832 if (!PltContents) {

834 return {};

835 }

837 PltEntries,

838 MIA->findPltEntries(Section.getAddress(),

839 arrayRefFromStringRef(*PltContents), Triple));

840 }

841 }

842

843

845 for (auto [Plt, GotPlt] : PltEntries) {

846 uint64_t GotPltEntry = GotPlt;

847

848

849

851 GotPltEntry = static_cast<int32_t>(GotPltEntry) + GotBaseVA;

852 GotToPlt.insert(std::make_pair(GotPltEntry, Plt));

853 }

854

855

856

857 std::vector Result;

860 for (const auto &R : Rels) {

861 if (R.getType() != RelType)

862 continue;

863 auto PltEntryIter = GotToPlt.find(R.getOffset());

864 if (PltEntryIter != GotToPlt.end()) {

867 Result.push_back(

868 ELFPltEntry{PltSec, std::nullopt, PltEntryIter->second});

869 else

870 Result.push_back(ELFPltEntry{PltSec, Sym->getRawDataRefImpl(),

871 PltEntryIter->second});

872 }

873 }

874 };

875

876 if (RelaPlt)

877 handleRels(RelaPlt->relocations(), JumpSlotReloc, ".plt");

878

879

880

881 if (RelaDyn)

882 handleRels(RelaDyn->relocations(), GlobDatReloc, ".plt.got");

883

884 return Result;

885}

886

887template

889 const ELFFile &EF, std::optional TextSectionIndex,

890 std::vector *PGOAnalyses) {

891 using Elf_Shdr = typename ELFT::Shdr;

893 std::vector BBAddrMaps;

894 if (PGOAnalyses)

895 PGOAnalyses->clear();

896

898 auto IsMatch = [&](const Elf_Shdr &Sec) -> Expected {

901 return false;

902 if (!TextSectionIndex)

903 return true;

905 if (!TextSecOrErr)

906 return createError("unable to get the linked-to section for " +

909 assert(*TextSecOrErr >= Sections.begin() &&

910 "Text section pointer outside of bounds");

911 if (*TextSectionIndex !=

912 (unsigned)std::distance(Sections.begin(), *TextSecOrErr))

913 return false;

914 return true;

915 };

916

919 if (!SectionRelocMapOrErr)

920 return SectionRelocMapOrErr.takeError();

921

922 for (auto const &[Sec, RelocSec] : *SectionRelocMapOrErr) {

923 if (IsRelocatable && !RelocSec)

924 return createError("unable to get relocation section for " +

928 if (!BBAddrMapOrErr) {

929 if (PGOAnalyses)

930 PGOAnalyses->clear();

933 }

934 std::move(BBAddrMapOrErr->begin(), BBAddrMapOrErr->end(),

935 std::back_inserter(BBAddrMaps));

936 }

937 if (PGOAnalyses)

938 assert(PGOAnalyses->size() == BBAddrMaps.size() &&

939 "The same number of BBAddrMaps and PGOAnalysisMaps should be "

940 "returned when PGO information is requested");

941 return BBAddrMaps;

942}

943

944template

948 using Elf_Shdr = typename ELFT::Shdr;

949 const Elf_Shdr *VerSec = nullptr;

950 const Elf_Shdr *VerNeedSec = nullptr;

951 const Elf_Shdr *VerDefSec = nullptr;

952

955 VerSec = &Sec;

957 VerDefSec = &Sec;

959 VerNeedSec = &Sec;

960 }

961 if (!VerSec)

962 return std::vector();

963

966 if (!MapOrErr)

968

969 std::vector Ret;

970 size_t I = 0;

972 ++I;

974 EF.template getEntry(*VerSec, I);

975 if (!VerEntryOrErr)

976 return createError("unable to read an entry with index " + Twine(I) +

977 " from " + describe(EF, *VerSec) + ": " +

979

981 if (!FlagsOrErr)

982 return createError("unable to read flags for symbol with index " +

984

985 bool IsDefault;

987 (*VerEntryOrErr)->vs_index, IsDefault, *MapOrErr,

989 if (!VerOrErr)

990 return createError("unable to get a version for entry " + Twine(I) +

991 " of " + describe(EF, *VerSec) + ": " +

993

994 Ret.push_back({(*VerOrErr).str(), IsDefault});

995 }

996

997 return Ret;

998}

999

1003 if (const auto *Obj = dyn_cast(this))

1005 if (const auto *Obj = dyn_cast(this))

1007 if (const auto *Obj = dyn_cast(this))

1010 Symbols);

1011}

1012

1014 std::optional TextSectionIndex,

1015 std::vector *PGOAnalyses) const {

1016 if (const auto *Obj = dyn_cast(this))

1017 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);

1018 if (const auto *Obj = dyn_cast(this))

1019 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);

1020 if (const auto *Obj = dyn_cast(this))

1021 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);

1022 return readBBAddrMapImpl(cast(this)->getELFFile(),

1023 TextSectionIndex, PGOAnalyses);

1024}

1025

1028 if (const auto *Obj = dyn_cast(this))

1029 return Obj->getCrelDecodeProblem(Data);

1030 if (const auto *Obj = dyn_cast(this))

1031 return Obj->getCrelDecodeProblem(Data);

1032 if (const auto *Obj = dyn_cast(this))

1033 return Obj->getCrelDecodeProblem(Data);

1034 return cast(this)->getCrelDecodeProblem(Data);

1035}

static Expected< std::unique_ptr< ELFObjectFile< ELFT > > > createPtr(MemoryBufferRef Object, bool InitContent)

static Expected< std::vector< BBAddrMap > > readBBAddrMapImpl(const ELFFile< ELFT > &EF, std::optional< unsigned > TextSectionIndex, std::vector< PGOAnalysisMap > *PGOAnalyses)

static std::optional< std::string > hexagonAttrToFeatureString(unsigned Attr)

static Expected< std::vector< VersionEntry > > readDynsymVersionsImpl(const ELFFile< ELFT > &EF, ELFObjectFileBase::elf_symbol_iterator_range Symbols)

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

iterator find(const_arg_type_t< KeyT > Val)

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

Lightweight error class with error context and mandatory checking.

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

const char * getBufferStart() const

StringRef getBuffer() const

This class represents success/failure for parsing-like operations that find it important to chain tog...

static llvm::Expected< std::unique_ptr< RISCVISAInfo > > parseNormalizedArchString(StringRef Arch)

Parse RISC-V ISA info from an arch string that is already in normalized form (as defined in the psABI...

StringRef - Represent a constant reference to a string, i.e.

Manages the enabling and disabling of subtarget specific features.

void AddFeature(StringRef String, bool Enable=true)

Adds Features.

void addFeaturesVector(const ArrayRef< std::string > OtherFeatures)

Triple - Helper class for working with autoconf configuration names.

void setArchName(StringRef Str)

Set the architecture (first) component of the triple by name.

bool isThumb() const

Tests whether the target is Thumb (little and big endian).

SubArchType getSubArch() const

get the parsed subarchitecture type for this triple.

ArchType getArch() const

Get the parsed architecture type of this triple.

const std::string & str() const

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

The instances of the Type class are immutable: once they are created, they are never changed.

A range adaptor for a pair of iterators.

bool isLittleEndian() const

const Elf_Ehdr & getHeader() const

Expected< std::vector< BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec=nullptr, std::vector< PGOAnalysisMap > *PGOAnalyses=nullptr) const

Returns a vector of BBAddrMap structs corresponding to each function within the text section that the...

Expected< StringRef > getSymbolVersionByIndex(uint32_t SymbolVersionIndex, bool &IsDefault, SmallVector< std::optional< VersionEntry >, 0 > &VersionMap, std::optional< bool > IsSymHidden) const

Expected< Elf_Shdr_Range > sections() const

Expected< MapVector< const Elf_Shdr *, const Elf_Shdr * > > getSectionAndRelocations(std::function< Expected< bool >(const Elf_Shdr &)> IsMatch) const

Returns a map from every section matching IsMatch to its relocation section, or nullptr if it has no ...

Expected< SmallVector< std::optional< VersionEntry >, 0 > > loadVersionMap(const Elf_Shdr *VerNeedSec, const Elf_Shdr *VerDefSec) const

Expected< const Elf_Shdr * > getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab, DataRegion< Elf_Word > ShndxTable) const

virtual Error getBuildAttributes(ELFAttributeParser &Attributes) const =0

Expected< std::vector< VersionEntry > > readDynsymVersions() const

Returns a vector containing a symbol version for each dynamic symbol.

virtual elf_symbol_iterator_range getDynamicSymbolIterators() const =0

StringRef getCrelDecodeProblem(SectionRef Sec) const

std::vector< ELFPltEntry > getPltEntries() const

Expected< SubtargetFeatures > getFeatures() const override

std::optional< StringRef > tryGetCPUName() const override

virtual uint16_t getEMachine() const =0

virtual unsigned getPlatformFlags() const =0

Returns platform-specific object flags, if any.

ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)

void setARMSubArch(Triple &TheTriple) const override

Expected< std::vector< BBAddrMap > > readBBAddrMap(std::optional< unsigned > TextSectionIndex=std::nullopt, std::vector< PGOAnalysisMap > *PGOAnalyses=nullptr) const

Returns a vector of all BB address maps in the object file.

static Expected< ELFObjectFile< ELFT > > create(MemoryBufferRef Object, bool InitContent=true)

This class is the base class for all object file types.

static Expected< std::unique_ptr< ObjectFile > > createELFObjectFile(MemoryBufferRef Object, bool InitContent=true)

Triple makeTriple() const

Create a triple from the data in this object file.

section_iterator_range sections() const

This is a value type class that represents a single section in the list of sections in the object fil...

DataRefImpl getRawDataRefImpl() const

virtual basic_symbol_iterator symbol_end() const =0

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ AllowMVEIntegerAndFloat

@ SHT_LLVM_BB_ADDR_MAP_V0

@ EF_AMDGPU_MACH_AMDGCN_GFX703

@ EF_AMDGPU_MACH_AMDGCN_GFX1035

@ EF_AMDGPU_MACH_AMDGCN_GFX1031

@ EF_AMDGPU_MACH_R600_CAYMAN

@ EF_AMDGPU_MACH_AMDGCN_GFX704

@ EF_AMDGPU_MACH_AMDGCN_GFX902

@ EF_AMDGPU_MACH_AMDGCN_GFX810

@ EF_AMDGPU_MACH_AMDGCN_GFX950

@ EF_AMDGPU_MACH_AMDGCN_GFX1036

@ EF_AMDGPU_MACH_AMDGCN_GFX1102

@ EF_AMDGPU_MACH_R600_RV730

@ EF_AMDGPU_MACH_R600_RV710

@ EF_AMDGPU_MACH_AMDGCN_GFX908

@ EF_AMDGPU_MACH_AMDGCN_GFX1011

@ EF_AMDGPU_MACH_R600_CYPRESS

@ EF_AMDGPU_MACH_AMDGCN_GFX1032

@ EF_AMDGPU_MACH_R600_R600

@ EF_AMDGPU_MACH_AMDGCN_GFX940

@ EF_AMDGPU_MACH_AMDGCN_GFX941

@ EF_AMDGPU_MACH_R600_TURKS

@ EF_AMDGPU_MACH_R600_JUNIPER

@ EF_AMDGPU_MACH_AMDGCN_GFX601

@ EF_AMDGPU_MACH_AMDGCN_GFX942

@ EF_AMDGPU_MACH_AMDGCN_GFX1152

@ EF_AMDGPU_MACH_R600_R630

@ EF_AMDGPU_MACH_R600_REDWOOD

@ EF_AMDGPU_MACH_R600_RV770

@ EF_AMDGPU_MACH_AMDGCN_GFX600

@ EF_AMDGPU_MACH_AMDGCN_GFX602

@ EF_AMDGPU_MACH_AMDGCN_GFX1101

@ EF_AMDGPU_MACH_AMDGCN_GFX1100

@ EF_AMDGPU_MACH_AMDGCN_GFX1033

@ EF_AMDGPU_MACH_AMDGCN_GFX801

@ EF_AMDGPU_MACH_AMDGCN_GFX705

@ EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX1153

@ EF_AMDGPU_MACH_AMDGCN_GFX1010

@ EF_AMDGPU_MACH_R600_RV670

@ EF_AMDGPU_MACH_AMDGCN_GFX701

@ EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX1012

@ EF_AMDGPU_MACH_AMDGCN_GFX1151

@ EF_AMDGPU_MACH_AMDGCN_GFX1030

@ EF_AMDGPU_MACH_R600_CEDAR

@ EF_AMDGPU_MACH_AMDGCN_GFX1200

@ EF_AMDGPU_MACH_AMDGCN_GFX700

@ EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX803

@ EF_AMDGPU_MACH_AMDGCN_GFX802

@ EF_AMDGPU_MACH_AMDGCN_GFX90C

@ EF_AMDGPU_MACH_AMDGCN_GFX900

@ EF_AMDGPU_MACH_AMDGCN_GFX909

@ EF_AMDGPU_MACH_AMDGCN_GFX906

@ EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX1103

@ EF_AMDGPU_MACH_R600_CAICOS

@ EF_AMDGPU_MACH_AMDGCN_GFX90A

@ EF_AMDGPU_MACH_AMDGCN_GFX1034

@ EF_AMDGPU_MACH_AMDGCN_GFX1013

@ EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC

@ EF_AMDGPU_MACH_AMDGCN_GFX904

@ EF_AMDGPU_MACH_R600_RS880

@ EF_AMDGPU_MACH_AMDGCN_GFX805

@ EF_AMDGPU_MACH_AMDGCN_GFX1201

@ EF_AMDGPU_MACH_AMDGCN_GFX1150

@ EF_AMDGPU_MACH_R600_SUMO

@ EF_AMDGPU_MACH_R600_BARTS

@ EF_AMDGPU_MACH_AMDGCN_GFX702

@ EF_LOONGARCH_ABI_SINGLE_FLOAT

@ EF_LOONGARCH_ABI_DOUBLE_FLOAT

@ EF_LOONGARCH_ABI_SOFT_FLOAT

@ EF_LOONGARCH_ABI_MODIFIER_MASK

Error createError(const Twine &Err)

constexpr int NumElfSymbolTypes

static std::string describe(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)

std::pair< unsigned char, unsigned char > getElfArchType(StringRef Object)

const llvm::EnumEntry< unsigned > ElfSymbolTypes[NumElfSymbolTypes]

This is an optimization pass for GlobalISel generic memory operations.

void append_range(Container &C, Range &&R)

Wrapper function to append range R to container C.

int countr_zero(T Val)

Count number of 0's from the least significant bit to the most stopping at the first 1.

void cantFail(Error Err, const char *Msg=nullptr)

Report a fatal error if Err is a failure value.

const char * toString(DWARFSectionKind Kind)

void consumeError(Error Err)

Consume a Error without doing anything.

static const Target * lookupTarget(StringRef Triple, std::string &Error)

lookupTarget - Lookup a target based on a target triple.