ELF.cpp Source File (original) (raw)

627

629 if (!ProgramHeadersOrError)

630 return ProgramHeadersOrError.takeError();

631

632 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {

634 const uint8_t *DynOffset = base() + Phdr.p_offset;

635 if (DynOffset > end())

637 "dynamic section offset past file size: corrupted ELF");

638 Dyn = ArrayRef(reinterpret_cast<const Elf_Dyn *>(DynOffset),

639 Phdr.p_filesz / sizeof(Elf_Dyn));

640 break;

641 }

642 }

643

644

645

646 if (Dyn.empty()) {

647 auto SectionsOrError = sections();

648 if (!SectionsOrError)

649 return SectionsOrError.takeError();

650

651 for (const Elf_Shdr &Sec : *SectionsOrError) {

655 if (!DynOrError)

657 Dyn = *DynOrError;

658 break;

659 }

660 }

661

662 if (!Dyn.data())

664 }

665

667 return createError("invalid empty dynamic section");

668

669 if (Dyn.back().d_tag != ELF::DT_NULL)

670 return createError("dynamic sections must be DT_NULL terminated");

671

672 return Dyn;

673}

679 if (!ProgramHeadersOrError)

680 return ProgramHeadersOrError.takeError();

681

683

684 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)

686 LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));

687

690 return A->p_vaddr < B->p_vaddr;

691 };

694 WarnHandler("loadable segments are unsorted by virtual address"))

695 return std::move(E);

697 }

698

701 return VAddr < Phdr->p_vaddr;

702 });

703

704 if (I == LoadSegments.begin())

705 return createError("virtual address is not in any segment: 0x" +

707 --I;

708 const Elf_Phdr &Phdr = **I;

709 uint64_t Delta = VAddr - Phdr.p_vaddr;

710 if (Delta >= Phdr.p_filesz)

711 return createError("virtual address is not in any segment: 0x" +

713

716 return createError("can't map virtual address 0x" +

718 Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +

719 ": the segment ends at 0x" +

721 ", which is greater than the file size (0x" +

723

725}

732template <typename IntTy, std::enable_if_t<std::is_unsigned_v, int> = 0>

734 Error &ULEBSizeErr) {

735

736 if (ULEBSizeErr)

737 return 0;

740 if (Value > std::numeric_limits::max()) {

741 ULEBSizeErr = createError("ULEB128 value at offset 0x" +

743 Twine(std::numeric_limits::digits) +

745 return 0;

746 }

747 return static_cast<IntTy>(Value);

748}

755 std::vector *PGOAnalyses) {

757

758

759

760

762 if (IsRelocatable && RelaSec) {

764 "Can't read a SHT_LLVM_BB_ADDR_MAP section in a relocatable "

765 "object file without providing a relocation section.");

768 if (!Relas)

769 return createError("unable to read CREL relocations for section " +

773 FunctionOffsetTranslations[Rela.r_offset] = Rela.r_addend;

774 }

775 } else {

777 EF.relas(*RelaSec);

778 if (!Relas)

779 return createError("unable to read relocations for section " +

783 FunctionOffsetTranslations[Rela.r_offset] = Rela.r_addend;

784 }

785 }

786 auto GetAddressForRelocation =

788 auto FOTIterator =

789 FunctionOffsetTranslations.find(RelocationOffsetInSection);

790 if (FOTIterator == FunctionOffsetTranslations.end()) {

791 return createError("failed to get relocation data for offset: " +

793 " in section " + describe(EF, Sec));

794 }

795 return FOTIterator->second;

796 };

798 if (!ContentsOrErr)

799 return ContentsOrErr.takeError();

801

802

803 std::unique_ptr<uint8_t[]> DecompressedContent;

806 if (!SectionNameOrErr)

807 return SectionNameOrErr.takeError();

808 auto DecompressorOrErr =

810 EF.isLE(), ELFT::Is64Bits);

811 if (!DecompressorOrErr)

812 return DecompressorOrErr.takeError();

813 size_t DecompressedSize = DecompressorOrErr->getDecompressedSize();

814 DecompressedContent = std::make_unique<uint8_t[]>(DecompressedSize);

816 DecompressedSize);

817 if (Error Err = DecompressorOrErr->decompress(DecompressedContentRef))

818 return std::move(Err);

819 Content = DecompressedContentRef;

820 }

821

823 std::vector FunctionEntries;

824

828

829

831 uint64_t RelocationOffsetInSection = Cur.tell();

832 auto Address =

834 if (!Cur)

836 if (!IsRelocatable)

837 return Address;

838 assert(Address == 0);

840 GetAddressForRelocation(RelocationOffsetInSection);

841 if (!AddressOrErr)

843 return *AddressOrErr;

844 };

845

849 while (!ULEBSizeErr && !MetadataDecodeErr && Cur &&

850 Cur.tell() < Content.size()) {

851 Version = Data.getU8(Cur);

852 if (!Cur)

853 break;

855 return createError("unsupported SHT_LLVM_BB_ADDR_MAP version: " +

856 Twine(static_cast<int>(Version)));

857 Feature = Version < 5 ? Data.getU8(Cur) : Data.getU16(Cur);

858 if (!Cur)

859 break;

861 if (!FeatEnableOrErr)

862 return FeatEnableOrErr.takeError();

863 FeatEnable = *FeatEnableOrErr;

865 return createError("version should be >= 3 for SHT_LLVM_BB_ADDR_MAP when "

866 "callsite offsets feature is enabled: version = " +

867 Twine(static_cast<int>(Version)) +

868 " feature = " + Twine(static_cast<int>(Feature)));

869 if (FeatEnable.BBHash && Version < 4)

870 return createError("version should be >= 4 for SHT_LLVM_BB_ADDR_MAP when "

871 "basic block hash feature is enabled: version = " +

872 Twine(static_cast<int>(Version)) +

873 " feature = " + Twine(static_cast<int>(Feature)));

874 if (FeatEnable.PostLinkCfg && Version < 5)

875 return createError("version should be >= 5 for SHT_LLVM_BB_ADDR_MAP when "

876 "post link cfg feature is enabled: version = " +

877 Twine(static_cast<int>(Version)) +

878 " feature = " + Twine(static_cast<int>(Feature)));

879 uint32_t NumBlocksInBBRange = 0;

884 if (!Cur || ULEBSizeErr)

885 break;

886 if (!NumBBRanges)

887 return createError("invalid zero number of BB ranges at offset " +

890 } else {

891 auto AddressOrErr = ExtractAddress();

892 if (!AddressOrErr)

893 return AddressOrErr.takeError();

894 RangeBaseAddress = *AddressOrErr;

896 }

897 std::vectorBBAddrMap::BBRangeEntry BBRangeEntries;

899 for (uint32_t BBRangeIndex = 0; BBRangeIndex < NumBBRanges;

900 ++BBRangeIndex) {

901 uint32_t PrevBBEndOffset = 0;

903 auto AddressOrErr = ExtractAddress();

904 if (!AddressOrErr)

905 return AddressOrErr.takeError();

906 RangeBaseAddress = *AddressOrErr;

908 }

909 std::vectorBBAddrMap::BBEntry BBEntries;

911 for (uint32_t BlockIndex = 0; !MetadataDecodeErr && !ULEBSizeErr &&

912 Cur && (BlockIndex < NumBlocksInBBRange);

913 ++BlockIndex) {

916

917 uint32_t LastCallsiteEndOffset = 0;

922 CallsiteEndOffsets.reserve(NumCallsites);

924 !ULEBSizeErr && Cur && (CallsiteIndex < NumCallsites);

926 LastCallsiteEndOffset +=

928 CallsiteEndOffsets.push_back(LastCallsiteEndOffset);

929 }

930 }

932 LastCallsiteEndOffset;

937 if (!MetadataOrErr) {

938 MetadataDecodeErr = MetadataOrErr.takeError();

939 break;

940 }

941 BBEntries.push_back({ID, Offset + PrevBBEndOffset, Size,

942 *MetadataOrErr, CallsiteEndOffsets, Hash});

944 }

945 TotalNumBlocks += BBEntries.size();

946 }

947 BBRangeEntries.push_back({RangeBaseAddress, std::move(BBEntries)});

948 }

949 FunctionEntries.push_back({std::move(BBRangeEntries)});

950

952

956 : 0;

957

958 std::vectorPGOAnalysisMap::PGOBBEntry PGOBBEntries;

959 for (uint32_t BlockIndex = 0;

961 !ULEBSizeErr && Cur && (BlockIndex < TotalNumBlocks);

962 ++BlockIndex) {

963

966 : 0;

970 : 0;

971

972

974 Successors;

975 if (FeatEnable.BrProb) {

977 for (uint64_t I = 0; I < SuccCount; ++I) {

983 : 0;

984

985 if (PGOAnalyses)

988 }

989 }

990

991 if (PGOAnalyses)

992 PGOBBEntries.push_back(

993 {BlockFrequency(BBF), PostLinkBBFreq, std::move(Successors)});

994 }

995

996 if (PGOAnalyses)

997 PGOAnalyses->push_back(

998 {FuncEntryCount, std::move(PGOBBEntries), FeatEnable});

999 }

1000 }

1001

1002

1003 if (!Cur || ULEBSizeErr || MetadataDecodeErr)

1005 std::move(MetadataDecodeErr));

1006 return FunctionEntries;

1007}

1012 std::vector *PGOAnalyses) const {

1013 size_t OriginalPGOSize = PGOAnalyses ? PGOAnalyses->size() : 0;

1014 auto AddrMapsOrErr = decodeBBAddrMapImpl(*this, Sec, RelaSec, PGOAnalyses);

1015

1016 if (!AddrMapsOrErr && PGOAnalyses)

1017 PGOAnalyses->resize(OriginalPGOSize);

1018 return std::move(AddrMapsOrErr);

1019}

1025 std::function<Expected(const Elf_Shdr &)> IsMatch) const {

1030 if (!DoesSectionMatch) {

1032 continue;

1033 }

1034 if (*DoesSectionMatch) {

1035 if (SecToRelocMap.try_emplace(&Sec).second)

1036 continue;

1037 }

1038

1041 continue;

1042

1044 if (!RelSecOrErr) {

1045 Errors = joinErrors(std::move(Errors),

1047 ": failed to get a relocated section: " +

1049 continue;

1050 }

1051 const Elf_Shdr *ContentsSec = *RelSecOrErr;

1052 Expected DoesRelTargetMatch = IsMatch(*ContentsSec);

1053 if (!DoesRelTargetMatch) {

1055 continue;

1056 }

1057 if (*DoesRelTargetMatch)

1058 SecToRelocMap[ContentsSec] = &Sec;

1059 }

1060 if(Errors)

1061 return std::move(Errors);

1062 return SecToRelocMap;

1063}