| //===----------------------------------------------------------------------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| /// | |
| /// \file | |
| /// This file implements shared utilities for basic-block address maps. | |
| /// | |
| //===----------------------------------------------------------------------===// | |
| #include "llvm/Object/BBAddrMap.h" | |
| #include "llvm/Object/Error.h" | |
| using namespace llvm; | |
| using namespace object; | |
| namespace { | |
| // Helper to extract and decode the next ULEB128 value as an unsigned integer | |
| // type. Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the | |
| // destination type's limit. | |
| // Also returns zero if ULEBSizeErr is already in an error state. | |
| // ULEBSizeErr is an out variable if an error occurs. | |
| template <typename IntTy, std::enable_if_t<std::is_unsigned_v<IntTy>, int> = 0> | |
| static IntTy readULEB128As(const DataExtractor &Data, | |
| DataExtractor::Cursor &Cur, Error &ULEBSizeErr) { | |
| // Bail out and do not extract data if ULEBSizeErr is already set. | |
| if (ULEBSizeErr) | |
| return 0; | |
| uint64_t Offset = Cur.tell(); | |
| uint64_t Value = Data.getULEB128(Cur); | |
| if (Value > std::numeric_limits<IntTy>::max()) { | |
| ULEBSizeErr = createError("ULEB128 value at offset 0x" + | |
| Twine::utohexstr(Offset) + " exceeds UINT" + | |
| Twine(std::numeric_limits<IntTy>::digits) + | |
| "_MAX (0x" + Twine::utohexstr(Value) + ")"); | |
| return 0; | |
| } | |
| return static_cast<IntTy>(Value); | |
| } | |
| } // end anonymous namespace | |
| Expected<std::vector<BBAddrMap>> | |
| llvm::object::decodeBBAddrMapPayload(AddressExtractor &Extractor, | |
| std::vector<PGOAnalysisMap> *PGOAnalyses) { | |
| const DataExtractor &Data = Extractor.getDataExtractor(); | |
| std::vector<BBAddrMap> FunctionEntries; | |
| DataExtractor::Cursor Cur(0); | |
| Error ULEBSizeErr = Error::success(); | |
| Error MetadataDecodeErr = Error::success(); | |
| // Use int for Version to avoid Twine treating uint8_t as char. | |
| int Version = 0; | |
| uint16_t Feature = 0; | |
| BBAddrMap::Features FeatEnable{}; | |
| while (!ULEBSizeErr && !MetadataDecodeErr && Cur && | |
| Cur.tell() < Data.getData().size()) { | |
| Version = Data.getU8(Cur); | |
| if (!Cur) | |
| break; | |
| if (Version < 2 || Version > 5) | |
| return createError("unsupported BB address map version: " + | |
| Twine(Version)); | |
| Feature = Version < 5 ? Data.getU8(Cur) : Data.getU16(Cur); | |
| if (!Cur) | |
| break; | |
| auto FeatEnableOrErr = BBAddrMap::Features::decode(Feature); | |
| if (!FeatEnableOrErr) | |
| return FeatEnableOrErr.takeError(); | |
| FeatEnable = *FeatEnableOrErr; | |
| if (FeatEnable.CallsiteEndOffsets && Version < 3) | |
| return createError("version should be >= 3 for BB address map when " | |
| "callsite offsets feature is enabled: version = " + | |
| Twine(Version) + " feature = " + Twine(Feature)); | |
| if (FeatEnable.BBHash && Version < 4) | |
| return createError("version should be >= 4 for BB address map when " | |
| "basic block hash feature is enabled: version = " + | |
| Twine(Version) + " feature = " + Twine(Feature)); | |
| if (FeatEnable.PostLinkCfg && Version < 5) | |
| return createError("version should be >= 5 for BB address map when " | |
| "post link cfg feature is enabled: version = " + | |
| Twine(Version) + " feature = " + Twine(Feature)); | |
| uint32_t NumBlocksInBBRange = 0; | |
| uint32_t NumBBRanges = 1; | |
| uint64_t RangeBaseAddress = 0; | |
| if (FeatEnable.MultiBBRange) { | |
| NumBBRanges = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| if (!Cur || ULEBSizeErr) | |
| break; | |
| if (!NumBBRanges) | |
| return createError("invalid zero number of BB ranges at offset " + | |
| Twine::utohexstr(Cur.tell())); | |
| } else { | |
| auto AddressOrErr = Extractor.extractAddress(Cur); | |
| if (!AddressOrErr) | |
| return AddressOrErr.takeError(); | |
| RangeBaseAddress = *AddressOrErr; | |
| NumBlocksInBBRange = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| } | |
| std::vector<BBAddrMap::BBRangeEntry> BBRangeEntries; | |
| uint32_t TotalNumBlocks = 0; | |
| for (uint32_t BBRangeIndex = 0; BBRangeIndex < NumBBRanges; | |
| ++BBRangeIndex) { | |
| uint32_t PrevBBEndOffset = 0; | |
| if (FeatEnable.MultiBBRange) { | |
| auto AddressOrErr = Extractor.extractAddress(Cur); | |
| if (!AddressOrErr) | |
| return AddressOrErr.takeError(); | |
| RangeBaseAddress = *AddressOrErr; | |
| NumBlocksInBBRange = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| } | |
| std::vector<BBAddrMap::BBEntry> BBEntries; | |
| if (!FeatEnable.OmitBBEntries) { | |
| for (uint32_t BlockIndex = 0; !MetadataDecodeErr && !ULEBSizeErr && | |
| Cur && (BlockIndex < NumBlocksInBBRange); | |
| ++BlockIndex) { | |
| uint32_t ID = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| uint32_t Offset = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| // Read the callsite offsets. | |
| uint32_t LastCallsiteEndOffset = 0; | |
| SmallVector<uint32_t, 1> CallsiteEndOffsets; | |
| if (FeatEnable.CallsiteEndOffsets) { | |
| uint32_t NumCallsites = | |
| readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| CallsiteEndOffsets.reserve(NumCallsites); | |
| for (uint32_t CallsiteIndex = 0; | |
| !ULEBSizeErr && Cur && (CallsiteIndex < NumCallsites); | |
| ++CallsiteIndex) { | |
| LastCallsiteEndOffset += | |
| readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| CallsiteEndOffsets.push_back(LastCallsiteEndOffset); | |
| } | |
| } | |
| uint32_t Size = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr) + | |
| LastCallsiteEndOffset; | |
| uint32_t MD = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| uint64_t Hash = FeatEnable.BBHash ? Data.getU64(Cur) : 0; | |
| Expected<BBAddrMap::BBEntry::Metadata> MetadataOrErr = | |
| BBAddrMap::BBEntry::Metadata::decode(MD); | |
| if (!MetadataOrErr) { | |
| MetadataDecodeErr = MetadataOrErr.takeError(); | |
| break; | |
| } | |
| BBEntries.push_back({ID, Offset + PrevBBEndOffset, Size, | |
| *MetadataOrErr, CallsiteEndOffsets, Hash}); | |
| PrevBBEndOffset += Offset + Size; | |
| } | |
| TotalNumBlocks += BBEntries.size(); | |
| } | |
| BBRangeEntries.push_back({RangeBaseAddress, std::move(BBEntries)}); | |
| } | |
| FunctionEntries.push_back({std::move(BBRangeEntries)}); | |
| if (PGOAnalyses || FeatEnable.hasPGOAnalysis()) { | |
| // Function entry count | |
| uint64_t FuncEntryCount = | |
| FeatEnable.FuncEntryCount | |
| ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr) | |
| : 0; | |
| std::vector<PGOAnalysisMap::PGOBBEntry> PGOBBEntries; | |
| for (uint32_t BlockIndex = 0; | |
| FeatEnable.hasPGOAnalysisBBData() && !MetadataDecodeErr && | |
| !ULEBSizeErr && Cur && (BlockIndex < TotalNumBlocks); | |
| ++BlockIndex) { | |
| // Block frequency | |
| uint64_t BBF = FeatEnable.BBFreq | |
| ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr) | |
| : 0; | |
| uint32_t PostLinkBBFreq = | |
| FeatEnable.PostLinkCfg | |
| ? readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr) | |
| : 0; | |
| // Branch probability | |
| llvm::SmallVector<PGOAnalysisMap::PGOBBEntry::SuccessorEntry, 2> | |
| Successors; | |
| if (FeatEnable.BrProb) { | |
| auto SuccCount = readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr); | |
| for (uint64_t I = 0; I < SuccCount; ++I) { | |
| uint32_t BBID = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| uint32_t BrProb = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr); | |
| uint32_t PostLinkFreq = | |
| FeatEnable.PostLinkCfg | |
| ? readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr) | |
| : 0; | |
| if (PGOAnalyses) | |
| Successors.push_back( | |
| {BBID, BranchProbability::getRaw(BrProb), PostLinkFreq}); | |
| } | |
| } | |
| if (PGOAnalyses) | |
| PGOBBEntries.push_back( | |
| {BlockFrequency(BBF), PostLinkBBFreq, std::move(Successors)}); | |
| } | |
| if (PGOAnalyses) | |
| PGOAnalyses->push_back( | |
| {FuncEntryCount, std::move(PGOBBEntries), FeatEnable}); | |
| } | |
| } | |
| // Either Cur is in the error state, or we have an error in ULEBSizeErr or | |
| // MetadataDecodeErr (but not both), but we join all errors here to be safe. | |
| if (!Cur || ULEBSizeErr || MetadataDecodeErr) | |
| return joinErrors(joinErrors(Cur.takeError(), std::move(ULEBSizeErr)), | |
| std::move(MetadataDecodeErr)); | |
| return FunctionEntries; | |
| } |