LLVM 24.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 constexpr EnumStringDef<uint8_t, 2> ElfSymbolTypeDefs[] = {
42 {{"None", "NOTYPE"}, ELF::STT_NOTYPE},
43 {{"Object", "OBJECT"}, ELF::STT_OBJECT},
44 {{"Function", "FUNC"}, ELF::STT_FUNC},
45 {{"Section", "SECTION"}, ELF::STT_SECTION},
46 {{"File", "FILE"}, ELF::STT_FILE},
47 {{"Common", "COMMON"}, ELF::STT_COMMON},
48 {{"TLS", "TLS"}, ELF::STT_TLS},
49 {{"Unknown", "<unknown>: 7"}, 7},
50 {{"Unknown", "<unknown>: 8"}, 8},
51 {{"Unknown", "<unknown>: 9"}, 9},
52 {{"GNU_IFunc", "IFUNC"}, ELF::STT_GNU_IFUNC},
53 {{"OS Specific", "<OS specific>: 11"}, 11},
54 {{"OS Specific", "<OS specific>: 12"}, 12},
55 {{"Proc Specific", "<processor specific>: 13"}, 13},
56 {{"Proc Specific", "<processor specific>: 14"}, 14},
57 {{"Proc Specific", "<processor specific>: 15"}, 15},
58 };
59 static constexpr auto ElfSymbolTypes = BUILD_ENUM_STRINGS(ElfSymbolTypeDefs);
60 return ElfSymbolTypes;
61}
62
65
66template <class ELFT>
68createPtr(MemoryBufferRef Object, bool InitContent) {
69 auto Ret = ELFObjectFile<ELFT>::create(Object, InitContent);
70 if (Error E = Ret.takeError())
71 return std::move(E);
72 return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
73}
74
75Expected<std::unique_ptr<ObjectFile>>
77 std::pair<unsigned char, unsigned char> Ident =
78 getElfArchType(Obj.getBuffer());
79 std::size_t MaxAlignment =
80 1ULL << llvm::countr_zero(
81 reinterpret_cast<uintptr_t>(Obj.getBufferStart()));
82
83 if (MaxAlignment < 2)
84 return createError("Insufficient alignment");
85
86 if (Ident.first == ELF::ELFCLASS32) {
87 if (Ident.second == ELF::ELFDATA2LSB)
88 return createPtr<ELF32LE>(Obj, InitContent);
89 else if (Ident.second == ELF::ELFDATA2MSB)
90 return createPtr<ELF32BE>(Obj, InitContent);
91 else
92 return createError("Invalid ELF data");
93 } else if (Ident.first == ELF::ELFCLASS64) {
94 if (Ident.second == ELF::ELFDATA2LSB)
95 return createPtr<ELF64LE>(Obj, InitContent);
96 else if (Ident.second == ELF::ELFDATA2MSB)
97 return createPtr<ELF64BE>(Obj, InitContent);
98 else
99 return createError("Invalid ELF data");
100 }
101 return createError("Invalid ELF class");
102}
103
104SubtargetFeatures ELFObjectFileBase::getMIPSFeatures() const {
105 SubtargetFeatures Features;
106 unsigned PlatformFlags = getPlatformFlags();
107
108 switch (PlatformFlags & ELF::EF_MIPS_ARCH) {
110 break;
112 Features.AddFeature("mips2");
113 break;
115 Features.AddFeature("mips3");
116 break;
118 Features.AddFeature("mips4");
119 break;
121 Features.AddFeature("mips5");
122 break;
124 Features.AddFeature("mips32");
125 break;
127 Features.AddFeature("mips64");
128 break;
130 Features.AddFeature("mips32r2");
131 break;
133 Features.AddFeature("mips64r2");
134 break;
136 Features.AddFeature("mips32r6");
137 break;
139 Features.AddFeature("mips64r6");
140 break;
141 default:
142 llvm_unreachable("Unknown EF_MIPS_ARCH value");
143 }
144
145 switch (PlatformFlags & ELF::EF_MIPS_MACH) {
147 // No feature associated with this value.
148 break;
150 Features.AddFeature("cnmips");
151 break;
152 default:
153 llvm_unreachable("Unknown EF_MIPS_ARCH value");
154 }
155
156 if (PlatformFlags & ELF::EF_MIPS_ARCH_ASE_M16)
157 Features.AddFeature("mips16");
158 if (PlatformFlags & ELF::EF_MIPS_MICROMIPS)
159 Features.AddFeature("micromips");
160
161 return Features;
162}
163
164SubtargetFeatures ELFObjectFileBase::getARMFeatures() const {
165 SubtargetFeatures Features;
166 ARMAttributeParser Attributes;
168 consumeError(std::move(E));
169 return SubtargetFeatures();
170 }
171
172 // both ARMv7-M and R have to support thumb hardware div
173 bool isV7 = false;
174 std::optional<unsigned> Attr =
175 Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
176 if (Attr)
177 isV7 = *Attr == ARMBuildAttrs::v7;
178
179 Attr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);
180 if (Attr) {
181 switch (*Attr) {
183 Features.AddFeature("aclass");
184 break;
186 Features.AddFeature("rclass");
187 if (isV7)
188 Features.AddFeature("hwdiv");
189 break;
191 Features.AddFeature("mclass");
192 if (isV7)
193 Features.AddFeature("hwdiv");
194 break;
195 }
196 }
197
198 Attr = Attributes.getAttributeValue(ARMBuildAttrs::THUMB_ISA_use);
199 if (Attr) {
200 switch (*Attr) {
201 default:
202 break;
204 Features.AddFeature("thumb", false);
205 Features.AddFeature("thumb2", false);
206 break;
208 Features.AddFeature("thumb2");
209 break;
210 }
211 }
212
213 Attr = Attributes.getAttributeValue(ARMBuildAttrs::FP_arch);
214 if (Attr) {
215 switch (*Attr) {
216 default:
217 break;
219 Features.AddFeature("vfp2sp", false);
220 Features.AddFeature("vfp3d16sp", false);
221 Features.AddFeature("vfp4d16sp", false);
222 break;
224 Features.AddFeature("vfp2");
225 break;
228 Features.AddFeature("vfp3");
229 break;
232 Features.AddFeature("vfp4");
233 break;
234 }
235 }
236
237 Attr = Attributes.getAttributeValue(ARMBuildAttrs::Advanced_SIMD_arch);
238 if (Attr) {
239 switch (*Attr) {
240 default:
241 break;
243 Features.AddFeature("neon", false);
244 Features.AddFeature("fp16", false);
245 break;
247 Features.AddFeature("neon");
248 break;
250 Features.AddFeature("neon");
251 Features.AddFeature("fp16");
252 break;
253 }
254 }
255
256 Attr = Attributes.getAttributeValue(ARMBuildAttrs::MVE_arch);
257 if (Attr) {
258 switch (*Attr) {
259 default:
260 break;
262 Features.AddFeature("mve", false);
263 Features.AddFeature("mve.fp", false);
264 break;
266 Features.AddFeature("mve.fp", false);
267 Features.AddFeature("mve");
268 break;
270 Features.AddFeature("mve.fp");
271 break;
272 }
273 }
274
275 Attr = Attributes.getAttributeValue(ARMBuildAttrs::DIV_use);
276 if (Attr) {
277 switch (*Attr) {
278 default:
279 break;
281 Features.AddFeature("hwdiv", false);
282 Features.AddFeature("hwdiv-arm", false);
283 break;
285 Features.AddFeature("hwdiv");
286 Features.AddFeature("hwdiv-arm");
287 break;
288 }
289 }
290
291 return Features;
292}
293
294static std::string hexagonAttrToFeatureString(unsigned Attr) {
295 return "v" + utostr(Attr);
296}
297
298SubtargetFeatures ELFObjectFileBase::getHexagonFeatures() const {
299 SubtargetFeatures Features;
300 HexagonAttributeParser Parser;
301 if (Error E = getBuildAttributes(Parser)) {
302 // Return no attributes if none can be read.
303 // This behavior is important for backwards compatibility.
304 consumeError(std::move(E));
305 return Features;
306 }
307 std::optional<unsigned> Attr;
308
309 if ((Attr = Parser.getAttributeValue(HexagonAttrs::ARCH)))
310 Features.AddFeature(hexagonAttrToFeatureString(*Attr));
311
312 if ((Attr = Parser.getAttributeValue(HexagonAttrs::HVXARCH)))
313 Features.AddFeature("hvx" + hexagonAttrToFeatureString(*Attr));
314
315 if ((Attr = Parser.getAttributeValue(HexagonAttrs::HVXIEEEFP)))
316 if (*Attr)
317 Features.AddFeature("hvx-ieee-fp");
318
319 if ((Attr = Parser.getAttributeValue(HexagonAttrs::HVXQFLOAT)))
320 if (*Attr)
321 Features.AddFeature("hvx-qfloat");
322
323 if ((Attr = Parser.getAttributeValue(HexagonAttrs::ZREG)))
324 if (*Attr)
325 Features.AddFeature("zreg");
326
327 if ((Attr = Parser.getAttributeValue(HexagonAttrs::AUDIO)))
328 if (*Attr)
329 Features.AddFeature("audio");
330
331 if ((Attr = Parser.getAttributeValue(HexagonAttrs::CABAC)))
332 if (*Attr)
333 Features.AddFeature("cabac");
334
335 return Features;
336}
337
338Expected<SubtargetFeatures> ELFObjectFileBase::getRISCVFeatures() const {
339 SubtargetFeatures Features;
340 unsigned PlatformFlags = getPlatformFlags();
341
342 if (PlatformFlags & ELF::EF_RISCV_RVC) {
343 Features.AddFeature("zca");
344 }
345
346 RISCVAttributeParser Attributes;
348 return std::move(E);
349 }
350
351 std::optional<StringRef> Attr =
352 Attributes.getAttributeString(RISCVAttrs::ARCH);
353 if (Attr) {
354 auto ParseResult = RISCVISAInfo::parseNormalizedArchString(*Attr);
355 if (!ParseResult)
356 return ParseResult.takeError();
357 auto &ISAInfo = *ParseResult;
358
359 if (ISAInfo->getXLen() == 32)
360 Features.AddFeature("64bit", false);
361 else if (ISAInfo->getXLen() == 64)
362 Features.AddFeature("64bit");
363 else
364 llvm_unreachable("XLEN should be 32 or 64.");
365
366 Features.addFeaturesVector(ISAInfo->toFeatures());
367 }
368
369 return Features;
370}
371
372SubtargetFeatures ELFObjectFileBase::getLoongArchFeatures() const {
373 SubtargetFeatures Features;
374
377 break;
379 Features.AddFeature("d");
380 // D implies F according to LoongArch ISA spec.
381 [[fallthrough]];
383 Features.AddFeature("f");
384 break;
385 }
386
387 return Features;
388}
389
390SubtargetFeatures ELFObjectFileBase::getSparcFeatures() const {
391 SubtargetFeatures Features;
392 unsigned PlatformFlags = getPlatformFlags();
393
394 if (getEMachine() == ELF::EM_SPARC32PLUS ||
395 (PlatformFlags & ELF::EF_SPARC_32PLUS))
396 Features.AddFeature("v9");
397 if (PlatformFlags & ELF::EF_SPARC_SUN_US1)
398 Features.AddFeature("vis");
399 if (PlatformFlags & ELF::EF_SPARC_SUN_US3)
400 Features.AddFeature("vis2");
401
402 return Features;
403}
404
406 switch (getEMachine()) {
407 case ELF::EM_MIPS:
408 return getMIPSFeatures();
409 case ELF::EM_ARM:
410 return getARMFeatures();
411 case ELF::EM_RISCV:
412 return getRISCVFeatures();
413 case ELF::EM_LOONGARCH:
414 return getLoongArchFeatures();
415 case ELF::EM_HEXAGON:
416 return getHexagonFeatures();
417 case ELF::EM_SPARC:
418 case ELF::EM_SPARC32PLUS:
419 case ELF::EM_SPARCV9:
420 return getSparcFeatures();
421 default:
422 return SubtargetFeatures();
423 }
424}
425
426std::optional<StringRef> ELFObjectFileBase::tryGetCPUName() const {
427 switch (getEMachine()) {
428 case ELF::EM_AMDGPU:
429 return getAMDGPUCPUName();
430 case ELF::EM_CUDA:
431 return getNVPTXCPUName();
432 case ELF::EM_PPC:
433 case ELF::EM_PPC64:
434 return StringRef("future");
435 case ELF::EM_BPF:
436 return StringRef("v4");
437 default:
438 return std::nullopt;
439 }
440}
441
442StringRef ELFObjectFileBase::getAMDGPUCPUName() const {
443 assert(getEMachine() == ELF::EM_AMDGPU);
444 unsigned CPU = getPlatformFlags() & ELF::EF_AMDGPU_MACH;
445
446 switch (CPU) {
447#define X(NUM, ENUM, NAME) \
448 case ELF::ENUM: \
449 return NAME;
451#undef X
452
453 default:
454 llvm_unreachable("Unknown EF_AMDGPU_MACH value");
455 }
456}
457
458StringRef ELFObjectFileBase::getNVPTXCPUName() const {
459 assert(getEMachine() == ELF::EM_CUDA);
464
465 switch (SM) {
466 // Fermi architecture.
468 return "sm_20";
470 return "sm_21";
471
472 // Kepler architecture.
474 return "sm_30";
476 return "sm_32";
478 return "sm_35";
480 return "sm_37";
481
482 // Maxwell architecture.
484 return "sm_50";
486 return "sm_52";
488 return "sm_53";
489
490 // Pascal architecture.
492 return "sm_60";
494 return "sm_61";
496 return "sm_62";
497
498 // Volta architecture.
500 return "sm_70";
502 return "sm_72";
503
504 // Turing architecture.
506 return "sm_75";
507
508 // Ampere architecture.
510 return "sm_80";
512 return "sm_86";
514 return "sm_87";
516 return "sm_88";
517
518 // Ada architecture.
520 return "sm_89";
521
522 // Hopper architecture.
525 : "sm_90";
526
527 // Blackwell architecture.
529 return getPlatformFlags() & ELF::EF_CUDA_ACCELERATORS ? "sm_100a"
530 : "sm_100";
532 return getPlatformFlags() & ELF::EF_CUDA_ACCELERATORS ? "sm_101a"
533 : "sm_101";
535 return getPlatformFlags() & ELF::EF_CUDA_ACCELERATORS ? "sm_103a"
536 : "sm_103";
538 return getPlatformFlags() & ELF::EF_CUDA_ACCELERATORS ? "sm_107a"
539 : "sm_107";
541 return getPlatformFlags() & ELF::EF_CUDA_ACCELERATORS ? "sm_110a"
542 : "sm_110";
543
544 // Rubin architecture.
546 return getPlatformFlags() & ELF::EF_CUDA_ACCELERATORS ? "sm_120a"
547 : "sm_120";
549 return getPlatformFlags() & ELF::EF_CUDA_ACCELERATORS ? "sm_121a"
550 : "sm_121";
551 default:
552 llvm_unreachable("Unknown EF_CUDA_SM value");
553 }
554}
555
556// FIXME Encode from a tablegen description or target parser.
558 if (TheTriple.getSubArch() != Triple::NoSubArch)
559 return;
560
561 ARMAttributeParser Attributes;
562 if (Error E = getBuildAttributes(Attributes)) {
563 // TODO Propagate Error.
564 consumeError(std::move(E));
565 return;
566 }
567
568 std::string Triple;
569 // Default to ARM, but use the triple if it's been set.
570 if (TheTriple.isThumb())
571 Triple = "thumb";
572 else
573 Triple = "arm";
574
575 std::optional<unsigned> Attr =
576 Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
577 if (Attr) {
578 switch (*Attr) {
580 Triple += "v4";
581 break;
583 Triple += "v4t";
584 break;
586 Triple += "v5t";
587 break;
589 Triple += "v5te";
590 break;
592 Triple += "v5tej";
593 break;
595 Triple += "v6";
596 break;
598 Triple += "v6kz";
599 break;
601 Triple += "v6t2";
602 break;
604 Triple += "v6k";
605 break;
606 case ARMBuildAttrs::v7: {
607 std::optional<unsigned> ArchProfileAttr =
608 Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);
609 if (ArchProfileAttr == ARMBuildAttrs::MicroControllerProfile)
610 Triple += "v7m";
611 else
612 Triple += "v7";
613 break;
614 }
616 Triple += "v6m";
617 break;
619 Triple += "v6sm";
620 break;
622 Triple += "v7em";
623 break;
625 Triple += "v8a";
626 break;
628 Triple += "v8r";
629 break;
631 Triple += "v8m.base";
632 break;
634 Triple += "v8m.main";
635 break;
637 Triple += "v8.1m.main";
638 break;
640 Triple += "v9a";
641 break;
642 }
643 }
644 if (!isLittleEndian())
645 Triple += "eb";
646
647 TheTriple.setArchName(Triple);
648}
649
650std::vector<ELFPltEntry>
652 std::string Err;
653 const auto Triple = makeTriple();
654 const auto *T = TargetRegistry::lookupTarget(Triple, Err);
655 if (!T)
656 return {};
657 uint32_t JumpSlotReloc = 0, GlobDatReloc = 0;
658 switch (Triple.getArch()) {
659 case Triple::x86:
660 JumpSlotReloc = ELF::R_386_JUMP_SLOT;
661 GlobDatReloc = ELF::R_386_GLOB_DAT;
662 break;
663 case Triple::x86_64:
664 JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;
665 GlobDatReloc = ELF::R_X86_64_GLOB_DAT;
666 break;
667 case Triple::aarch64:
669 JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;
670 break;
671 case Triple::arm:
672 case Triple::armeb:
673 case Triple::thumb:
674 case Triple::thumbeb:
675 JumpSlotReloc = ELF::R_ARM_JUMP_SLOT;
676 break;
677 case Triple::hexagon:
678 JumpSlotReloc = ELF::R_HEX_JMP_SLOT;
679 GlobDatReloc = ELF::R_HEX_GLOB_DAT;
680 break;
681 case Triple::riscv32:
682 case Triple::riscv64:
683 JumpSlotReloc = ELF::R_RISCV_JUMP_SLOT;
684 break;
687 JumpSlotReloc = ELF::R_LARCH_JUMP_SLOT;
688 break;
689 default:
690 return {};
691 }
692 std::unique_ptr<const MCInstrInfo> MII(T->createMCInstrInfo());
693 std::unique_ptr<const MCInstrAnalysis> MIA(
694 T->createMCInstrAnalysis(MII.get()));
695 if (!MIA)
696 return {};
697 std::vector<std::pair<uint64_t, uint64_t>> PltEntries;
698 std::optional<SectionRef> RelaPlt, RelaDyn;
699 uint64_t GotBaseVA = 0;
700 for (const SectionRef &Section : sections()) {
701 Expected<StringRef> NameOrErr = Section.getName();
702 if (!NameOrErr) {
703 consumeError(NameOrErr.takeError());
704 continue;
705 }
706 StringRef Name = *NameOrErr;
707
708 if (Name == ".rela.plt" || Name == ".rel.plt") {
709 RelaPlt = Section;
710 } else if (Name == ".rela.dyn" || Name == ".rel.dyn") {
711 RelaDyn = Section;
712 } else if (Name == ".got.plt") {
713 GotBaseVA = Section.getAddress();
714 } else if (Name == ".plt" || Name == ".plt.got") {
715 Expected<StringRef> PltContents = Section.getContents();
716 if (!PltContents) {
717 consumeError(PltContents.takeError());
718 return {};
719 }
721 PltEntries,
722 MIA->findPltEntries(Section.getAddress(),
723 arrayRefFromStringRef(*PltContents), STI));
724 }
725 }
726
727 // Build a map from GOT entry virtual address to PLT entry virtual address.
729 for (auto [Plt, GotPlt] : PltEntries) {
730 uint64_t GotPltEntry = GotPlt;
731 // An x86-32 PIC PLT uses jmp DWORD PTR [ebx-offset]. Add
732 // _GLOBAL_OFFSET_TABLE_ (EBX) to get the .got.plt (or .got) entry address.
733 // See X86MCTargetDesc.cpp:findPltEntries for the 1 << 32 bit.
734 if (GotPltEntry & (uint64_t(1) << 32) && getEMachine() == ELF::EM_386)
735 GotPltEntry = static_cast<int32_t>(GotPltEntry) + GotBaseVA;
736 GotToPlt.insert(std::make_pair(GotPltEntry, Plt));
737 }
738
739 // Find the relocations in the dynamic relocation table that point to
740 // locations in the GOT for which we know the corresponding PLT entry.
741 std::vector<ELFPltEntry> Result;
742 auto handleRels = [&](iterator_range<relocation_iterator> Rels,
743 uint32_t RelType, StringRef PltSec) {
744 for (const auto &R : Rels) {
745 if (R.getType() != RelType)
746 continue;
747 auto PltEntryIter = GotToPlt.find(R.getOffset());
748 if (PltEntryIter != GotToPlt.end()) {
749 symbol_iterator Sym = R.getSymbol();
750 if (Sym == symbol_end())
751 Result.push_back(
752 ELFPltEntry{PltSec, std::nullopt, PltEntryIter->second});
753 else
754 Result.push_back(ELFPltEntry{PltSec, Sym->getRawDataRefImpl(),
755 PltEntryIter->second});
756 }
757 }
758 };
759
760 if (RelaPlt)
761 handleRels(RelaPlt->relocations(), JumpSlotReloc, ".plt");
762
763 // If a symbol needing a PLT entry also needs a GLOB_DAT relocation, GNU ld's
764 // x86 port places the PLT entry in the .plt.got section.
765 if (RelaDyn)
766 handleRels(RelaDyn->relocations(), GlobDatReloc, ".plt.got");
767
768 return Result;
769}
770
771template <class ELFT>
773 const ELFFile<ELFT> &EF, std::optional<unsigned> TextSectionIndex,
774 std::vector<PGOAnalysisMap> *PGOAnalyses) {
775 using Elf_Shdr = typename ELFT::Shdr;
776 bool IsRelocatable = EF.getHeader().e_type == ELF::ET_REL;
777 std::vector<BBAddrMap> BBAddrMaps;
778 if (PGOAnalyses)
779 PGOAnalyses->clear();
780
781 const auto &Sections = cantFail(EF.sections());
782 auto IsMatch = [&](const Elf_Shdr &Sec) -> Expected<bool> {
783 if (Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP)
784 return false;
785 if (!TextSectionIndex)
786 return true;
787 Expected<const Elf_Shdr *> TextSecOrErr = EF.getSection(Sec.sh_link);
788 if (!TextSecOrErr)
789 return createError("unable to get the linked-to section for " +
790 describe(EF, Sec) + ": " +
791 toString(TextSecOrErr.takeError()));
792 assert(*TextSecOrErr >= Sections.begin() &&
793 "Text section pointer outside of bounds");
794 if (*TextSectionIndex !=
795 (unsigned)std::distance(Sections.begin(), *TextSecOrErr))
796 return false;
797 return true;
798 };
799
801 EF.getSectionAndRelocations(IsMatch);
802 if (!SectionRelocMapOrErr)
803 return SectionRelocMapOrErr.takeError();
804
805 for (auto const &[Sec, RelocSec] : *SectionRelocMapOrErr) {
806 if (IsRelocatable && !RelocSec)
807 return createError("unable to get relocation section for " +
808 describe(EF, *Sec));
809 Expected<std::vector<BBAddrMap>> BBAddrMapOrErr =
810 EF.decodeBBAddrMap(*Sec, RelocSec, PGOAnalyses);
811 if (!BBAddrMapOrErr) {
812 if (PGOAnalyses)
813 PGOAnalyses->clear();
814 return createError("unable to read BB addr map section: " +
815 toString(BBAddrMapOrErr.takeError()));
816 }
817 std::move(BBAddrMapOrErr->begin(), BBAddrMapOrErr->end(),
818 std::back_inserter(BBAddrMaps));
819 }
820 if (PGOAnalyses)
821 assert(PGOAnalyses->size() == BBAddrMaps.size() &&
822 "The same number of BBAddrMaps and PGOAnalysisMaps should be "
823 "returned when PGO information is requested");
824 return BBAddrMaps;
825}
826
827template <class ELFT>
828static Expected<std::vector<VersionEntry>>
831 using Elf_Shdr = typename ELFT::Shdr;
832 const Elf_Shdr *VerSec = nullptr;
833 const Elf_Shdr *VerNeedSec = nullptr;
834 const Elf_Shdr *VerDefSec = nullptr;
835 // The user should ensure sections() can't fail here.
836 for (const Elf_Shdr &Sec : cantFail(EF.sections())) {
837 if (Sec.sh_type == ELF::SHT_GNU_versym)
838 VerSec = &Sec;
839 else if (Sec.sh_type == ELF::SHT_GNU_verdef)
840 VerDefSec = &Sec;
841 else if (Sec.sh_type == ELF::SHT_GNU_verneed)
842 VerNeedSec = &Sec;
843 }
844 if (!VerSec)
845 return std::vector<VersionEntry>();
846
848 EF.loadVersionMap(VerNeedSec, VerDefSec);
849 if (!MapOrErr)
850 return MapOrErr.takeError();
851
852 std::vector<VersionEntry> Ret;
853 size_t I = 0;
854 for (const ELFSymbolRef &Sym : Symbols) {
855 ++I;
857 EF.template getEntry<typename ELFT::Versym>(*VerSec, I);
858 if (!VerEntryOrErr)
859 return createError("unable to read an entry with index " + Twine(I) +
860 " from " + describe(EF, *VerSec) + ": " +
861 toString(VerEntryOrErr.takeError()));
862
863 Expected<uint32_t> FlagsOrErr = Sym.getFlags();
864 if (!FlagsOrErr)
865 return createError("unable to read flags for symbol with index " +
866 Twine(I) + ": " + toString(FlagsOrErr.takeError()));
867
868 bool IsDefault;
870 (*VerEntryOrErr)->vs_index, IsDefault, *MapOrErr,
871 (*FlagsOrErr) & SymbolRef::SF_Undefined);
872 if (!VerOrErr)
873 return createError("unable to get a version for entry " + Twine(I) +
874 " of " + describe(EF, *VerSec) + ": " +
875 toString(VerOrErr.takeError()));
876
877 Ret.push_back({(*VerOrErr).str(), IsDefault});
878 }
879
880 return Ret;
881}
882
883Expected<std::vector<VersionEntry>>
886 if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
887 return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
888 if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
889 return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
890 if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
891 return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
892 return readDynsymVersionsImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
893 Symbols);
894}
895
897 std::optional<unsigned> TextSectionIndex,
898 std::vector<PGOAnalysisMap> *PGOAnalyses) const {
899 if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
900 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);
901 if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
902 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);
903 if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
904 return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex, PGOAnalyses);
905 return readBBAddrMapImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
906 TextSectionIndex, PGOAnalyses);
907}
908
910 auto Data = Sec.getRawDataRefImpl();
911 if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
912 return Obj->getCrelDecodeProblem(Data);
913 if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
914 return Obj->getCrelDecodeProblem(Data);
915 if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
916 return Obj->getCrelDecodeProblem(Data);
917 return cast<ELF64BEObjectFile>(this)->getCrelDecodeProblem(Data);
918}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
uint64_t uint64_t
AMDGPU Kernel Attributes
#define X(NUM, ENUM, NAME)
Definition ELF.h:665
#define AMDGPU_MACH_LIST(X)
Definition ELF.h:576
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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::string hexagonAttrToFeatureString(unsigned Attr)
static Expected< std::vector< VersionEntry > > readDynsymVersionsImpl(const ELFFile< ELFT > &EF, ELFObjectFileBase::elf_symbol_iterator_range Symbols)
#define BUILD_ENUM_STRINGS(Tab)
Definition Enum.h:120
#define I(x, y, z)
Definition MD5.cpp:57
#define T
iterator find(const_arg_type_t< KeyT > Val)
Definition DenseMap.h:766
iterator end()
Definition DenseMap.h:686
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition DenseMap.h:827
std::optional< uint64_t > getAttributeValue(unsigned tag) const override
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
Tagged union holding either a T or a Error.
Definition Error.h:485
Error takeError()
Take ownership of the stored error.
Definition Error.h:612
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...
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
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.
Definition Triple.h:48
LLVM_ABI void setArchName(StringRef Str)
Set the architecture (first) component of the triple by name.
Definition Triple.cpp:1721
bool isThumb() const
Tests whether the target is Thumb (little and big endian).
Definition Triple.h:1003
SubArchType getSubArch() const
get the parsed subarchitecture type for this triple.
Definition Triple.h:520
@ loongarch32
Definition Triple.h:65
@ loongarch64
Definition Triple.h:66
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition Triple.h:517
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:46
A range adaptor for a pair of iterators.
DataRefImpl getRawDataRefImpl() const
MemoryBufferRef Data
Definition Binary.h:38
bool isLittleEndian() const
Definition Binary.h:157
const Elf_Ehdr & getHeader() const
Definition ELF.h:346
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...
Definition ELF.cpp:872
Expected< StringRef > getSymbolVersionByIndex(uint32_t SymbolVersionIndex, bool &IsDefault, SmallVector< std::optional< VersionEntry >, 0 > &VersionMap, std::optional< bool > IsSymHidden) const
Definition ELF.h:1119
Expected< Elf_Shdr_Range > sections() const
Definition ELF.h:1037
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:885
Expected< SmallVector< std::optional< VersionEntry >, 0 > > loadVersionMap(const Elf_Shdr *VerNeedSec, const Elf_Shdr *VerDefSec) const
Definition ELF.h:792
Expected< const Elf_Shdr * > getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab, DataRegion< Elf_Word > ShndxTable) const
Definition ELF.h:650
virtual uint8_t getEIdentABIVersion() const =0
virtual Error getBuildAttributes(ELFAttributeParser &Attributes) const =0
std::vector< ELFPltEntry > getPltEntries(const MCSubtargetInfo &STI) const
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
Expected< SubtargetFeatures > getFeatures() const override
std::optional< StringRef > tryGetCPUName() const override
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)
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)
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
Definition ObjectFile.h:331
ObjectFile(unsigned int Type, MemoryBufferRef Source)
DataRefImpl getRawDataRefImpl() const
Definition ObjectFile.h:603
virtual basic_symbol_iterator symbol_end() const =0
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ STT_FUNC
Definition ELF.h:1274
@ STT_NOTYPE
Definition ELF.h:1272
@ STT_SECTION
Definition ELF.h:1275
@ STT_FILE
Definition ELF.h:1276
@ STT_COMMON
Definition ELF.h:1277
@ STT_GNU_IFUNC
Definition ELF.h:1279
@ STT_OBJECT
Definition ELF.h:1273
@ STT_TLS
Definition ELF.h:1278
@ EF_MIPS_ARCH
Definition ELF.h:388
@ EF_MIPS_MICROMIPS
Definition ELF.h:371
@ EF_MIPS_ARCH_32R6
Definition ELF.h:386
@ EF_MIPS_MACH_NONE
Definition ELF.h:349
@ EF_MIPS_ARCH_64
Definition ELF.h:383
@ EF_MIPS_ARCH_32
Definition ELF.h:382
@ EF_MIPS_MACH_OCTEON
Definition ELF.h:357
@ EF_MIPS_ARCH_4
Definition ELF.h:380
@ EF_MIPS_ARCH_5
Definition ELF.h:381
@ EF_MIPS_ARCH_2
Definition ELF.h:378
@ EF_MIPS_ARCH_32R2
Definition ELF.h:384
@ EF_MIPS_ARCH_64R2
Definition ELF.h:385
@ EF_MIPS_ARCH_ASE_M16
Definition ELF.h:372
@ EF_MIPS_MACH
Definition ELF.h:368
@ EF_MIPS_ARCH_1
Definition ELF.h:377
@ EF_MIPS_ARCH_64R6
Definition ELF.h:387
@ EF_MIPS_ARCH_3
Definition ELF.h:379
@ ELFDATA2MSB
Definition ELF.h:149
@ ELFDATA2LSB
Definition ELF.h:148
@ EF_LOONGARCH_ABI_SINGLE_FLOAT
Definition ELF.h:886
@ EF_LOONGARCH_ABI_DOUBLE_FLOAT
Definition ELF.h:887
@ EF_LOONGARCH_ABI_SOFT_FLOAT
Definition ELF.h:885
@ EF_LOONGARCH_ABI_MODIFIER_MASK
Definition ELF.h:888
@ EF_SPARC_32PLUS
Definition ELF.h:558
@ EF_SPARC_SUN_US1
Definition ELF.h:559
@ EF_SPARC_SUN_US3
Definition ELF.h:561
@ EF_CUDA_SM21
Definition ELF.h:762
@ EF_CUDA_SM90
Definition ELF.h:781
@ EF_CUDA_SM86
Definition ELF.h:777
@ EF_CUDA_SM60
Definition ELF.h:770
@ EF_CUDA_SM
Definition ELF.h:752
@ EF_CUDA_SM89
Definition ELF.h:780
@ EF_CUDA_SM37
Definition ELF.h:766
@ EF_CUDA_SM32
Definition ELF.h:764
@ EF_CUDA_SM72
Definition ELF.h:774
@ EF_CUDA_SM50
Definition ELF.h:767
@ EF_CUDA_ACCELERATORS
Definition ELF.h:805
@ EF_CUDA_SM121
Definition ELF.h:788
@ EF_CUDA_SM61
Definition ELF.h:771
@ EF_CUDA_SM_MASK
Definition ELF.h:755
@ EF_CUDA_SM52
Definition ELF.h:768
@ EF_CUDA_SM35
Definition ELF.h:765
@ EF_CUDA_SM120
Definition ELF.h:787
@ EF_CUDA_SM100
Definition ELF.h:782
@ EF_CUDA_SM62
Definition ELF.h:772
@ EF_CUDA_SM101
Definition ELF.h:783
@ EF_CUDA_SM30
Definition ELF.h:763
@ EF_CUDA_SM_OFFSET
Definition ELF.h:758
@ EF_CUDA_ACCELERATORS_V1
Definition ELF.h:797
@ EF_CUDA_SM75
Definition ELF.h:775
@ EF_CUDA_SM103
Definition ELF.h:784
@ EF_CUDA_SM87
Definition ELF.h:778
@ EF_CUDA_SM20
Definition ELF.h:761
@ EF_CUDA_SM88
Definition ELF.h:779
@ EF_CUDA_SM80
Definition ELF.h:776
@ EF_CUDA_SM107
Definition ELF.h:785
@ EF_CUDA_SM53
Definition ELF.h:769
@ EF_CUDA_SM70
Definition ELF.h:773
@ EF_CUDA_SM110
Definition ELF.h:786
@ ELFCLASS64
Definition ELF.h:142
@ ELFCLASS32
Definition ELF.h:141
@ ET_REL
Definition ELF.h:119
@ EF_AMDGPU_MACH
Definition ELF.h:660
@ ELFABIVERSION_CUDA_V1
Definition ELF.h:199
@ EF_RISCV_RVC
Definition ELF.h:520
@ SHT_GNU_verneed
Definition ELF.h:1048
@ SHT_GNU_verdef
Definition ELF.h:1047
@ SHT_LLVM_BB_ADDR_MAP
Definition ELF.h:1034
@ SHT_GNU_versym
Definition ELF.h:1049
LLVM_ABI EnumStrings< uint8_t, 2 > getElfSymbolTypes()
Error createError(const Twine &Err)
Definition Error.h:86
std::pair< unsigned char, unsigned char > getElfArchType(StringRef Object)
Definition ELF.h:82
std::string describe(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)
Definition ELF.h:147
This is an optimization pass for GlobalISel generic memory operations.
ArrayRef< CharT > arrayRefFromStringRef(StringRef Input)
Construct an array ref of bytes from a string ref.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition STLExtras.h:2224
std::string utostr(uint64_t X, bool isNeg=false)
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:204
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition Error.h:769
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<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
void consumeError(Error Err)
Consume a Error without doing anything.
Definition Error.h:1106
Compile-time data representation of enum entries.
Definition Enum.h:47
static LLVM_ABI const Target * lookupTarget(const Triple &TheTriple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.