LLVM 18.0.0git
ELFObjectFile.cpp
Go to the documentation of this file.
1//===- ELFObjectFile.cpp - ELF object file implementation -----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Part of the ELFObjectFile class implementation.
10//
11//===----------------------------------------------------------------------===//
12
17#include "llvm/Object/ELF.h"
19#include "llvm/Object/Error.h"
29#include <algorithm>
30#include <cstddef>
31#include <cstdint>
32#include <memory>
33#include <optional>
34#include <string>
35#include <utility>
36
37using namespace llvm;
38using namespace object;
39
41 {"None", "NOTYPE", ELF::STT_NOTYPE},
42 {"Object", "OBJECT", ELF::STT_OBJECT},
43 {"Function", "FUNC", ELF::STT_FUNC},
44 {"Section", "SECTION", ELF::STT_SECTION},
45 {"File", "FILE", ELF::STT_FILE},
46 {"Common", "COMMON", ELF::STT_COMMON},
47 {"TLS", "TLS", ELF::STT_TLS},
48 {"Unknown", "<unknown>: 7", 7},
49 {"Unknown", "<unknown>: 8", 8},
50 {"Unknown", "<unknown>: 9", 9},
51 {"GNU_IFunc", "IFUNC", ELF::STT_GNU_IFUNC},
52 {"OS Specific", "<OS specific>: 11", 11},
53 {"OS Specific", "<OS specific>: 12", 12},
54 {"Proc Specific", "<processor specific>: 13", 13},
55 {"Proc Specific", "<processor specific>: 14", 14},
56 {"Proc Specific", "<processor specific>: 15", 15}
57};
58
60 : ObjectFile(Type, Source) {}
61
62template <class ELFT>
64createPtr(MemoryBufferRef Object, bool InitContent) {
65 auto Ret = ELFObjectFile<ELFT>::create(Object, InitContent);
66 if (Error E = Ret.takeError())
67 return std::move(E);
68 return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
69}
70
73 std::pair<unsigned char, unsigned char> Ident =
75 std::size_t MaxAlignment =
76 1ULL << llvm::countr_zero(
77 reinterpret_cast<uintptr_t>(Obj.getBufferStart()));
78
79 if (MaxAlignment < 2)
80 return createError("Insufficient alignment");
81
82 if (Ident.first == ELF::ELFCLASS32) {
83 if (Ident.second == ELF::ELFDATA2LSB)
84 return createPtr<ELF32LE>(Obj, InitContent);
85 else if (Ident.second == ELF::ELFDATA2MSB)
86 return createPtr<ELF32BE>(Obj, InitContent);
87 else
88 return createError("Invalid ELF data");
89 } else if (Ident.first == ELF::ELFCLASS64) {
90 if (Ident.second == ELF::ELFDATA2LSB)
91 return createPtr<ELF64LE>(Obj, InitContent);
92 else if (Ident.second == ELF::ELFDATA2MSB)
93 return createPtr<ELF64BE>(Obj, InitContent);
94 else
95 return createError("Invalid ELF data");
96 }
97 return createError("Invalid ELF class");
98}
99
100SubtargetFeatures ELFObjectFileBase::getMIPSFeatures() const {
101 SubtargetFeatures Features;
102 unsigned PlatformFlags = getPlatformFlags();
103
104 switch (PlatformFlags & ELF::EF_MIPS_ARCH) {
106 break;
108 Features.AddFeature("mips2");
109 break;
111 Features.AddFeature("mips3");
112 break;
114 Features.AddFeature("mips4");
115 break;
117 Features.AddFeature("mips5");
118 break;
120 Features.AddFeature("mips32");
121 break;
123 Features.AddFeature("mips64");
124 break;
126 Features.AddFeature("mips32r2");
127 break;
129 Features.AddFeature("mips64r2");
130 break;
132 Features.AddFeature("mips32r6");
133 break;
135 Features.AddFeature("mips64r6");
136 break;
137 default:
138 llvm_unreachable("Unknown EF_MIPS_ARCH value");
139 }
140
141 switch (PlatformFlags & ELF::EF_MIPS_MACH) {
143 // No feature associated with this value.
144 break;
146 Features.AddFeature("cnmips");
147 break;
148 default:
149 llvm_unreachable("Unknown EF_MIPS_ARCH value");
150 }
151
152 if (PlatformFlags & ELF::EF_MIPS_ARCH_ASE_M16)
153 Features.AddFeature("mips16");
154 if (PlatformFlags & ELF::EF_MIPS_MICROMIPS)
155 Features.AddFeature("micromips");
156
157 return Features;
158}
159
160SubtargetFeatures ELFObjectFileBase::getARMFeatures() const {
161 SubtargetFeatures Features;
163 if (Error E = getBuildAttributes(Attributes)) {
164 consumeError(std::move(E));
165 return SubtargetFeatures();
166 }
167
168 // both ARMv7-M and R have to support thumb hardware div
169 bool isV7 = false;
170 std::optional<unsigned> Attr =
171 Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
172 if (Attr)
173 isV7 = *Attr == ARMBuildAttrs::v7;
174
175 Attr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);
176 if (Attr) {
177 switch (*Attr) {
179 Features.AddFeature("aclass");
180 break;
182 Features.AddFeature("rclass");
183 if (isV7)
184 Features.AddFeature("hwdiv");
185 break;
187 Features.AddFeature("mclass");
188 if (isV7)
189 Features.AddFeature("hwdiv");
190 break;
191 }
192 }
193
194 Attr = Attributes.getAttributeValue(ARMBuildAttrs::THUMB_ISA_use);
195 if (Attr) {
196 switch (*Attr) {
197 default:
198 break;
200 Features.AddFeature("thumb", false);
201 Features.AddFeature("thumb2", false);
202 break;
204 Features.AddFeature("thumb2");
205 break;
206 }
207 }
208
209 Attr = Attributes.getAttributeValue(ARMBuildAttrs::FP_arch);
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;
220 Features.AddFeature("vfp2");
221 break;
224 Features.AddFeature("vfp3");
225 break;
228 Features.AddFeature("vfp4");
229 break;
230 }
231 }
232
233 Attr = Attributes.getAttributeValue(ARMBuildAttrs::Advanced_SIMD_arch);
234 if (Attr) {
235 switch (*Attr) {
236 default:
237 break;
239 Features.AddFeature("neon", false);
240 Features.AddFeature("fp16", false);
241 break;
243 Features.AddFeature("neon");
244 break;
246 Features.AddFeature("neon");
247 Features.AddFeature("fp16");
248 break;
249 }
250 }
251
252 Attr = Attributes.getAttributeValue(ARMBuildAttrs::MVE_arch);
253 if (Attr) {
254 switch (*Attr) {
255 default:
256 break;
258 Features.AddFeature("mve", false);
259 Features.AddFeature("mve.fp", false);
260 break;
262 Features.AddFeature("mve.fp", false);
263 Features.AddFeature("mve");
264 break;
266 Features.AddFeature("mve.fp");
267 break;
268 }
269 }
270
271 Attr = Attributes.getAttributeValue(ARMBuildAttrs::DIV_use);
272 if (Attr) {
273 switch (*Attr) {
274 default:
275 break;
277 Features.AddFeature("hwdiv", false);
278 Features.AddFeature("hwdiv-arm", false);
279 break;
281 Features.AddFeature("hwdiv");
282 Features.AddFeature("hwdiv-arm");
283 break;
284 }
285 }
286
287 return Features;
288}
289
290Expected<SubtargetFeatures> ELFObjectFileBase::getRISCVFeatures() const {
291 SubtargetFeatures Features;
292 unsigned PlatformFlags = getPlatformFlags();
293
294 if (PlatformFlags & ELF::EF_RISCV_RVC) {
295 Features.AddFeature("c");
296 }
297
299 if (Error E = getBuildAttributes(Attributes)) {
300 return std::move(E);
301 }
302
303 std::optional<StringRef> Attr =
304 Attributes.getAttributeString(RISCVAttrs::ARCH);
305 if (Attr) {
306 auto ParseResult = RISCVISAInfo::parseNormalizedArchString(*Attr);
307 if (!ParseResult)
308 return ParseResult.takeError();
309 auto &ISAInfo = *ParseResult;
310
311 if (ISAInfo->getXLen() == 32)
312 Features.AddFeature("64bit", false);
313 else if (ISAInfo->getXLen() == 64)
314 Features.AddFeature("64bit");
315 else
316 llvm_unreachable("XLEN should be 32 or 64.");
317
318 Features.addFeaturesVector(ISAInfo->toFeatureVector());
319 }
320
321 return Features;
322}
323
324SubtargetFeatures ELFObjectFileBase::getLoongArchFeatures() const {
325 SubtargetFeatures Features;
326
329 break;
331 Features.AddFeature("d");
332 // D implies F according to LoongArch ISA spec.
333 [[fallthrough]];
335 Features.AddFeature("f");
336 break;
337 }
338
339 return Features;
340}
341
343 switch (getEMachine()) {
344 case ELF::EM_MIPS:
345 return getMIPSFeatures();
346 case ELF::EM_ARM:
347 return getARMFeatures();
348 case ELF::EM_RISCV:
349 return getRISCVFeatures();
351 return getLoongArchFeatures();
352 default:
353 return SubtargetFeatures();
354 }
355}
356
357std::optional<StringRef> ELFObjectFileBase::tryGetCPUName() const {
358 switch (getEMachine()) {
359 case ELF::EM_AMDGPU:
360 return getAMDGPUCPUName();
361 case ELF::EM_PPC:
362 case ELF::EM_PPC64:
363 return StringRef("future");
364 default:
365 return std::nullopt;
366 }
367}
368
369StringRef ELFObjectFileBase::getAMDGPUCPUName() const {
371 unsigned CPU = getPlatformFlags() & ELF::EF_AMDGPU_MACH;
372
373 switch (CPU) {
374 // Radeon HD 2000/3000 Series (R600).
376 return "r600";
378 return "r630";
380 return "rs880";
382 return "rv670";
383
384 // Radeon HD 4000 Series (R700).
386 return "rv710";
388 return "rv730";
390 return "rv770";
391
392 // Radeon HD 5000 Series (Evergreen).
394 return "cedar";
396 return "cypress";
398 return "juniper";
400 return "redwood";
402 return "sumo";
403
404 // Radeon HD 6000 Series (Northern Islands).
406 return "barts";
408 return "caicos";
410 return "cayman";
412 return "turks";
413
414 // AMDGCN GFX6.
416 return "gfx600";
418 return "gfx601";
420 return "gfx602";
421
422 // AMDGCN GFX7.
424 return "gfx700";
426 return "gfx701";
428 return "gfx702";
430 return "gfx703";
432 return "gfx704";
434 return "gfx705";
435
436 // AMDGCN GFX8.
438 return "gfx801";
440 return "gfx802";
442 return "gfx803";
444 return "gfx805";
446 return "gfx810";
447
448 // AMDGCN GFX9.
450 return "gfx900";
452 return "gfx902";
454 return "gfx904";
456 return "gfx906";
458 return "gfx908";
460 return "gfx909";
462 return "gfx90a";
464 return "gfx90c";
466 return "gfx940";
468 return "gfx941";
470 return "gfx942";
471
472 // AMDGCN GFX10.
474 return "gfx1010";
476 return "gfx1011";
478 return "gfx1012";
480 return "gfx1013";
482 return "gfx1030";
484 return "gfx1031";
486 return "gfx1032";
488 return "gfx1033";
490 return "gfx1034";
492 return "gfx1035";
494 return "gfx1036";
495
496 // AMDGCN GFX11.
498 return "gfx1100";
500 return "gfx1101";
502 return "gfx1102";
504 return "gfx1103";
506 return "gfx1150";
508 return "gfx1151";
509 default:
510 llvm_unreachable("Unknown EF_AMDGPU_MACH value");
511 }
512}
513
514// FIXME Encode from a tablegen description or target parser.
516 if (TheTriple.getSubArch() != Triple::NoSubArch)
517 return;
518
521 // TODO Propagate Error.
522 consumeError(std::move(E));
523 return;
524 }
525
526 std::string Triple;
527 // Default to ARM, but use the triple if it's been set.
528 if (TheTriple.isThumb())
529 Triple = "thumb";
530 else
531 Triple = "arm";
532
533 std::optional<unsigned> Attr =
534 Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
535 if (Attr) {
536 switch (*Attr) {
538 Triple += "v4";
539 break;
541 Triple += "v4t";
542 break;
544 Triple += "v5t";
545 break;
547 Triple += "v5te";
548 break;
550 Triple += "v5tej";
551 break;
553 Triple += "v6";
554 break;
556 Triple += "v6kz";
557 break;
559 Triple += "v6t2";
560 break;
562 Triple += "v6k";
563 break;
564 case ARMBuildAttrs::v7: {
565 std::optional<unsigned> ArchProfileAttr =
567 if (ArchProfileAttr &&
568 *ArchProfileAttr == ARMBuildAttrs::MicroControllerProfile)
569 Triple += "v7m";
570 else
571 Triple += "v7";
572 break;
573 }
575 Triple += "v6m";
576 break;
578 Triple += "v6sm";
579 break;
581 Triple += "v7em";
582 break;
584 Triple += "v8a";
585 break;
587 Triple += "v8r";
588 break;
590 Triple += "v8m.base";
591 break;
593 Triple += "v8m.main";
594 break;
596 Triple += "v8.1m.main";
597 break;
599 Triple += "v9a";
600 break;
601 }
602 }
603 if (!isLittleEndian())
604 Triple += "eb";
605
606 TheTriple.setArchName(Triple);
607}
608
609std::vector<ELFPltEntry> ELFObjectFileBase::getPltEntries() const {
610 std::string Err;
611 const auto Triple = makeTriple();
612 const auto *T = TargetRegistry::lookupTarget(Triple.str(), Err);
613 if (!T)
614 return {};
615 uint32_t JumpSlotReloc = 0, GlobDatReloc = 0;
616 switch (Triple.getArch()) {
617 case Triple::x86:
618 JumpSlotReloc = ELF::R_386_JUMP_SLOT;
619 GlobDatReloc = ELF::R_386_GLOB_DAT;
620 break;
621 case Triple::x86_64:
622 JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;
623 GlobDatReloc = ELF::R_X86_64_GLOB_DAT;
624 break;
625 case Triple::aarch64:
627 JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;
628 break;
629 default:
630 return {};
631 }
632 std::unique_ptr<const MCInstrInfo> MII(T->createMCInstrInfo());
633 std::unique_ptr<const MCInstrAnalysis> MIA(
634 T->createMCInstrAnalysis(MII.get()));
635 if (!MIA)
636 return {};
637 std::vector<std::pair<uint64_t, uint64_t>> PltEntries;
638 std::optional<SectionRef> RelaPlt, RelaDyn;
639 uint64_t GotBaseVA = 0;
640 for (const SectionRef &Section : sections()) {
641 Expected<StringRef> NameOrErr = Section.getName();
642 if (!NameOrErr) {
643 consumeError(NameOrErr.takeError());
644 continue;
645 }
646 StringRef Name = *NameOrErr;
647
648 if (Name == ".rela.plt" || Name == ".rel.plt") {
649 RelaPlt = Section;
650 } else if (Name == ".rela.dyn" || Name == ".rel.dyn") {
651 RelaDyn = Section;
652 } else if (Name == ".got.plt") {
653 GotBaseVA = Section.getAddress();
654 } else if (Name == ".plt" || Name == ".plt.got") {
655 Expected<StringRef> PltContents = Section.getContents();
656 if (!PltContents) {
657 consumeError(PltContents.takeError());
658 return {};
659 }
661 PltEntries,
662 MIA->findPltEntries(Section.getAddress(),
663 arrayRefFromStringRef(*PltContents), Triple));
664 }
665 }
666
667 // Build a map from GOT entry virtual address to PLT entry virtual address.
669 for (auto [Plt, GotPlt] : PltEntries) {
670 uint64_t GotPltEntry = GotPlt;
671 // An x86-32 PIC PLT uses jmp DWORD PTR [ebx-offset]. Add
672 // _GLOBAL_OFFSET_TABLE_ (EBX) to get the .got.plt (or .got) entry address.
673 // See X86MCTargetDesc.cpp:findPltEntries for the 1 << 32 bit.
674 if (GotPltEntry & (uint64_t(1) << 32) && getEMachine() == ELF::EM_386)
675 GotPltEntry = static_cast<int32_t>(GotPltEntry) + GotBaseVA;
676 GotToPlt.insert(std::make_pair(GotPltEntry, Plt));
677 }
678
679 // Find the relocations in the dynamic relocation table that point to
680 // locations in the GOT for which we know the corresponding PLT entry.
681 std::vector<ELFPltEntry> Result;
682 auto handleRels = [&](iterator_range<relocation_iterator> Rels,
683 uint32_t RelType, StringRef PltSec) {
684 for (const auto &R : Rels) {
685 if (R.getType() != RelType)
686 continue;
687 auto PltEntryIter = GotToPlt.find(R.getOffset());
688 if (PltEntryIter != GotToPlt.end()) {
689 symbol_iterator Sym = R.getSymbol();
690 if (Sym == symbol_end())
691 Result.push_back(
692 ELFPltEntry{PltSec, std::nullopt, PltEntryIter->second});
693 else
694 Result.push_back(ELFPltEntry{PltSec, Sym->getRawDataRefImpl(),
695 PltEntryIter->second});
696 }
697 }
698 };
699
700 if (RelaPlt)
701 handleRels(RelaPlt->relocations(), JumpSlotReloc, ".plt");
702
703 // If a symbol needing a PLT entry also needs a GLOB_DAT relocation, GNU ld's
704 // x86 port places the PLT entry in the .plt.got section.
705 if (RelaDyn)
706 handleRels(RelaDyn->relocations(), GlobDatReloc, ".plt.got");
707
708 return Result;
709}
710
711template <class ELFT>
713 const ELFFile<ELFT> &EF, std::optional<unsigned> TextSectionIndex) {
714 using Elf_Shdr = typename ELFT::Shdr;
715 bool IsRelocatable = EF.getHeader().e_type == ELF::ET_REL;
716 std::vector<BBAddrMap> BBAddrMaps;
717
718 const auto &Sections = cantFail(EF.sections());
719 auto IsMatch = [&](const Elf_Shdr &Sec) -> Expected<bool> {
720 if (Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP &&
721 Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP_V0)
722 return false;
723 if (!TextSectionIndex)
724 return true;
725 Expected<const Elf_Shdr *> TextSecOrErr = EF.getSection(Sec.sh_link);
726 if (!TextSecOrErr)
727 return createError("unable to get the linked-to section for " +
728 describe(EF, Sec) + ": " +
729 toString(TextSecOrErr.takeError()));
730 if (*TextSectionIndex != std::distance(Sections.begin(), *TextSecOrErr))
731 return false;
732 return true;
733 };
734
736 EF.getSectionAndRelocations(IsMatch);
737 if (!SectionRelocMapOrErr)
738 return SectionRelocMapOrErr.takeError();
739
740 for (auto const &[Sec, RelocSec] : *SectionRelocMapOrErr) {
741 if (IsRelocatable && !RelocSec)
742 return createError("unable to get relocation section for " +
743 describe(EF, *Sec));
744 Expected<std::vector<BBAddrMap>> BBAddrMapOrErr =
745 EF.decodeBBAddrMap(*Sec, RelocSec);
746 if (!BBAddrMapOrErr)
747 return createError("unable to read " + describe(EF, *Sec) + ": " +
748 toString(BBAddrMapOrErr.takeError()));
749 std::move(BBAddrMapOrErr->begin(), BBAddrMapOrErr->end(),
750 std::back_inserter(BBAddrMaps));
751 }
752 return BBAddrMaps;
753}
754
755template <class ELFT>
759 using Elf_Shdr = typename ELFT::Shdr;
760 const Elf_Shdr *VerSec = nullptr;
761 const Elf_Shdr *VerNeedSec = nullptr;
762 const Elf_Shdr *VerDefSec = nullptr;
763 // The user should ensure sections() can't fail here.
764 for (const Elf_Shdr &Sec : cantFail(EF.sections())) {
765 if (Sec.sh_type == ELF::SHT_GNU_versym)
766 VerSec = &Sec;
767 else if (Sec.sh_type == ELF::SHT_GNU_verdef)
768 VerDefSec = &Sec;
769 else if (Sec.sh_type == ELF::SHT_GNU_verneed)
770 VerNeedSec = &Sec;
771 }
772 if (!VerSec)
773 return std::vector<VersionEntry>();
774
776 EF.loadVersionMap(VerNeedSec, VerDefSec);
777 if (!MapOrErr)
778 return MapOrErr.takeError();
779
780 std::vector<VersionEntry> Ret;
781 size_t I = 0;
782 for (const ELFSymbolRef &Sym : Symbols) {
783 ++I;
785 EF.template getEntry<typename ELFT::Versym>(*VerSec, I);
786 if (!VerEntryOrErr)
787 return createError("unable to read an entry with index " + Twine(I) +
788 " from " + describe(EF, *VerSec) + ": " +
789 toString(VerEntryOrErr.takeError()));
790
791 Expected<uint32_t> FlagsOrErr = Sym.getFlags();
792 if (!FlagsOrErr)
793 return createError("unable to read flags for symbol with index " +
794 Twine(I) + ": " + toString(FlagsOrErr.takeError()));
795
796 bool IsDefault;
798 (*VerEntryOrErr)->vs_index, IsDefault, *MapOrErr,
799 (*FlagsOrErr) & SymbolRef::SF_Undefined);
800 if (!VerOrErr)
801 return createError("unable to get a version for entry " + Twine(I) +
802 " of " + describe(EF, *VerSec) + ": " +
803 toString(VerOrErr.takeError()));
804
805 Ret.push_back({(*VerOrErr).str(), IsDefault});
806 }
807
808 return Ret;
809}
810
814 if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
815 return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
816 if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
817 return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
818 if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
819 return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
820 return readDynsymVersionsImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
821 Symbols);
822}
823
825 std::optional<unsigned> TextSectionIndex) const {
826 if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
827 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
828 if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
829 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
830 if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
831 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
832 return readBBAddrMapImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
833 TextSectionIndex);
834}
AMDGPU Kernel Attributes
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
std::string Name
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)
static Expected< std::vector< VersionEntry > > readDynsymVersionsImpl(const ELFFile< ELFT > &EF, ELFObjectFileBase::elf_symbol_iterator_range Symbols)
Symbol * Sym
Definition: ELF_riscv.cpp:468
#define I(x, y, z)
Definition: MD5.cpp:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
iterator end()
Definition: DenseMap.h:84
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
const char * getBufferStart() const
StringRef getBuffer() const
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.
Definition: StringRef.h:50
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.
Definition: Triple.h:44
void setArchName(StringRef Str)
Set the architecture (first) component of the triple by name.
Definition: Triple.cpp:1358
bool isThumb() const
Tests whether the target is Thumb (little and big endian).
Definition: Triple.h:806
SubArchType getSubArch() const
get the parsed subarchitecture type for this triple.
Definition: Triple.h:358
@ aarch64_be
Definition: Triple.h:52
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:355
const std::string & str() const
Definition: Triple.h:414
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
A range adaptor for a pair of iterators.
bool isLittleEndian() const
Definition: Binary.h:155
const Elf_Ehdr & getHeader() const
Definition: ELF.h:192
Expected< std::vector< BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec=nullptr) const
Returns a vector of BBAddrMap structs corresponding to each function within the text section that the...
Definition: ELF.cpp:650
Expected< StringRef > getSymbolVersionByIndex(uint32_t SymbolVersionIndex, bool &IsDefault, SmallVector< std::optional< VersionEntry >, 0 > &VersionMap, std::optional< bool > IsSymHidden) const
Definition: ELF.h:909
Expected< Elf_Shdr_Range > sections() const
Definition: ELF.h:829
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 ...
Definition: ELF.cpp:761
Expected< SmallVector< std::optional< VersionEntry >, 0 > > loadVersionMap(const Elf_Shdr *VerNeedSec, const Elf_Shdr *VerDefSec) const
Definition: ELF.h:623
Expected< const Elf_Shdr * > getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab, DataRegion< Elf_Word > ShndxTable) const
Definition: ELF.h:481
Expected< std::vector< BBAddrMap > > readBBAddrMap(std::optional< unsigned > TextSectionIndex=std::nullopt) const
Returns a vector of all BB address maps in the object file. When.
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
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
static Expected< ELFObjectFile< ELFT > > create(MemoryBufferRef Object, bool InitContent=true)
This class is the base class for all object file types.
Definition: ObjectFile.h:229
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.
Definition: ObjectFile.cpp:109
section_iterator_range sections() const
Definition: ObjectFile.h:328
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
virtual basic_symbol_iterator symbol_end() const =0
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ ET_REL
Definition: ELF.h:116
@ EM_PPC64
Definition: ELF.h:149
@ EM_386
Definition: ELF.h:136
@ EM_LOONGARCH
Definition: ELF.h:322
@ EM_PPC
Definition: ELF.h:148
@ EM_MIPS
Definition: ELF.h:141
@ EM_RISCV
Definition: ELF.h:317
@ EM_ARM
Definition: ELF.h:156
@ EM_AMDGPU
Definition: ELF.h:316
@ ELFDATA2MSB
Definition: ELF.h:336
@ ELFDATA2LSB
Definition: ELF.h:335
@ SHT_LLVM_BB_ADDR_MAP_V0
Definition: ELF.h:1033
@ SHT_GNU_verneed
Definition: ELF.h:1046
@ SHT_GNU_verdef
Definition: ELF.h:1045
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:1037
@ SHT_GNU_versym
Definition: ELF.h:1047
@ EF_AMDGPU_MACH_AMDGCN_GFX703
Definition: ELF.h:746
@ EF_AMDGPU_MACH_AMDGCN_GFX1035
Definition: ELF.h:770
@ EF_AMDGPU_MACH_AMDGCN_GFX1031
Definition: ELF.h:764
@ EF_AMDGPU_MACH_R600_CAYMAN
Definition: ELF.h:729
@ EF_AMDGPU_MACH_AMDGCN_GFX704
Definition: ELF.h:747
@ EF_AMDGPU_MACH_AMDGCN_GFX902
Definition: ELF.h:754
@ EF_AMDGPU_MACH_AMDGCN_GFX810
Definition: ELF.h:752
@ EF_AMDGPU_MACH_AMDGCN_GFX1036
Definition: ELF.h:778
@ EF_AMDGPU_MACH_AMDGCN_GFX1102
Definition: ELF.h:780
@ EF_AMDGPU_MACH_R600_RV730
Definition: ELF.h:718
@ EF_AMDGPU_MACH_R600_RV710
Definition: ELF.h:717
@ EF_AMDGPU_MACH_AMDGCN_GFX908
Definition: ELF.h:757
@ EF_AMDGPU_MACH_AMDGCN_GFX1011
Definition: ELF.h:761
@ EF_AMDGPU_MACH_R600_CYPRESS
Definition: ELF.h:722
@ EF_AMDGPU_MACH_AMDGCN_GFX1032
Definition: ELF.h:765
@ EF_AMDGPU_MACH_R600_R600
Definition: ELF.h:712
@ EF_AMDGPU_MACH_AMDGCN_GFX940
Definition: ELF.h:773
@ EF_AMDGPU_MACH_AMDGCN_GFX941
Definition: ELF.h:784
@ EF_AMDGPU_MACH_R600_TURKS
Definition: ELF.h:730
@ EF_AMDGPU_MACH_R600_JUNIPER
Definition: ELF.h:723
@ EF_AMDGPU_MACH_AMDGCN_GFX601
Definition: ELF.h:742
@ EF_AMDGPU_MACH_AMDGCN_GFX942
Definition: ELF.h:785
@ EF_AMDGPU_MACH_R600_R630
Definition: ELF.h:713
@ EF_AMDGPU_MACH_R600_REDWOOD
Definition: ELF.h:724
@ EF_AMDGPU_MACH_R600_RV770
Definition: ELF.h:719
@ EF_AMDGPU_MACH_AMDGCN_GFX600
Definition: ELF.h:741
@ EF_AMDGPU_MACH_AMDGCN_GFX602
Definition: ELF.h:767
@ EF_AMDGPU_MACH_AMDGCN_GFX1101
Definition: ELF.h:779
@ EF_AMDGPU_MACH_AMDGCN_GFX1100
Definition: ELF.h:774
@ EF_AMDGPU_MACH_AMDGCN_GFX1033
Definition: ELF.h:766
@ EF_AMDGPU_MACH_AMDGCN_GFX801
Definition: ELF.h:749
@ EF_AMDGPU_MACH_AMDGCN_GFX705
Definition: ELF.h:768
@ EF_AMDGPU_MACH_AMDGCN_GFX1010
Definition: ELF.h:760
@ EF_AMDGPU_MACH_R600_RV670
Definition: ELF.h:715
@ EF_AMDGPU_MACH_AMDGCN_GFX701
Definition: ELF.h:744
@ EF_AMDGPU_MACH_AMDGCN_GFX1012
Definition: ELF.h:762
@ EF_AMDGPU_MACH_AMDGCN_GFX1151
Definition: ELF.h:783
@ EF_AMDGPU_MACH_AMDGCN_GFX1030
Definition: ELF.h:763
@ EF_AMDGPU_MACH_R600_CEDAR
Definition: ELF.h:721
@ EF_AMDGPU_MACH_AMDGCN_GFX700
Definition: ELF.h:743
@ EF_AMDGPU_MACH_AMDGCN_GFX803
Definition: ELF.h:751
@ EF_AMDGPU_MACH_AMDGCN_GFX802
Definition: ELF.h:750
@ EF_AMDGPU_MACH_AMDGCN_GFX90C
Definition: ELF.h:759
@ EF_AMDGPU_MACH_AMDGCN_GFX900
Definition: ELF.h:753
@ EF_AMDGPU_MACH_AMDGCN_GFX909
Definition: ELF.h:758
@ EF_AMDGPU_MACH
Definition: ELF.h:704
@ EF_AMDGPU_MACH_AMDGCN_GFX906
Definition: ELF.h:756
@ EF_AMDGPU_MACH_AMDGCN_GFX1103
Definition: ELF.h:777
@ EF_AMDGPU_MACH_R600_CAICOS
Definition: ELF.h:728
@ EF_AMDGPU_MACH_AMDGCN_GFX90A
Definition: ELF.h:772
@ EF_AMDGPU_MACH_AMDGCN_GFX1034
Definition: ELF.h:771
@ EF_AMDGPU_MACH_AMDGCN_GFX1013
Definition: ELF.h:775
@ EF_AMDGPU_MACH_AMDGCN_GFX904
Definition: ELF.h:755
@ EF_AMDGPU_MACH_R600_RS880
Definition: ELF.h:714
@ EF_AMDGPU_MACH_AMDGCN_GFX805
Definition: ELF.h:769
@ EF_AMDGPU_MACH_AMDGCN_GFX1150
Definition: ELF.h:776
@ EF_AMDGPU_MACH_R600_SUMO
Definition: ELF.h:725
@ EF_AMDGPU_MACH_R600_BARTS
Definition: ELF.h:727
@ EF_AMDGPU_MACH_AMDGCN_GFX702
Definition: ELF.h:745
@ EF_MIPS_ARCH
Definition: ELF.h:565
@ EF_MIPS_MICROMIPS
Definition: ELF.h:548
@ EF_MIPS_ARCH_32R6
Definition: ELF.h:563
@ EF_MIPS_MACH_NONE
Definition: ELF.h:526
@ EF_MIPS_ARCH_64
Definition: ELF.h:560
@ EF_MIPS_ARCH_32
Definition: ELF.h:559
@ EF_MIPS_MACH_OCTEON
Definition: ELF.h:534
@ EF_MIPS_ARCH_4
Definition: ELF.h:557
@ EF_MIPS_ARCH_5
Definition: ELF.h:558
@ EF_MIPS_ARCH_2
Definition: ELF.h:555
@ EF_MIPS_ARCH_32R2
Definition: ELF.h:561
@ EF_MIPS_ARCH_64R2
Definition: ELF.h:562
@ EF_MIPS_ARCH_ASE_M16
Definition: ELF.h:549
@ EF_MIPS_MACH
Definition: ELF.h:545
@ EF_MIPS_ARCH_1
Definition: ELF.h:554
@ EF_MIPS_ARCH_64R6
Definition: ELF.h:564
@ EF_MIPS_ARCH_3
Definition: ELF.h:556
@ ELFCLASS64
Definition: ELF.h:329
@ ELFCLASS32
Definition: ELF.h:328
@ EF_LOONGARCH_ABI_SINGLE_FLOAT
Definition: ELF.h:923
@ EF_LOONGARCH_ABI_DOUBLE_FLOAT
Definition: ELF.h:924
@ EF_LOONGARCH_ABI_SOFT_FLOAT
Definition: ELF.h:922
@ EF_LOONGARCH_ABI_MODIFIER_MASK
Definition: ELF.h:925
@ EF_RISCV_RVC
Definition: ELF.h:670
@ STT_FUNC
Definition: ELF.h:1256
@ STT_NOTYPE
Definition: ELF.h:1254
@ STT_SECTION
Definition: ELF.h:1257
@ STT_FILE
Definition: ELF.h:1258
@ STT_COMMON
Definition: ELF.h:1259
@ STT_GNU_IFUNC
Definition: ELF.h:1261
@ STT_OBJECT
Definition: ELF.h:1255
@ STT_TLS
Definition: ELF.h:1260
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
Error createError(const Twine &Err)
Definition: Error.h:84
constexpr int NumElfSymbolTypes
Definition: ELFObjectFile.h:46
static std::string describe(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)
Definition: ELF.h:143
std::pair< unsigned char, unsigned char > getElfArchType(StringRef Object)
Definition: ELF.h:78
const llvm::EnumEntry< unsigned > ElfSymbolTypes[NumElfSymbolTypes]
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:2037
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
Definition: bit.h:179
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:749
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1041
static const Target * lookupTarget(StringRef Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.