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}

71Expected<std::unique_ptr>

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

75 std::size_t MaxAlignment =

77 reinterpret_cast<uintptr_t>(Obj.getBufferStart()));

79 if (MaxAlignment < 2)

80 return createError("Insufficient alignment");

87 else

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

160SubtargetFeatures ELFObjectFileBase::getARMFeatures() const {

161 SubtargetFeatures Features;

165 return SubtargetFeatures();

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 case 79:

315 return "v79";

316 case 81:

317 return "v81";

318 default:

319 return {};

320 }

321}

322

323SubtargetFeatures ELFObjectFileBase::getHexagonFeatures() const {

324 SubtargetFeatures Features;

325 HexagonAttributeParser Parser;

327

328

330 return Features;

331 }

332 std::optional Attr;

333

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

338 }

339

341 std::optionalstd::string FeatureString =

343

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

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

346 }

347

349 if (*Attr)

351

353 if (*Attr)

355

357 if (*Attr)

359

361 if (*Attr)

363

365 if (*Attr)

367

368 return Features;

369}

370

371Expected ELFObjectFileBase::getRISCVFeatures() const {

372 SubtargetFeatures Features;

374

377 }

378

381 return std::move(E);

382 }

383

384 std::optional Attr =

386 if (Attr) {

388 if (!ParseResult)

389 return ParseResult.takeError();

390 auto &ISAInfo = *ParseResult;

391

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

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

396 else

398

400 }

401

402 return Features;

403}

404

405SubtargetFeatures ELFObjectFileBase::getLoongArchFeatures() const {

406 SubtargetFeatures Features;

407

410 break;

413

414 [[fallthrough]];

417 break;

418 }

419

420 return Features;

421}

422

426 return getMIPSFeatures();

428 return getARMFeatures();

430 return getRISCVFeatures();

432 return getLoongArchFeatures();

434 return getHexagonFeatures();

435 default:

437 }

438}

439

443 return getAMDGPUCPUName();

445 return getNVPTXCPUName();

451 default:

452 return std::nullopt;

453 }

454}

455

456StringRef ELFObjectFileBase::getAMDGPUCPUName() const {

459

460 switch (CPU) {

461

463 return "r600";

465 return "r630";

467 return "rs880";

469 return "rv670";

470

471

473 return "rv710";

475 return "rv730";

477 return "rv770";

478

479

481 return "cedar";

483 return "cypress";

485 return "juniper";

487 return "redwood";

489 return "sumo";

490

491

493 return "barts";

495 return "caicos";

497 return "cayman";

499 return "turks";

500

501

503 return "gfx600";

505 return "gfx601";

507 return "gfx602";

508

509

511 return "gfx700";

513 return "gfx701";

515 return "gfx702";

517 return "gfx703";

519 return "gfx704";

521 return "gfx705";

522

523

525 return "gfx801";

527 return "gfx802";

529 return "gfx803";

531 return "gfx805";

533 return "gfx810";

534

535

537 return "gfx900";

539 return "gfx902";

541 return "gfx904";

543 return "gfx906";

545 return "gfx908";

547 return "gfx909";

549 return "gfx90a";

551 return "gfx90c";

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";

605 return "gfx1250";

607 return "gfx1251";

608

609

611 return "gfx9-generic";

613 return "gfx9-4-generic";

615 return "gfx10-1-generic";

617 return "gfx10-3-generic";

619 return "gfx11-generic";

621 return "gfx12-generic";

622 default:

624 }

625}

626

627StringRef ELFObjectFileBase::getNVPTXCPUName() const {

633

634 switch (SM) {

635

637 return "sm_20";

639 return "sm_21";

640

641

643 return "sm_30";

645 return "sm_32";

647 return "sm_35";

649 return "sm_37";

650

651

653 return "sm_50";

655 return "sm_52";

657 return "sm_53";

658

659

661 return "sm_60";

663 return "sm_61";

665 return "sm_62";

666

667

669 return "sm_70";

671 return "sm_72";

672

673

675 return "sm_75";

676

677

679 return "sm_80";

681 return "sm_86";

683 return "sm_87";

685 return "sm_88";

686

687

689 return "sm_89";

690

691

694 : "sm_90";

695

696

699 : "sm_100";

702 : "sm_101";

705 : "sm_103";

708 : "sm_110";

709

710

713 : "sm_120";

716 : "sm_121";

717 default:

719 }

720}

721

722

725 return;

726

729

731 return;

732 }

733

735

738 else

740

741 std::optional Attr =

743 if (Attr) {

744 switch (*Attr) {

747 break;

750 break;

753 break;

756 break;

759 break;

762 break;

765 break;

768 break;

771 break;

773 std::optional ArchProfileAttr =

777 else

779 break;

780 }

783 break;

786 break;

789 break;

792 break;

795 break;

797 Triple += "v8m.base";

798 break;

800 Triple += "v8m.main";

801 break;

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

804 break;

807 break;

808 }

809 }

812

814}

815

816std::vector

818 std::string Err;

821 if ()

822 return {};

823 uint32_t JumpSlotReloc = 0, GlobDatReloc = 0;

826 JumpSlotReloc = ELF::R_386_JUMP_SLOT;

827 GlobDatReloc = ELF::R_386_GLOB_DAT;

828 break;

830 JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;

831 GlobDatReloc = ELF::R_X86_64_GLOB_DAT;

832 break;

835 JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;

836 break;

841 JumpSlotReloc = ELF::R_ARM_JUMP_SLOT;

842 break;

844 JumpSlotReloc = ELF::R_HEX_JMP_SLOT;

845 GlobDatReloc = ELF::R_HEX_GLOB_DAT;

846 break;

849 JumpSlotReloc = ELF::R_RISCV_JUMP_SLOT;

850 break;

851 default:

852 return {};

853 }

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

855 std::unique_ptr MIA(

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

857 if (!MIA)

858 return {};

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

860 std::optional RelaPlt, RelaDyn;

864 if (!NameOrErr) {

866 continue;

867 }

869

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

871 RelaPlt = Section;

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

873 RelaDyn = Section;

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

875 GotBaseVA = Section.getAddress();

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

878 if (!PltContents) {

880 return {};

881 }

883 PltEntries,

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

886 }

887 }

888

889

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

892 uint64_t GotPltEntry = GotPlt;

893

894

895

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

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

899 }

900

901

902

903 std::vector Result;

906 for (const auto &R : Rels) {

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

908 continue;

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

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

913 Result.push_back(

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

915 else

917 PltEntryIter->second});

918 }

919 }

920 };

921

922 if (RelaPlt)

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

924

925

926

927 if (RelaDyn)

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

929

930 return Result;

931}

932

933template

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

936 std::vector *PGOAnalyses) {

937 using Elf_Shdr = typename ELFT::Shdr;

939 std::vector BBAddrMaps;

940 if (PGOAnalyses)

941 PGOAnalyses->clear();

942

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

946 return false;

947 if (!TextSectionIndex)

948 return true;

950 if (!TextSecOrErr)

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

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

955 "Text section pointer outside of bounds");

956 if (*TextSectionIndex !=

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

958 return false;

959 return true;

960 };

961

964 if (!SectionRelocMapOrErr)

965 return SectionRelocMapOrErr.takeError();

966

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

968 if (IsRelocatable && !RelocSec)

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

973 if (!BBAddrMapOrErr) {

974 if (PGOAnalyses)

975 PGOAnalyses->clear();

978 }

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

980 std::back_inserter(BBAddrMaps));

981 }

982 if (PGOAnalyses)

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

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

985 "returned when PGO information is requested");

986 return BBAddrMaps;

987}

988

989template

990static Expected<std::vector>

993 using Elf_Shdr = typename ELFT::Shdr;

994 const Elf_Shdr *VerSec = nullptr;

995 const Elf_Shdr *VerNeedSec = nullptr;

996 const Elf_Shdr *VerDefSec = nullptr;

997

1000 VerSec = &Sec;

1002 VerDefSec = &Sec;

1004 VerNeedSec = &Sec;

1005 }

1006 if (!VerSec)

1007 return std::vector();

1008

1011 if (!MapOrErr)

1013

1014 std::vector Ret;

1015 size_t I = 0;

1017 ++I;

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

1020 if (!VerEntryOrErr)

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

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

1024

1026 if (!FlagsOrErr)

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

1029

1030 bool IsDefault;

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

1034 if (!VerOrErr)

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

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

1038

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

1040 }

1041

1042 return Ret;

1043}

1044

1045Expected<std::vector>

1057

1059 std::optional TextSectionIndex,

1060 std::vector *PGOAnalyses) const {

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

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

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

1068 TextSectionIndex, PGOAnalyses);

1069}

1070

1074 return Obj->getCrelDecodeProblem(Data);

1076 return Obj->getCrelDecodeProblem(Data);

1078 return Obj->getCrelDecodeProblem(Data);

1080}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

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

Definition ELFObjectFile.cpp:64

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

Definition ELFObjectFile.cpp:934

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

Definition ELFObjectFile.cpp:290

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

Definition ELFObjectFile.cpp:991

iterator find(const_arg_type_t< KeyT > Val)

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

std::optional< unsigned > getAttributeValue(unsigned tag) const override

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.

Generic base class for all target subtargets.

static LLVM_ABI 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.

LLVM_ABI void AddFeature(StringRef String, bool Enable=true)

Adds Features.

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

Triple - Helper class for working with autoconf configuration names.

LLVM_ABI 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.

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.

DataRefImpl getRawDataRefImpl() const

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 uint8_t getEIdentABIVersion() const =0

virtual Error getBuildAttributes(ELFAttributeParser &Attributes) const =0

std::vector< ELFPltEntry > getPltEntries(const MCSubtargetInfo &STI) const

Definition ELFObjectFile.cpp:817

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

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

Definition ELFObjectFile.cpp:1046

virtual elf_symbol_iterator_range getDynamicSymbolIterators() const =0

StringRef getCrelDecodeProblem(SectionRef Sec) const

Definition ELFObjectFile.cpp:1071

Expected< SubtargetFeatures > getFeatures() const override

Definition ELFObjectFile.cpp:423

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

Definition ELFObjectFile.cpp:440

iterator_range< elf_symbol_iterator > elf_symbol_iterator_range

virtual uint16_t getEMachine() const =0

virtual unsigned getPlatformFlags() const =0

Returns platform-specific object flags, if any.

ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)

Definition ELFObjectFile.cpp:59

void setARMSubArch(Triple &TheTriple) const override

Definition ELFObjectFile.cpp:723

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.

Definition ELFObjectFile.cpp:1058

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

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

Definition ELFObjectFile.cpp:72

Triple makeTriple() const

Create a triple from the data in this object file.

section_iterator_range sections() const

ObjectFile(unsigned int Type, MemoryBufferRef Source)

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

@ EF_LOONGARCH_ABI_SINGLE_FLOAT

@ EF_LOONGARCH_ABI_DOUBLE_FLOAT

@ EF_LOONGARCH_ABI_SOFT_FLOAT

@ EF_LOONGARCH_ABI_MODIFIER_MASK

@ EF_CUDA_ACCELERATORS_V1

@ 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_GFX1250

@ 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_AMDGCN_GFX1251

@ 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

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)

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

Definition ELFObjectFile.cpp:40

This is an optimization pass for GlobalISel generic memory operations.

ArrayRef< CharT > arrayRefFromStringRef(StringRef Input)

Construct a string ref from an array ref of unsigned chars.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

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.

std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

void consumeError(Error Err)

Consume a Error without doing anything.

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

lookupTarget - Lookup a target based on a target triple.