//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// // // 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 // //===----------------------------------------------------------------------===// #include "llvm/Bitcode/BitcodeReader.h" #include "MetadataLoader.h" #include "ValueList.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Twine.h" #include "llvm/Bitcode/BitcodeCommon.h" #include "llvm/Bitcode/LLVMBitCodes.h" #include "llvm/Bitstream/BitstreamReader.h" #include "llvm/Config/llvm-config.h" #include "llvm/IR/Argument.h" #include "llvm/IR/AttributeMask.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/AutoUpgrade.h" #include "llvm/IR/BasicBlock.h" #include "llvm/IR/CallingConv.h" #include "llvm/IR/Comdat.h" #include "llvm/IR/Constant.h" #include "llvm/IR/ConstantRangeList.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DebugInfo.h" #include "llvm/IR/DebugInfoMetadata.h" #include "llvm/IR/DebugLoc.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Function.h" #include "llvm/IR/GVMaterializer.h" #include "llvm/IR/GetElementPtrTypeIterator.h" #include "llvm/IR/GlobalAlias.h" #include "llvm/IR/GlobalIFunc.h" #include "llvm/IR/GlobalObject.h" #include "llvm/IR/GlobalValue.h" #include "llvm/IR/GlobalVariable.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/InstIterator.h" #include "llvm/IR/InstrTypes.h" #include "llvm/IR/Instruction.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/IntrinsicsAArch64.h" #include "llvm/IR/IntrinsicsARM.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Metadata.h" #include "llvm/IR/Module.h" #include "llvm/IR/ModuleSummaryIndex.h" #include "llvm/IR/Operator.h" #include "llvm/IR/ProfDataUtils.h" #include "llvm/IR/Type.h" #include "llvm/IR/Value.h" #include "llvm/IR/Verifier.h" #include "llvm/Support/AtomicOrdering.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Debug.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/ModRef.h" #include "llvm/Support/raw_ostream.h" #include "llvm/TargetParser/Triple.h" #include <algorithm> #include <cassert> #include <cstddef> #include <cstdint> #include <deque> #include <map> #include <memory> #include <optional> #include <set> #include <string> #include <system_error> #include <tuple> #include <utility> #include <vector> usingnamespacellvm; static cl::opt<bool> PrintSummaryGUIDs( "print-summary-global-ids", cl::init(false), cl::Hidden, cl::desc( "Print the global id for each value when reading the module summary")); static cl::opt<bool> ExpandConstantExprs( "expand-constant-exprs", cl::Hidden, cl::desc( "Expand constant expressions to instructions for testing purposes")); /// Load bitcode directly into RemoveDIs format (use debug records instead /// of debug intrinsics). UNSET is treated as FALSE, so the default action /// is to do nothing. Individual tools can override this to incrementally add /// support for the RemoveDIs format. cl::opt<cl::boolOrDefault> LoadBitcodeIntoNewDbgInfoFormat( "load-bitcode-into-experimental-debuginfo-iterators", cl::Hidden, cl::desc("Load bitcode directly into the new debug info format (regardless " "of input format)")); extern cl::opt<bool> UseNewDbgInfoFormat; extern cl::opt<cl::boolOrDefault> PreserveInputDbgFormat; extern bool WriteNewDbgInfoFormatToBitcode; extern cl::opt<bool> WriteNewDbgInfoFormat; namespace { enum { … }; } // end anonymous namespace static Error error(const Twine &Message) { … } static Error hasInvalidBitcodeHeader(BitstreamCursor &Stream) { … } static Expected<BitstreamCursor> initStream(MemoryBufferRef Buffer) { … } /// Convert a string from a record into an std::string, return true on failure. template <typename StrTy> static bool convertToString(ArrayRef<uint64_t> Record, unsigned Idx, StrTy &Result) { … } // Strip all the TBAA attachment for the module. static void stripTBAA(Module *M) { … } /// Read the "IDENTIFICATION_BLOCK_ID" block, do some basic enforcement on the /// "epoch" encoded in the bitcode, and return the producer name if any. static Expected<std::string> readIdentificationBlock(BitstreamCursor &Stream) { … } static Expected<std::string> readIdentificationCode(BitstreamCursor &Stream) { … } static Expected<bool> hasObjCCategoryInModule(BitstreamCursor &Stream) { … } static Expected<bool> hasObjCCategory(BitstreamCursor &Stream) { … } static Expected<std::string> readModuleTriple(BitstreamCursor &Stream) { … } static Expected<std::string> readTriple(BitstreamCursor &Stream) { … } namespace { class BitcodeReaderBase { … }; } // end anonymous namespace Error BitcodeReaderBase::error(const Twine &Message) { … } Expected<unsigned> BitcodeReaderBase::parseVersionRecord(ArrayRef<uint64_t> Record) { … } std::pair<StringRef, ArrayRef<uint64_t>> BitcodeReaderBase::readNameFromStrtab(ArrayRef<uint64_t> Record) { … } namespace { /// This represents a constant expression or constant aggregate using a custom /// structure internal to the bitcode reader. Later, this structure will be /// expanded by materializeValue() either into a constant expression/aggregate, /// or into an instruction sequence at the point of use. This allows us to /// upgrade bitcode using constant expressions even if this kind of constant /// expression is no longer supported. class BitcodeConstant final : public Value, TrailingObjects<BitcodeConstant, unsigned> { … }; class BitcodeReader : public BitcodeReaderBase, public GVMaterializer { … }; /// Class to manage reading and parsing function summary index bitcode /// files/sections. class ModuleSummaryIndexBitcodeReader : public BitcodeReaderBase { … }; } // end anonymous namespace std::error_code llvm::errorToErrorCodeAndEmitErrors(LLVMContext &Ctx, Error Err) { … } BitcodeReader::BitcodeReader(BitstreamCursor Stream, StringRef Strtab, StringRef ProducerIdentification, LLVMContext &Context) : … { … } Error BitcodeReader::materializeForwardReferencedFunctions() { … } //===----------------------------------------------------------------------===// // Helper functions to implement forward reference resolution, etc. //===----------------------------------------------------------------------===// static bool hasImplicitComdat(size_t Val) { … } static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) { … } static FunctionSummary::FFlags getDecodedFFlags(uint64_t RawFlags) { … } // Decode the flags for GlobalValue in the summary. The bits for each attribute: // // linkage: [0,4), notEligibleToImport: 4, live: 5, local: 6, canAutoHide: 7, // visibility: [8, 10). static GlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags, uint64_t Version) { … } // Decode the flags for GlobalVariable in the summary static GlobalVarSummary::GVarFlags getDecodedGVarFlags(uint64_t RawFlags) { … } static std::pair<CalleeInfo::HotnessType, bool> getDecodedHotnessCallEdgeInfo(uint64_t RawFlags) { … } static void getDecodedRelBFCallEdgeInfo(uint64_t RawFlags, uint64_t &RelBF, bool &HasTailCall) { … } static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) { … } static GlobalValue::DLLStorageClassTypes getDecodedDLLStorageClass(unsigned Val) { … } static bool getDecodedDSOLocal(unsigned Val) { … } static std::optional<CodeModel::Model> getDecodedCodeModel(unsigned Val) { … } static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) { … } static GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val) { … } static int getDecodedCastOpcode(unsigned Val) { … } static int getDecodedUnaryOpcode(unsigned Val, Type *Ty) { … } static int getDecodedBinaryOpcode(unsigned Val, Type *Ty) { … } static AtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val) { … } static AtomicOrdering getDecodedOrdering(unsigned Val) { … } static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) { … } static FastMathFlags getDecodedFastMathFlags(unsigned Val) { … } static void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val) { … } Type *BitcodeReader::getTypeByID(unsigned ID) { … } unsigned BitcodeReader::getContainedTypeID(unsigned ID, unsigned Idx) { … } Type *BitcodeReader::getPtrElementTypeByID(unsigned ID) { … } unsigned BitcodeReader::getVirtualTypeID(Type *Ty, ArrayRef<unsigned> ChildTypeIDs) { … } static GEPNoWrapFlags toGEPNoWrapFlags(uint64_t Flags) { … } static bool isConstExprSupported(const BitcodeConstant *BC) { … } Expected<Value *> BitcodeReader::materializeValue(unsigned StartValID, BasicBlock *InsertBB) { … } Expected<Constant *> BitcodeReader::getValueForInitializer(unsigned ID) { … } StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context, StringRef Name) { … } StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) { … } //===----------------------------------------------------------------------===// // Functions for parsing blocks from the bitcode file //===----------------------------------------------------------------------===// static uint64_t getRawAttributeMask(Attribute::AttrKind Val) { … } static void addRawAttributeValue(AttrBuilder &B, uint64_t Val) { … } /// This fills an AttrBuilder object with the LLVM attributes that have /// been decoded from the given integer. This function must stay in sync with /// 'encodeLLVMAttributesForBitcode'. static void decodeLLVMAttributesForBitcode(AttrBuilder &B, uint64_t EncodedAttrs, uint64_t AttrIdx) { … } Error BitcodeReader::parseAttributeBlock() { … } // Returns Attribute::None on unrecognized codes. static Attribute::AttrKind getAttrFromCode(uint64_t Code) { … } Error BitcodeReader::parseAlignmentValue(uint64_t Exponent, MaybeAlign &Alignment) { … } Error BitcodeReader::parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind) { … } static bool upgradeOldMemoryAttribute(MemoryEffects &ME, uint64_t EncodedKind) { … } Error BitcodeReader::parseAttributeGroupBlock() { … } Error BitcodeReader::parseTypeTable() { … } Error BitcodeReader::parseTypeTableBody() { … } Error BitcodeReader::parseOperandBundleTags() { … } Error BitcodeReader::parseSyncScopeNames() { … } /// Associate a value with its name from the given index in the provided record. Expected<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record, unsigned NameIndex, Triple &TT) { … } /// Helper to note and return the current location, and jump to the given /// offset. static Expected<uint64_t> jumpToValueSymbolTable(uint64_t Offset, BitstreamCursor &Stream) { … } void BitcodeReader::setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta, Function *F, ArrayRef<uint64_t> Record) { … } /// Read a new-style GlobalValue symbol table. Error BitcodeReader::parseGlobalValueSymbolTable() { … } /// Parse the value symbol table at either the current parsing location or /// at the given bit offset if provided. Error BitcodeReader::parseValueSymbolTable(uint64_t Offset) { … } /// Decode a signed value stored with the sign bit in the LSB for dense VBR /// encoding. uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { … } /// Resolve all of the initializers for global values and aliases that we can. Error BitcodeReader::resolveGlobalAndIndirectSymbolInits() { … } APInt llvm::readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { … } Error BitcodeReader::parseConstants() { … } Error BitcodeReader::parseUseLists() { … } /// When we see the block for metadata, remember where it is and then skip it. /// This lets us lazily deserialize the metadata. Error BitcodeReader::rememberAndSkipMetadata() { … } Error BitcodeReader::materializeMetadata() { … } void BitcodeReader::setStripDebugInfo() { … } /// When we see the block for a function body, remember where it is and then /// skip it. This lets us lazily deserialize the functions. Error BitcodeReader::rememberAndSkipFunctionBody() { … } Error BitcodeReader::globalCleanup() { … } /// Support for lazy parsing of function bodies. This is required if we /// either have an old bitcode file without a VST forward declaration record, /// or if we have an anonymous function being materialized, since anonymous /// functions do not have a name and are therefore not in the VST. Error BitcodeReader::rememberAndSkipFunctionBodies() { … } Error BitcodeReaderBase::readBlockInfo() { … } Error BitcodeReader::parseComdatRecord(ArrayRef<uint64_t> Record) { … } static void inferDSOLocal(GlobalValue *GV) { … } GlobalValue::SanitizerMetadata deserializeSanitizerMetadata(unsigned V) { … } Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) { … } void BitcodeReader::callValueTypeCallback(Value *F, unsigned TypeID) { … } Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) { … } Error BitcodeReader::parseGlobalIndirectSymbolRecord( unsigned BitCode, ArrayRef<uint64_t> Record) { … } Error BitcodeReader::parseModule(uint64_t ResumeBit, bool ShouldLazyLoadMetadata, ParserCallbacks Callbacks) { … } Error BitcodeReader::parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks) { … } Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType, Type *PtrType) { … } Error BitcodeReader::propagateAttributeTypes(CallBase *CB, ArrayRef<unsigned> ArgTyIDs) { … } /// Lazily parse the specified function body block. Error BitcodeReader::parseFunctionBody(Function *F) { … } /// Find the function body in the bitcode stream Error BitcodeReader::findFunctionInStream( Function *F, DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) { … } SyncScope::ID BitcodeReader::getDecodedSyncScopeID(unsigned Val) { … } //===----------------------------------------------------------------------===// // GVMaterializer implementation //===----------------------------------------------------------------------===// Error BitcodeReader::materialize(GlobalValue *GV) { … } Error BitcodeReader::materializeModule() { … } std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const { … } ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader( BitstreamCursor Cursor, StringRef Strtab, ModuleSummaryIndex &TheIndex, StringRef ModulePath, std::function<bool(GlobalValue::GUID)> IsPrevailing) : … { … } void ModuleSummaryIndexBitcodeReader::addThisModule() { … } ModuleSummaryIndex::ModuleInfo * ModuleSummaryIndexBitcodeReader::getThisModule() { … } template <bool AllowNullValueInfo> std::pair<ValueInfo, GlobalValue::GUID> ModuleSummaryIndexBitcodeReader::getValueInfoFromValueId(unsigned ValueId) { … } void ModuleSummaryIndexBitcodeReader::setValueGUID( uint64_t ValueID, StringRef ValueName, GlobalValue::LinkageTypes Linkage, StringRef SourceFileName) { … } // Specialized value symbol table parser used when reading module index // blocks where we don't actually create global values. The parsed information // is saved in the bitcode reader for use when later parsing summaries. Error ModuleSummaryIndexBitcodeReader::parseValueSymbolTable( uint64_t Offset, DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) { … } // Parse just the blocks needed for building the index out of the module. // At the end of this routine the module Index is populated with a map // from global value id to GlobalValueSummary objects. Error ModuleSummaryIndexBitcodeReader::parseModule() { … } SmallVector<ValueInfo, 0> ModuleSummaryIndexBitcodeReader::makeRefList(ArrayRef<uint64_t> Record) { … } SmallVector<FunctionSummary::EdgeTy, 0> ModuleSummaryIndexBitcodeReader::makeCallList(ArrayRef<uint64_t> Record, bool IsOldProfileFormat, bool HasProfile, bool HasRelBF) { … } static void parseWholeProgramDevirtResolutionByArg(ArrayRef<uint64_t> Record, size_t &Slot, WholeProgramDevirtResolution &Wpd) { … } static void parseWholeProgramDevirtResolution(ArrayRef<uint64_t> Record, StringRef Strtab, size_t &Slot, TypeIdSummary &TypeId) { … } static void parseTypeIdSummaryRecord(ArrayRef<uint64_t> Record, StringRef Strtab, ModuleSummaryIndex &TheIndex) { … } std::vector<FunctionSummary::ParamAccess> ModuleSummaryIndexBitcodeReader::parseParamAccesses(ArrayRef<uint64_t> Record) { … } void ModuleSummaryIndexBitcodeReader::parseTypeIdCompatibleVtableInfo( ArrayRef<uint64_t> Record, size_t &Slot, TypeIdCompatibleVtableInfo &TypeId) { … } void ModuleSummaryIndexBitcodeReader::parseTypeIdCompatibleVtableSummaryRecord( ArrayRef<uint64_t> Record) { … } static void setSpecialRefs(SmallVectorImpl<ValueInfo> &Refs, unsigned ROCnt, unsigned WOCnt) { … } // Eagerly parse the entire summary block. This populates the GlobalValueSummary // objects in the index. Error ModuleSummaryIndexBitcodeReader::parseEntireSummary(unsigned ID) { … } // Parse the module string table block into the Index. // This populates the ModulePathStringTable map in the index. Error ModuleSummaryIndexBitcodeReader::parseModuleStringTable() { … } namespace { // FIXME: This class is only here to support the transition to llvm::Error. It // will be removed once this transition is complete. Clients should prefer to // deal with the Error value directly, rather than converting to error_code. class BitcodeErrorCategoryType : public std::error_category { … }; } // end anonymous namespace const std::error_category &llvm::BitcodeErrorCategory() { … } static Expected<StringRef> readBlobInRecord(BitstreamCursor &Stream, unsigned Block, unsigned RecordID) { … } //===----------------------------------------------------------------------===// // External interface //===----------------------------------------------------------------------===// Expected<std::vector<BitcodeModule>> llvm::getBitcodeModuleList(MemoryBufferRef Buffer) { … } Expected<BitcodeFileContents> llvm::getBitcodeFileContents(MemoryBufferRef Buffer) { … } /// Get a lazy one-at-time loading module from bitcode. /// /// This isn't always used in a lazy context. In particular, it's also used by /// \a parseModule(). If this is truly lazy, then we need to eagerly pull /// in forward-referenced functions from block address references. /// /// \param[in] MaterializeAll Set to \c true if we should materialize /// everything. Expected<std::unique_ptr<Module>> BitcodeModule::getModuleImpl(LLVMContext &Context, bool MaterializeAll, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks) { … } Expected<std::unique_ptr<Module>> BitcodeModule::getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks) { … } // Parse the specified bitcode buffer and merge the index into CombinedIndex. // We don't use ModuleIdentifier here because the client may need to control the // module path used in the combined summary (e.g. when reading summaries for // regular LTO modules). Error BitcodeModule::readSummary( ModuleSummaryIndex &CombinedIndex, StringRef ModulePath, std::function<bool(GlobalValue::GUID)> IsPrevailing) { … } // Parse the specified bitcode buffer, returning the function info index. Expected<std::unique_ptr<ModuleSummaryIndex>> BitcodeModule::getSummary() { … } static Expected<std::pair<bool, bool>> getEnableSplitLTOUnitAndUnifiedFlag(BitstreamCursor &Stream, unsigned ID, BitcodeLTOInfo <OInfo) { … } // Check if the given bitcode buffer contains a global value summary block. Expected<BitcodeLTOInfo> BitcodeModule::getLTOInfo() { … } static Expected<BitcodeModule> getSingleModule(MemoryBufferRef Buffer) { … } Expected<std::unique_ptr<Module>> llvm::getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks) { … } Expected<std::unique_ptr<Module>> llvm::getOwningLazyBitcodeModule( std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks) { … } Expected<std::unique_ptr<Module>> BitcodeModule::parseModule(LLVMContext &Context, ParserCallbacks Callbacks) { … } Expected<std::unique_ptr<Module>> llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, ParserCallbacks Callbacks) { … } Expected<std::string> llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer) { … } Expected<bool> llvm::isBitcodeContainingObjCCategory(MemoryBufferRef Buffer) { … } Expected<std::string> llvm::getBitcodeProducerString(MemoryBufferRef Buffer) { … } Error llvm::readModuleSummaryIndex(MemoryBufferRef Buffer, ModuleSummaryIndex &CombinedIndex) { … } Expected<std::unique_ptr<ModuleSummaryIndex>> llvm::getModuleSummaryIndex(MemoryBufferRef Buffer) { … } Expected<BitcodeLTOInfo> llvm::getBitcodeLTOInfo(MemoryBufferRef Buffer) { … } Expected<std::unique_ptr<ModuleSummaryIndex>> llvm::getModuleSummaryIndexForFile(StringRef Path, bool IgnoreEmptyThinLTOIndexFile) { … }
Codebase Browser
llvm