diff options
author | Dimitry Andric <dim@FreeBSD.org> | 2019-12-20 19:53:05 +0000 |
---|---|---|
committer | Dimitry Andric <dim@FreeBSD.org> | 2019-12-20 19:53:05 +0000 |
commit | 0b57cec536236d46e3dba9bd041533462f33dbb7 (patch) | |
tree | 56229dbdbbf76d18580f72f789003db17246c8d9 /contrib/llvm/lib/Bitcode/Reader/MetadataLoader.cpp | |
parent | 718ef55ec7785aae63f98f8ca05dc07ed399c16d (diff) |
Notes
Diffstat (limited to 'contrib/llvm/lib/Bitcode/Reader/MetadataLoader.cpp')
-rw-r--r-- | contrib/llvm/lib/Bitcode/Reader/MetadataLoader.cpp | 2175 |
1 files changed, 0 insertions, 2175 deletions
diff --git a/contrib/llvm/lib/Bitcode/Reader/MetadataLoader.cpp b/contrib/llvm/lib/Bitcode/Reader/MetadataLoader.cpp deleted file mode 100644 index 108f71189585..000000000000 --- a/contrib/llvm/lib/Bitcode/Reader/MetadataLoader.cpp +++ /dev/null @@ -1,2175 +0,0 @@ -//===- MetadataLoader.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 "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/DenseSet.h" -#include "llvm/ADT/None.h" -#include "llvm/ADT/STLExtras.h" -#include "llvm/ADT/SmallString.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/Statistic.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/ADT/Twine.h" -#include "llvm/Bitcode/BitcodeReader.h" -#include "llvm/Bitstream/BitstreamReader.h" -#include "llvm/Bitcode/LLVMBitCodes.h" -#include "llvm/IR/Argument.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/Constants.h" -#include "llvm/IR/DebugInfo.h" -#include "llvm/IR/DebugInfoMetadata.h" -#include "llvm/IR/DebugLoc.h" -#include "llvm/IR/DerivedTypes.h" -#include "llvm/IR/DiagnosticPrinter.h" -#include "llvm/IR/Function.h" -#include "llvm/IR/GVMaterializer.h" -#include "llvm/IR/GlobalAlias.h" -#include "llvm/IR/GlobalIFunc.h" -#include "llvm/IR/GlobalIndirectSymbol.h" -#include "llvm/IR/GlobalObject.h" -#include "llvm/IR/GlobalValue.h" -#include "llvm/IR/GlobalVariable.h" -#include "llvm/IR/InlineAsm.h" -#include "llvm/IR/InstrTypes.h" -#include "llvm/IR/Instruction.h" -#include "llvm/IR/Instructions.h" -#include "llvm/IR/IntrinsicInst.h" -#include "llvm/IR/Intrinsics.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/IR/Module.h" -#include "llvm/IR/ModuleSummaryIndex.h" -#include "llvm/IR/OperandTraits.h" -#include "llvm/IR/TrackingMDRef.h" -#include "llvm/IR/Type.h" -#include "llvm/IR/ValueHandle.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/ManagedStatic.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/raw_ostream.h" -#include <algorithm> -#include <cassert> -#include <cstddef> -#include <cstdint> -#include <deque> -#include <limits> -#include <map> -#include <memory> -#include <string> -#include <system_error> -#include <tuple> -#include <utility> -#include <vector> - -using namespace llvm; - -#define DEBUG_TYPE "bitcode-reader" - -STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded"); -STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created"); -STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded"); - -/// Flag whether we need to import full type definitions for ThinLTO. -/// Currently needed for Darwin and LLDB. -static cl::opt<bool> ImportFullTypeDefinitions( - "import-full-type-definitions", cl::init(false), cl::Hidden, - cl::desc("Import full type definitions for ThinLTO.")); - -static cl::opt<bool> DisableLazyLoading( - "disable-ondemand-mds-loading", cl::init(false), cl::Hidden, - cl::desc("Force disable the lazy-loading on-demand of metadata when " - "loading bitcode for importing.")); - -namespace { - -static int64_t unrotateSign(uint64_t U) { return (U & 1) ? ~(U >> 1) : U >> 1; } - -class BitcodeReaderMetadataList { - /// Array of metadata references. - /// - /// Don't use std::vector here. Some versions of libc++ copy (instead of - /// move) on resize, and TrackingMDRef is very expensive to copy. - SmallVector<TrackingMDRef, 1> MetadataPtrs; - - /// The set of indices in MetadataPtrs above of forward references that were - /// generated. - SmallDenseSet<unsigned, 1> ForwardReference; - - /// The set of indices in MetadataPtrs above of Metadata that need to be - /// resolved. - SmallDenseSet<unsigned, 1> UnresolvedNodes; - - /// Structures for resolving old type refs. - struct { - SmallDenseMap<MDString *, TempMDTuple, 1> Unknown; - SmallDenseMap<MDString *, DICompositeType *, 1> Final; - SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls; - SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays; - } OldTypeRefs; - - LLVMContext &Context; - - /// Maximum number of valid references. Forward references exceeding the - /// maximum must be invalid. - unsigned RefsUpperBound; - -public: - BitcodeReaderMetadataList(LLVMContext &C, size_t RefsUpperBound) - : Context(C), - RefsUpperBound(std::min((size_t)std::numeric_limits<unsigned>::max(), - RefsUpperBound)) {} - - // vector compatibility methods - unsigned size() const { return MetadataPtrs.size(); } - void resize(unsigned N) { MetadataPtrs.resize(N); } - void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); } - void clear() { MetadataPtrs.clear(); } - Metadata *back() const { return MetadataPtrs.back(); } - void pop_back() { MetadataPtrs.pop_back(); } - bool empty() const { return MetadataPtrs.empty(); } - - Metadata *operator[](unsigned i) const { - assert(i < MetadataPtrs.size()); - return MetadataPtrs[i]; - } - - Metadata *lookup(unsigned I) const { - if (I < MetadataPtrs.size()) - return MetadataPtrs[I]; - return nullptr; - } - - void shrinkTo(unsigned N) { - assert(N <= size() && "Invalid shrinkTo request!"); - assert(ForwardReference.empty() && "Unexpected forward refs"); - assert(UnresolvedNodes.empty() && "Unexpected unresolved node"); - MetadataPtrs.resize(N); - } - - /// Return the given metadata, creating a replaceable forward reference if - /// necessary. - Metadata *getMetadataFwdRef(unsigned Idx); - - /// Return the given metadata only if it is fully resolved. - /// - /// Gives the same result as \a lookup(), unless \a MDNode::isResolved() - /// would give \c false. - Metadata *getMetadataIfResolved(unsigned Idx); - - MDNode *getMDNodeFwdRefOrNull(unsigned Idx); - void assignValue(Metadata *MD, unsigned Idx); - void tryToResolveCycles(); - bool hasFwdRefs() const { return !ForwardReference.empty(); } - int getNextFwdRef() { - assert(hasFwdRefs()); - return *ForwardReference.begin(); - } - - /// Upgrade a type that had an MDString reference. - void addTypeRef(MDString &UUID, DICompositeType &CT); - - /// Upgrade a type that had an MDString reference. - Metadata *upgradeTypeRef(Metadata *MaybeUUID); - - /// Upgrade a type ref array that may have MDString references. - Metadata *upgradeTypeRefArray(Metadata *MaybeTuple); - -private: - Metadata *resolveTypeRefArray(Metadata *MaybeTuple); -}; - -void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) { - if (auto *MDN = dyn_cast<MDNode>(MD)) - if (!MDN->isResolved()) - UnresolvedNodes.insert(Idx); - - if (Idx == size()) { - push_back(MD); - return; - } - - if (Idx >= size()) - resize(Idx + 1); - - TrackingMDRef &OldMD = MetadataPtrs[Idx]; - if (!OldMD) { - OldMD.reset(MD); - return; - } - - // If there was a forward reference to this value, replace it. - TempMDTuple PrevMD(cast<MDTuple>(OldMD.get())); - PrevMD->replaceAllUsesWith(MD); - ForwardReference.erase(Idx); -} - -Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) { - // Bail out for a clearly invalid value. - if (Idx >= RefsUpperBound) - return nullptr; - - if (Idx >= size()) - resize(Idx + 1); - - if (Metadata *MD = MetadataPtrs[Idx]) - return MD; - - // Track forward refs to be resolved later. - ForwardReference.insert(Idx); - - // Create and return a placeholder, which will later be RAUW'd. - ++NumMDNodeTemporary; - Metadata *MD = MDNode::getTemporary(Context, None).release(); - MetadataPtrs[Idx].reset(MD); - return MD; -} - -Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) { - Metadata *MD = lookup(Idx); - if (auto *N = dyn_cast_or_null<MDNode>(MD)) - if (!N->isResolved()) - return nullptr; - return MD; -} - -MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) { - return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx)); -} - -void BitcodeReaderMetadataList::tryToResolveCycles() { - if (!ForwardReference.empty()) - // Still forward references... can't resolve cycles. - return; - - // Give up on finding a full definition for any forward decls that remain. - for (const auto &Ref : OldTypeRefs.FwdDecls) - OldTypeRefs.Final.insert(Ref); - OldTypeRefs.FwdDecls.clear(); - - // Upgrade from old type ref arrays. In strange cases, this could add to - // OldTypeRefs.Unknown. - for (const auto &Array : OldTypeRefs.Arrays) - Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get())); - OldTypeRefs.Arrays.clear(); - - // Replace old string-based type refs with the resolved node, if possible. - // If we haven't seen the node, leave it to the verifier to complain about - // the invalid string reference. - for (const auto &Ref : OldTypeRefs.Unknown) { - if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first)) - Ref.second->replaceAllUsesWith(CT); - else - Ref.second->replaceAllUsesWith(Ref.first); - } - OldTypeRefs.Unknown.clear(); - - if (UnresolvedNodes.empty()) - // Nothing to do. - return; - - // Resolve any cycles. - for (unsigned I : UnresolvedNodes) { - auto &MD = MetadataPtrs[I]; - auto *N = dyn_cast_or_null<MDNode>(MD); - if (!N) - continue; - - assert(!N->isTemporary() && "Unexpected forward reference"); - N->resolveCycles(); - } - - // Make sure we return early again until there's another unresolved ref. - UnresolvedNodes.clear(); -} - -void BitcodeReaderMetadataList::addTypeRef(MDString &UUID, - DICompositeType &CT) { - assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID"); - if (CT.isForwardDecl()) - OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT)); - else - OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT)); -} - -Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) { - auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID); - if (LLVM_LIKELY(!UUID)) - return MaybeUUID; - - if (auto *CT = OldTypeRefs.Final.lookup(UUID)) - return CT; - - auto &Ref = OldTypeRefs.Unknown[UUID]; - if (!Ref) - Ref = MDNode::getTemporary(Context, None); - return Ref.get(); -} - -Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) { - auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); - if (!Tuple || Tuple->isDistinct()) - return MaybeTuple; - - // Look through the array immediately if possible. - if (!Tuple->isTemporary()) - return resolveTypeRefArray(Tuple); - - // Create and return a placeholder to use for now. Eventually - // resolveTypeRefArrays() will be resolve this forward reference. - OldTypeRefs.Arrays.emplace_back( - std::piecewise_construct, std::forward_as_tuple(Tuple), - std::forward_as_tuple(MDTuple::getTemporary(Context, None))); - return OldTypeRefs.Arrays.back().second.get(); -} - -Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) { - auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); - if (!Tuple || Tuple->isDistinct()) - return MaybeTuple; - - // Look through the DITypeRefArray, upgrading each DIType *. - SmallVector<Metadata *, 32> Ops; - Ops.reserve(Tuple->getNumOperands()); - for (Metadata *MD : Tuple->operands()) - Ops.push_back(upgradeTypeRef(MD)); - - return MDTuple::get(Context, Ops); -} - -namespace { - -class PlaceholderQueue { - // Placeholders would thrash around when moved, so store in a std::deque - // instead of some sort of vector. - std::deque<DistinctMDOperandPlaceholder> PHs; - -public: - ~PlaceholderQueue() { - assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed"); - } - bool empty() { return PHs.empty(); } - DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID); - void flush(BitcodeReaderMetadataList &MetadataList); - - /// Return the list of temporaries nodes in the queue, these need to be - /// loaded before we can flush the queue. - void getTemporaries(BitcodeReaderMetadataList &MetadataList, - DenseSet<unsigned> &Temporaries) { - for (auto &PH : PHs) { - auto ID = PH.getID(); - auto *MD = MetadataList.lookup(ID); - if (!MD) { - Temporaries.insert(ID); - continue; - } - auto *N = dyn_cast_or_null<MDNode>(MD); - if (N && N->isTemporary()) - Temporaries.insert(ID); - } - } -}; - -} // end anonymous namespace - -DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) { - PHs.emplace_back(ID); - return PHs.back(); -} - -void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) { - while (!PHs.empty()) { - auto *MD = MetadataList.lookup(PHs.front().getID()); - assert(MD && "Flushing placeholder on unassigned MD"); -#ifndef NDEBUG - if (auto *MDN = dyn_cast<MDNode>(MD)) - assert(MDN->isResolved() && - "Flushing Placeholder while cycles aren't resolved"); -#endif - PHs.front().replaceUseWith(MD); - PHs.pop_front(); - } -} - -} // anonynous namespace - -static Error error(const Twine &Message) { - return make_error<StringError>( - Message, make_error_code(BitcodeError::CorruptedBitcode)); -} - -class MetadataLoader::MetadataLoaderImpl { - BitcodeReaderMetadataList MetadataList; - BitcodeReaderValueList &ValueList; - BitstreamCursor &Stream; - LLVMContext &Context; - Module &TheModule; - std::function<Type *(unsigned)> getTypeByID; - - /// Cursor associated with the lazy-loading of Metadata. This is the easy way - /// to keep around the right "context" (Abbrev list) to be able to jump in - /// the middle of the metadata block and load any record. - BitstreamCursor IndexCursor; - - /// Index that keeps track of MDString values. - std::vector<StringRef> MDStringRef; - - /// On-demand loading of a single MDString. Requires the index above to be - /// populated. - MDString *lazyLoadOneMDString(unsigned Idx); - - /// Index that keeps track of where to find a metadata record in the stream. - std::vector<uint64_t> GlobalMetadataBitPosIndex; - - /// Populate the index above to enable lazily loading of metadata, and load - /// the named metadata as well as the transitively referenced global - /// Metadata. - Expected<bool> lazyLoadModuleMetadataBlock(); - - /// On-demand loading of a single metadata. Requires the index above to be - /// populated. - void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders); - - // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to - // point from SP to CU after a block is completly parsed. - std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms; - - /// Functions that need to be matched with subprograms when upgrading old - /// metadata. - SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs; - - // Map the bitcode's custom MDKind ID to the Module's MDKind ID. - DenseMap<unsigned, unsigned> MDKindMap; - - bool StripTBAA = false; - bool HasSeenOldLoopTags = false; - bool NeedUpgradeToDIGlobalVariableExpression = false; - bool NeedDeclareExpressionUpgrade = false; - - /// True if metadata is being parsed for a module being ThinLTO imported. - bool IsImporting = false; - - Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code, - PlaceholderQueue &Placeholders, StringRef Blob, - unsigned &NextMetadataNo); - Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob, - function_ref<void(StringRef)> CallBack); - Error parseGlobalObjectAttachment(GlobalObject &GO, - ArrayRef<uint64_t> Record); - Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record); - - void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders); - - /// Upgrade old-style CU <-> SP pointers to point from SP to CU. - void upgradeCUSubprograms() { - for (auto CU_SP : CUSubprograms) - if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second)) - for (auto &Op : SPs->operands()) - if (auto *SP = dyn_cast_or_null<DISubprogram>(Op)) - SP->replaceUnit(CU_SP.first); - CUSubprograms.clear(); - } - - /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions. - void upgradeCUVariables() { - if (!NeedUpgradeToDIGlobalVariableExpression) - return; - - // Upgrade list of variables attached to the CUs. - if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu")) - for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) { - auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I)); - if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables())) - for (unsigned I = 0; I < GVs->getNumOperands(); I++) - if (auto *GV = - dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) { - auto *DGVE = DIGlobalVariableExpression::getDistinct( - Context, GV, DIExpression::get(Context, {})); - GVs->replaceOperandWith(I, DGVE); - } - } - - // Upgrade variables attached to globals. - for (auto &GV : TheModule.globals()) { - SmallVector<MDNode *, 1> MDs; - GV.getMetadata(LLVMContext::MD_dbg, MDs); - GV.eraseMetadata(LLVMContext::MD_dbg); - for (auto *MD : MDs) - if (auto *DGV = dyn_cast_or_null<DIGlobalVariable>(MD)) { - auto *DGVE = DIGlobalVariableExpression::getDistinct( - Context, DGV, DIExpression::get(Context, {})); - GV.addMetadata(LLVMContext::MD_dbg, *DGVE); - } else - GV.addMetadata(LLVMContext::MD_dbg, *MD); - } - } - - /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that - /// describes a function argument. - void upgradeDeclareExpressions(Function &F) { - if (!NeedDeclareExpressionUpgrade) - return; - - for (auto &BB : F) - for (auto &I : BB) - if (auto *DDI = dyn_cast<DbgDeclareInst>(&I)) - if (auto *DIExpr = DDI->getExpression()) - if (DIExpr->startsWithDeref() && - dyn_cast_or_null<Argument>(DDI->getAddress())) { - SmallVector<uint64_t, 8> Ops; - Ops.append(std::next(DIExpr->elements_begin()), - DIExpr->elements_end()); - auto *E = DIExpression::get(Context, Ops); - DDI->setOperand(2, MetadataAsValue::get(Context, E)); - } - } - - /// Upgrade the expression from previous versions. - Error upgradeDIExpression(uint64_t FromVersion, - MutableArrayRef<uint64_t> &Expr, - SmallVectorImpl<uint64_t> &Buffer) { - auto N = Expr.size(); - switch (FromVersion) { - default: - return error("Invalid record"); - case 0: - if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece) - Expr[N - 3] = dwarf::DW_OP_LLVM_fragment; - LLVM_FALLTHROUGH; - case 1: - // Move DW_OP_deref to the end. - if (N && Expr[0] == dwarf::DW_OP_deref) { - auto End = Expr.end(); - if (Expr.size() >= 3 && - *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment) - End = std::prev(End, 3); - std::move(std::next(Expr.begin()), End, Expr.begin()); - *std::prev(End) = dwarf::DW_OP_deref; - } - NeedDeclareExpressionUpgrade = true; - LLVM_FALLTHROUGH; - case 2: { - // Change DW_OP_plus to DW_OP_plus_uconst. - // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus - auto SubExpr = ArrayRef<uint64_t>(Expr); - while (!SubExpr.empty()) { - // Skip past other operators with their operands - // for this version of the IR, obtained from - // from historic DIExpression::ExprOperand::getSize(). - size_t HistoricSize; - switch (SubExpr.front()) { - default: - HistoricSize = 1; - break; - case dwarf::DW_OP_constu: - case dwarf::DW_OP_minus: - case dwarf::DW_OP_plus: - HistoricSize = 2; - break; - case dwarf::DW_OP_LLVM_fragment: - HistoricSize = 3; - break; - } - - // If the expression is malformed, make sure we don't - // copy more elements than we should. - HistoricSize = std::min(SubExpr.size(), HistoricSize); - ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1); - - switch (SubExpr.front()) { - case dwarf::DW_OP_plus: - Buffer.push_back(dwarf::DW_OP_plus_uconst); - Buffer.append(Args.begin(), Args.end()); - break; - case dwarf::DW_OP_minus: - Buffer.push_back(dwarf::DW_OP_constu); - Buffer.append(Args.begin(), Args.end()); - Buffer.push_back(dwarf::DW_OP_minus); - break; - default: - Buffer.push_back(*SubExpr.begin()); - Buffer.append(Args.begin(), Args.end()); - break; - } - - // Continue with remaining elements. - SubExpr = SubExpr.slice(HistoricSize); - } - Expr = MutableArrayRef<uint64_t>(Buffer); - LLVM_FALLTHROUGH; - } - case 3: - // Up-to-date! - break; - } - - return Error::success(); - } - - void upgradeDebugInfo() { - upgradeCUSubprograms(); - upgradeCUVariables(); - } - -public: - MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule, - BitcodeReaderValueList &ValueList, - std::function<Type *(unsigned)> getTypeByID, - bool IsImporting) - : MetadataList(TheModule.getContext(), Stream.SizeInBytes()), - ValueList(ValueList), Stream(Stream), Context(TheModule.getContext()), - TheModule(TheModule), getTypeByID(std::move(getTypeByID)), - IsImporting(IsImporting) {} - - Error parseMetadata(bool ModuleLevel); - - bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); } - - Metadata *getMetadataFwdRefOrLoad(unsigned ID) { - if (ID < MDStringRef.size()) - return lazyLoadOneMDString(ID); - if (auto *MD = MetadataList.lookup(ID)) - return MD; - // If lazy-loading is enabled, we try recursively to load the operand - // instead of creating a temporary. - if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) { - PlaceholderQueue Placeholders; - lazyLoadOneMetadata(ID, Placeholders); - resolveForwardRefsAndPlaceholders(Placeholders); - return MetadataList.lookup(ID); - } - return MetadataList.getMetadataFwdRef(ID); - } - - DISubprogram *lookupSubprogramForFunction(Function *F) { - return FunctionsWithSPs.lookup(F); - } - - bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; } - - Error parseMetadataAttachment( - Function &F, const SmallVectorImpl<Instruction *> &InstructionList); - - Error parseMetadataKinds(); - - void setStripTBAA(bool Value) { StripTBAA = Value; } - bool isStrippingTBAA() { return StripTBAA; } - - unsigned size() const { return MetadataList.size(); } - void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); } - void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); } -}; - -Expected<bool> -MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() { - IndexCursor = Stream; - SmallVector<uint64_t, 64> Record; - // Get the abbrevs, and preload record positions to make them lazy-loadable. - while (true) { - Expected<BitstreamEntry> MaybeEntry = IndexCursor.advanceSkippingSubblocks( - BitstreamCursor::AF_DontPopBlockAtEnd); - if (!MaybeEntry) - return MaybeEntry.takeError(); - BitstreamEntry Entry = MaybeEntry.get(); - - switch (Entry.Kind) { - case BitstreamEntry::SubBlock: // Handled for us already. - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: { - return true; - } - case BitstreamEntry::Record: { - // The interesting case. - ++NumMDRecordLoaded; - uint64_t CurrentPos = IndexCursor.GetCurrentBitNo(); - Expected<unsigned> MaybeCode = IndexCursor.skipRecord(Entry.ID); - if (!MaybeCode) - return MaybeCode.takeError(); - unsigned Code = MaybeCode.get(); - switch (Code) { - case bitc::METADATA_STRINGS: { - // Rewind and parse the strings. - if (Error Err = IndexCursor.JumpToBit(CurrentPos)) - return std::move(Err); - StringRef Blob; - Record.clear(); - if (Expected<unsigned> MaybeRecord = - IndexCursor.readRecord(Entry.ID, Record, &Blob)) - ; - else - return MaybeRecord.takeError(); - unsigned NumStrings = Record[0]; - MDStringRef.reserve(NumStrings); - auto IndexNextMDString = [&](StringRef Str) { - MDStringRef.push_back(Str); - }; - if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString)) - return std::move(Err); - break; - } - case bitc::METADATA_INDEX_OFFSET: { - // This is the offset to the index, when we see this we skip all the - // records and load only an index to these. - if (Error Err = IndexCursor.JumpToBit(CurrentPos)) - return std::move(Err); - Record.clear(); - if (Expected<unsigned> MaybeRecord = - IndexCursor.readRecord(Entry.ID, Record)) - ; - else - return MaybeRecord.takeError(); - if (Record.size() != 2) - return error("Invalid record"); - auto Offset = Record[0] + (Record[1] << 32); - auto BeginPos = IndexCursor.GetCurrentBitNo(); - if (Error Err = IndexCursor.JumpToBit(BeginPos + Offset)) - return std::move(Err); - Expected<BitstreamEntry> MaybeEntry = - IndexCursor.advanceSkippingSubblocks( - BitstreamCursor::AF_DontPopBlockAtEnd); - if (!MaybeEntry) - return MaybeEntry.takeError(); - Entry = MaybeEntry.get(); - assert(Entry.Kind == BitstreamEntry::Record && - "Corrupted bitcode: Expected `Record` when trying to find the " - "Metadata index"); - Record.clear(); - if (Expected<unsigned> MaybeCode = - IndexCursor.readRecord(Entry.ID, Record)) - assert(MaybeCode.get() == bitc::METADATA_INDEX && - "Corrupted bitcode: Expected `METADATA_INDEX` when trying to " - "find the Metadata index"); - else - return MaybeCode.takeError(); - // Delta unpack - auto CurrentValue = BeginPos; - GlobalMetadataBitPosIndex.reserve(Record.size()); - for (auto &Elt : Record) { - CurrentValue += Elt; - GlobalMetadataBitPosIndex.push_back(CurrentValue); - } - break; - } - case bitc::METADATA_INDEX: - // We don't expect to get there, the Index is loaded when we encounter - // the offset. - return error("Corrupted Metadata block"); - case bitc::METADATA_NAME: { - // Named metadata need to be materialized now and aren't deferred. - if (Error Err = IndexCursor.JumpToBit(CurrentPos)) - return std::move(Err); - Record.clear(); - - unsigned Code; - if (Expected<unsigned> MaybeCode = - IndexCursor.readRecord(Entry.ID, Record)) { - Code = MaybeCode.get(); - assert(Code == bitc::METADATA_NAME); - } else - return MaybeCode.takeError(); - - // Read name of the named metadata. - SmallString<8> Name(Record.begin(), Record.end()); - if (Expected<unsigned> MaybeCode = IndexCursor.ReadCode()) - Code = MaybeCode.get(); - else - return MaybeCode.takeError(); - - // Named Metadata comes in two parts, we expect the name to be followed - // by the node - Record.clear(); - if (Expected<unsigned> MaybeNextBitCode = - IndexCursor.readRecord(Code, Record)) - assert(MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE); - else - return MaybeNextBitCode.takeError(); - - // Read named metadata elements. - unsigned Size = Record.size(); - NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name); - for (unsigned i = 0; i != Size; ++i) { - // FIXME: We could use a placeholder here, however NamedMDNode are - // taking MDNode as operand and not using the Metadata infrastructure. - // It is acknowledged by 'TODO: Inherit from Metadata' in the - // NamedMDNode class definition. - MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]); - assert(MD && "Invalid metadata: expect fwd ref to MDNode"); - NMD->addOperand(MD); - } - break; - } - case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: { - // FIXME: we need to do this early because we don't materialize global - // value explicitly. - if (Error Err = IndexCursor.JumpToBit(CurrentPos)) - return std::move(Err); - Record.clear(); - if (Expected<unsigned> MaybeRecord = - IndexCursor.readRecord(Entry.ID, Record)) - ; - else - return MaybeRecord.takeError(); - if (Record.size() % 2 == 0) - return error("Invalid record"); - unsigned ValueID = Record[0]; - if (ValueID >= ValueList.size()) - return error("Invalid record"); - if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) - if (Error Err = parseGlobalObjectAttachment( - *GO, ArrayRef<uint64_t>(Record).slice(1))) - return std::move(Err); - break; - } - case bitc::METADATA_KIND: - case bitc::METADATA_STRING_OLD: - case bitc::METADATA_OLD_FN_NODE: - case bitc::METADATA_OLD_NODE: - case bitc::METADATA_VALUE: - case bitc::METADATA_DISTINCT_NODE: - case bitc::METADATA_NODE: - case bitc::METADATA_LOCATION: - case bitc::METADATA_GENERIC_DEBUG: - case bitc::METADATA_SUBRANGE: - case bitc::METADATA_ENUMERATOR: - case bitc::METADATA_BASIC_TYPE: - case bitc::METADATA_DERIVED_TYPE: - case bitc::METADATA_COMPOSITE_TYPE: - case bitc::METADATA_SUBROUTINE_TYPE: - case bitc::METADATA_MODULE: - case bitc::METADATA_FILE: - case bitc::METADATA_COMPILE_UNIT: - case bitc::METADATA_SUBPROGRAM: - case bitc::METADATA_LEXICAL_BLOCK: - case bitc::METADATA_LEXICAL_BLOCK_FILE: - case bitc::METADATA_NAMESPACE: - case bitc::METADATA_COMMON_BLOCK: - case bitc::METADATA_MACRO: - case bitc::METADATA_MACRO_FILE: - case bitc::METADATA_TEMPLATE_TYPE: - case bitc::METADATA_TEMPLATE_VALUE: - case bitc::METADATA_GLOBAL_VAR: - case bitc::METADATA_LOCAL_VAR: - case bitc::METADATA_LABEL: - case bitc::METADATA_EXPRESSION: - case bitc::METADATA_OBJC_PROPERTY: - case bitc::METADATA_IMPORTED_ENTITY: - case bitc::METADATA_GLOBAL_VAR_EXPR: - // We don't expect to see any of these, if we see one, give up on - // lazy-loading and fallback. - MDStringRef.clear(); - GlobalMetadataBitPosIndex.clear(); - return false; - } - break; - } - } - } -} - -/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing -/// module level metadata. -Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) { - if (!ModuleLevel && MetadataList.hasFwdRefs()) - return error("Invalid metadata: fwd refs into function blocks"); - - // Record the entry position so that we can jump back here and efficiently - // skip the whole block in case we lazy-load. - auto EntryPos = Stream.GetCurrentBitNo(); - - if (Error Err = Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) - return Err; - - SmallVector<uint64_t, 64> Record; - PlaceholderQueue Placeholders; - - // We lazy-load module-level metadata: we build an index for each record, and - // then load individual record as needed, starting with the named metadata. - if (ModuleLevel && IsImporting && MetadataList.empty() && - !DisableLazyLoading) { - auto SuccessOrErr = lazyLoadModuleMetadataBlock(); - if (!SuccessOrErr) - return SuccessOrErr.takeError(); - if (SuccessOrErr.get()) { - // An index was successfully created and we will be able to load metadata - // on-demand. - MetadataList.resize(MDStringRef.size() + - GlobalMetadataBitPosIndex.size()); - - // Reading the named metadata created forward references and/or - // placeholders, that we flush here. - resolveForwardRefsAndPlaceholders(Placeholders); - upgradeDebugInfo(); - // Return at the beginning of the block, since it is easy to skip it - // entirely from there. - Stream.ReadBlockEnd(); // Pop the abbrev block context. - if (Error Err = IndexCursor.JumpToBit(EntryPos)) - return Err; - if (Error Err = Stream.SkipBlock()) { - // FIXME this drops the error on the floor, which - // ThinLTO/X86/debuginfo-cu-import.ll relies on. - consumeError(std::move(Err)); - return Error::success(); - } - return Error::success(); - } - // Couldn't load an index, fallback to loading all the block "old-style". - } - - unsigned NextMetadataNo = MetadataList.size(); - - // Read all the records. - while (true) { - Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks(); - if (!MaybeEntry) - return MaybeEntry.takeError(); - BitstreamEntry Entry = MaybeEntry.get(); - - switch (Entry.Kind) { - case BitstreamEntry::SubBlock: // Handled for us already. - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: - resolveForwardRefsAndPlaceholders(Placeholders); - upgradeDebugInfo(); - return Error::success(); - case BitstreamEntry::Record: - // The interesting case. - break; - } - - // Read a record. - Record.clear(); - StringRef Blob; - ++NumMDRecordLoaded; - if (Expected<unsigned> MaybeCode = - Stream.readRecord(Entry.ID, Record, &Blob)) { - if (Error Err = parseOneMetadata(Record, MaybeCode.get(), Placeholders, - Blob, NextMetadataNo)) - return Err; - } else - return MaybeCode.takeError(); - } -} - -MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) { - ++NumMDStringLoaded; - if (Metadata *MD = MetadataList.lookup(ID)) - return cast<MDString>(MD); - auto MDS = MDString::get(Context, MDStringRef[ID]); - MetadataList.assignValue(MDS, ID); - return MDS; -} - -void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata( - unsigned ID, PlaceholderQueue &Placeholders) { - assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size()); - assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString"); - // Lookup first if the metadata hasn't already been loaded. - if (auto *MD = MetadataList.lookup(ID)) { - auto *N = dyn_cast_or_null<MDNode>(MD); - if (!N->isTemporary()) - return; - } - SmallVector<uint64_t, 64> Record; - StringRef Blob; - if (Error Err = IndexCursor.JumpToBit( - GlobalMetadataBitPosIndex[ID - MDStringRef.size()])) - report_fatal_error("lazyLoadOneMetadata failed jumping: " + - toString(std::move(Err))); - Expected<BitstreamEntry> MaybeEntry = IndexCursor.advanceSkippingSubblocks(); - if (!MaybeEntry) - // FIXME this drops the error on the floor. - report_fatal_error("lazyLoadOneMetadata failed advanceSkippingSubblocks: " + - toString(MaybeEntry.takeError())); - BitstreamEntry Entry = MaybeEntry.get(); - ++NumMDRecordLoaded; - if (Expected<unsigned> MaybeCode = - IndexCursor.readRecord(Entry.ID, Record, &Blob)) { - if (Error Err = - parseOneMetadata(Record, MaybeCode.get(), Placeholders, Blob, ID)) - report_fatal_error("Can't lazyload MD, parseOneMetadata: " + - toString(std::move(Err))); - } else - report_fatal_error("Can't lazyload MD: " + toString(MaybeCode.takeError())); -} - -/// Ensure that all forward-references and placeholders are resolved. -/// Iteratively lazy-loading metadata on-demand if needed. -void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders( - PlaceholderQueue &Placeholders) { - DenseSet<unsigned> Temporaries; - while (1) { - // Populate Temporaries with the placeholders that haven't been loaded yet. - Placeholders.getTemporaries(MetadataList, Temporaries); - - // If we don't have any temporary, or FwdReference, we're done! - if (Temporaries.empty() && !MetadataList.hasFwdRefs()) - break; - - // First, load all the temporaries. This can add new placeholders or - // forward references. - for (auto ID : Temporaries) - lazyLoadOneMetadata(ID, Placeholders); - Temporaries.clear(); - - // Second, load the forward-references. This can also add new placeholders - // or forward references. - while (MetadataList.hasFwdRefs()) - lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders); - } - // At this point we don't have any forward reference remaining, or temporary - // that haven't been loaded. We can safely drop RAUW support and mark cycles - // as resolved. - MetadataList.tryToResolveCycles(); - - // Finally, everything is in place, we can replace the placeholders operands - // with the final node they refer to. - Placeholders.flush(MetadataList); -} - -Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata( - SmallVectorImpl<uint64_t> &Record, unsigned Code, - PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) { - - bool IsDistinct = false; - auto getMD = [&](unsigned ID) -> Metadata * { - if (ID < MDStringRef.size()) - return lazyLoadOneMDString(ID); - if (!IsDistinct) { - if (auto *MD = MetadataList.lookup(ID)) - return MD; - // If lazy-loading is enabled, we try recursively to load the operand - // instead of creating a temporary. - if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) { - // Create a temporary for the node that is referencing the operand we - // will lazy-load. It is needed before recursing in case there are - // uniquing cycles. - MetadataList.getMetadataFwdRef(NextMetadataNo); - lazyLoadOneMetadata(ID, Placeholders); - return MetadataList.lookup(ID); - } - // Return a temporary. - return MetadataList.getMetadataFwdRef(ID); - } - if (auto *MD = MetadataList.getMetadataIfResolved(ID)) - return MD; - return &Placeholders.getPlaceholderOp(ID); - }; - auto getMDOrNull = [&](unsigned ID) -> Metadata * { - if (ID) - return getMD(ID - 1); - return nullptr; - }; - auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * { - if (ID) - return MetadataList.getMetadataFwdRef(ID - 1); - return nullptr; - }; - auto getMDString = [&](unsigned ID) -> MDString * { - // This requires that the ID is not really a forward reference. In - // particular, the MDString must already have been resolved. - auto MDS = getMDOrNull(ID); - return cast_or_null<MDString>(MDS); - }; - - // Support for old type refs. - auto getDITypeRefOrNull = [&](unsigned ID) { - return MetadataList.upgradeTypeRef(getMDOrNull(ID)); - }; - -#define GET_OR_DISTINCT(CLASS, ARGS) \ - (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS) - - switch (Code) { - default: // Default behavior: ignore. - break; - case bitc::METADATA_NAME: { - // Read name of the named metadata. - SmallString<8> Name(Record.begin(), Record.end()); - Record.clear(); - Expected<unsigned> MaybeCode = Stream.ReadCode(); - if (!MaybeCode) - return MaybeCode.takeError(); - Code = MaybeCode.get(); - - ++NumMDRecordLoaded; - if (Expected<unsigned> MaybeNextBitCode = Stream.readRecord(Code, Record)) { - if (MaybeNextBitCode.get() != bitc::METADATA_NAMED_NODE) - return error("METADATA_NAME not followed by METADATA_NAMED_NODE"); - } else - return MaybeNextBitCode.takeError(); - - // Read named metadata elements. - unsigned Size = Record.size(); - NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name); - for (unsigned i = 0; i != Size; ++i) { - MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]); - if (!MD) - return error("Invalid named metadata: expect fwd ref to MDNode"); - NMD->addOperand(MD); - } - break; - } - case bitc::METADATA_OLD_FN_NODE: { - // FIXME: Remove in 4.0. - // This is a LocalAsMetadata record, the only type of function-local - // metadata. - if (Record.size() % 2 == 1) - return error("Invalid record"); - - // If this isn't a LocalAsMetadata record, we're dropping it. This used - // to be legal, but there's no upgrade path. - auto dropRecord = [&] { - MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo); - NextMetadataNo++; - }; - if (Record.size() != 2) { - dropRecord(); - break; - } - - Type *Ty = getTypeByID(Record[0]); - if (Ty->isMetadataTy() || Ty->isVoidTy()) { - dropRecord(); - break; - } - - MetadataList.assignValue( - LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_OLD_NODE: { - // FIXME: Remove in 4.0. - if (Record.size() % 2 == 1) - return error("Invalid record"); - - unsigned Size = Record.size(); - SmallVector<Metadata *, 8> Elts; - for (unsigned i = 0; i != Size; i += 2) { - Type *Ty = getTypeByID(Record[i]); - if (!Ty) - return error("Invalid record"); - if (Ty->isMetadataTy()) - Elts.push_back(getMD(Record[i + 1])); - else if (!Ty->isVoidTy()) { - auto *MD = - ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty)); - assert(isa<ConstantAsMetadata>(MD) && - "Expected non-function-local metadata"); - Elts.push_back(MD); - } else - Elts.push_back(nullptr); - } - MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_VALUE: { - if (Record.size() != 2) - return error("Invalid record"); - - Type *Ty = getTypeByID(Record[0]); - if (Ty->isMetadataTy() || Ty->isVoidTy()) - return error("Invalid record"); - - MetadataList.assignValue( - ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_DISTINCT_NODE: - IsDistinct = true; - LLVM_FALLTHROUGH; - case bitc::METADATA_NODE: { - SmallVector<Metadata *, 8> Elts; - Elts.reserve(Record.size()); - for (unsigned ID : Record) - Elts.push_back(getMDOrNull(ID)); - MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts) - : MDNode::get(Context, Elts), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_LOCATION: { - if (Record.size() != 5 && Record.size() != 6) - return error("Invalid record"); - - IsDistinct = Record[0]; - unsigned Line = Record[1]; - unsigned Column = Record[2]; - Metadata *Scope = getMD(Record[3]); - Metadata *InlinedAt = getMDOrNull(Record[4]); - bool ImplicitCode = Record.size() == 6 && Record[5]; - MetadataList.assignValue( - GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt, - ImplicitCode)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_GENERIC_DEBUG: { - if (Record.size() < 4) - return error("Invalid record"); - - IsDistinct = Record[0]; - unsigned Tag = Record[1]; - unsigned Version = Record[2]; - - if (Tag >= 1u << 16 || Version != 0) - return error("Invalid record"); - - auto *Header = getMDString(Record[3]); - SmallVector<Metadata *, 8> DwarfOps; - for (unsigned I = 4, E = Record.size(); I != E; ++I) - DwarfOps.push_back(getMDOrNull(Record[I])); - MetadataList.assignValue( - GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_SUBRANGE: { - Metadata *Val = nullptr; - // Operand 'count' is interpreted as: - // - Signed integer (version 0) - // - Metadata node (version 1) - switch (Record[0] >> 1) { - case 0: - Val = GET_OR_DISTINCT(DISubrange, - (Context, Record[1], unrotateSign(Record.back()))); - break; - case 1: - Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]), - unrotateSign(Record.back()))); - break; - default: - return error("Invalid record: Unsupported version of DISubrange"); - } - - MetadataList.assignValue(Val, NextMetadataNo); - IsDistinct = Record[0] & 1; - NextMetadataNo++; - break; - } - case bitc::METADATA_ENUMERATOR: { - if (Record.size() != 3) - return error("Invalid record"); - - IsDistinct = Record[0] & 1; - bool IsUnsigned = Record[0] & 2; - MetadataList.assignValue( - GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]), - IsUnsigned, getMDString(Record[2]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_BASIC_TYPE: { - if (Record.size() < 6 || Record.size() > 7) - return error("Invalid record"); - - IsDistinct = Record[0]; - DINode::DIFlags Flags = (Record.size() > 6) ? - static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero; - - MetadataList.assignValue( - GET_OR_DISTINCT(DIBasicType, - (Context, Record[1], getMDString(Record[2]), Record[3], - Record[4], Record[5], Flags)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_DERIVED_TYPE: { - if (Record.size() < 12 || Record.size() > 13) - return error("Invalid record"); - - // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means - // that there is no DWARF address space associated with DIDerivedType. - Optional<unsigned> DWARFAddressSpace; - if (Record.size() > 12 && Record[12]) - DWARFAddressSpace = Record[12] - 1; - - IsDistinct = Record[0]; - DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]); - MetadataList.assignValue( - GET_OR_DISTINCT(DIDerivedType, - (Context, Record[1], getMDString(Record[2]), - getMDOrNull(Record[3]), Record[4], - getDITypeRefOrNull(Record[5]), - getDITypeRefOrNull(Record[6]), Record[7], Record[8], - Record[9], DWARFAddressSpace, Flags, - getDITypeRefOrNull(Record[11]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_COMPOSITE_TYPE: { - if (Record.size() < 16 || Record.size() > 17) - return error("Invalid record"); - - // If we have a UUID and this is not a forward declaration, lookup the - // mapping. - IsDistinct = Record[0] & 0x1; - bool IsNotUsedInTypeRef = Record[0] >= 2; - unsigned Tag = Record[1]; - MDString *Name = getMDString(Record[2]); - Metadata *File = getMDOrNull(Record[3]); - unsigned Line = Record[4]; - Metadata *Scope = getDITypeRefOrNull(Record[5]); - Metadata *BaseType = nullptr; - uint64_t SizeInBits = Record[7]; - if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max()) - return error("Alignment value is too large"); - uint32_t AlignInBits = Record[8]; - uint64_t OffsetInBits = 0; - DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]); - Metadata *Elements = nullptr; - unsigned RuntimeLang = Record[12]; - Metadata *VTableHolder = nullptr; - Metadata *TemplateParams = nullptr; - Metadata *Discriminator = nullptr; - auto *Identifier = getMDString(Record[15]); - // If this module is being parsed so that it can be ThinLTO imported - // into another module, composite types only need to be imported - // as type declarations (unless full type definitions requested). - // Create type declarations up front to save memory. Also, buildODRType - // handles the case where this is type ODRed with a definition needed - // by the importing module, in which case the existing definition is - // used. - if (IsImporting && !ImportFullTypeDefinitions && Identifier && - (Tag == dwarf::DW_TAG_enumeration_type || - Tag == dwarf::DW_TAG_class_type || - Tag == dwarf::DW_TAG_structure_type || - Tag == dwarf::DW_TAG_union_type)) { - Flags = Flags | DINode::FlagFwdDecl; - } else { - BaseType = getDITypeRefOrNull(Record[6]); - OffsetInBits = Record[9]; - Elements = getMDOrNull(Record[11]); - VTableHolder = getDITypeRefOrNull(Record[13]); - TemplateParams = getMDOrNull(Record[14]); - if (Record.size() > 16) - Discriminator = getMDOrNull(Record[16]); - } - DICompositeType *CT = nullptr; - if (Identifier) - CT = DICompositeType::buildODRType( - Context, *Identifier, Tag, Name, File, Line, Scope, BaseType, - SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, - VTableHolder, TemplateParams, Discriminator); - - // Create a node if we didn't get a lazy ODR type. - if (!CT) - CT = GET_OR_DISTINCT(DICompositeType, - (Context, Tag, Name, File, Line, Scope, BaseType, - SizeInBits, AlignInBits, OffsetInBits, Flags, - Elements, RuntimeLang, VTableHolder, TemplateParams, - Identifier, Discriminator)); - if (!IsNotUsedInTypeRef && Identifier) - MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT)); - - MetadataList.assignValue(CT, NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_SUBROUTINE_TYPE: { - if (Record.size() < 3 || Record.size() > 4) - return error("Invalid record"); - bool IsOldTypeRefArray = Record[0] < 2; - unsigned CC = (Record.size() > 3) ? Record[3] : 0; - - IsDistinct = Record[0] & 0x1; - DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]); - Metadata *Types = getMDOrNull(Record[2]); - if (LLVM_UNLIKELY(IsOldTypeRefArray)) - Types = MetadataList.upgradeTypeRefArray(Types); - - MetadataList.assignValue( - GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)), - NextMetadataNo); - NextMetadataNo++; - break; - } - - case bitc::METADATA_MODULE: { - if (Record.size() != 6) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue( - GET_OR_DISTINCT(DIModule, - (Context, getMDOrNull(Record[1]), - getMDString(Record[2]), getMDString(Record[3]), - getMDString(Record[4]), getMDString(Record[5]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - - case bitc::METADATA_FILE: { - if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6) - return error("Invalid record"); - - IsDistinct = Record[0]; - Optional<DIFile::ChecksumInfo<MDString *>> Checksum; - // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum - // is not present. This matches up with the old internal representation, - // and the old encoding for CSK_None in the ChecksumKind. The new - // representation reserves the value 0 in the ChecksumKind to continue to - // encode None in a backwards-compatible way. - if (Record.size() > 4 && Record[3] && Record[4]) - Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]), - getMDString(Record[4])); - MetadataList.assignValue( - GET_OR_DISTINCT( - DIFile, - (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum, - Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5])) - : None)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_COMPILE_UNIT: { - if (Record.size() < 14 || Record.size() > 19) - return error("Invalid record"); - - // Ignore Record[0], which indicates whether this compile unit is - // distinct. It's always distinct. - IsDistinct = true; - auto *CU = DICompileUnit::getDistinct( - Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]), - Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]), - Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]), - getMDOrNull(Record[12]), getMDOrNull(Record[13]), - Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]), - Record.size() <= 14 ? 0 : Record[14], - Record.size() <= 16 ? true : Record[16], - Record.size() <= 17 ? false : Record[17], - Record.size() <= 18 ? 0 : Record[18], - Record.size() <= 19 ? 0 : Record[19]); - - MetadataList.assignValue(CU, NextMetadataNo); - NextMetadataNo++; - - // Move the Upgrade the list of subprograms. - if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11])) - CUSubprograms.push_back({CU, SPs}); - break; - } - case bitc::METADATA_SUBPROGRAM: { - if (Record.size() < 18 || Record.size() > 21) - return error("Invalid record"); - - bool HasSPFlags = Record[0] & 4; - - DINode::DIFlags Flags; - DISubprogram::DISPFlags SPFlags; - if (!HasSPFlags) - Flags = static_cast<DINode::DIFlags>(Record[11 + 2]); - else { - Flags = static_cast<DINode::DIFlags>(Record[11]); - SPFlags = static_cast<DISubprogram::DISPFlags>(Record[9]); - } - - // Support for old metadata when - // subprogram specific flags are placed in DIFlags. - const unsigned DIFlagMainSubprogram = 1 << 21; - bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram; - if (HasOldMainSubprogramFlag) - // Remove old DIFlagMainSubprogram from DIFlags. - // Note: This assumes that any future use of bit 21 defaults to it - // being 0. - Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram); - - if (HasOldMainSubprogramFlag && HasSPFlags) - SPFlags |= DISubprogram::SPFlagMainSubprogram; - else if (!HasSPFlags) - SPFlags = DISubprogram::toSPFlags( - /*IsLocalToUnit=*/Record[7], /*IsDefinition=*/Record[8], - /*IsOptimized=*/Record[14], /*Virtuality=*/Record[11], - /*DIFlagMainSubprogram*/HasOldMainSubprogramFlag); - - // All definitions should be distinct. - IsDistinct = (Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition); - // Version 1 has a Function as Record[15]. - // Version 2 has removed Record[15]. - // Version 3 has the Unit as Record[15]. - // Version 4 added thisAdjustment. - // Version 5 repacked flags into DISPFlags, changing many element numbers. - bool HasUnit = Record[0] & 2; - if (!HasSPFlags && HasUnit && Record.size() < 19) - return error("Invalid record"); - if (HasSPFlags && !HasUnit) - return error("Invalid record"); - // Accommodate older formats. - bool HasFn = false; - bool HasThisAdj = true; - bool HasThrownTypes = true; - unsigned OffsetA = 0; - unsigned OffsetB = 0; - if (!HasSPFlags) { - OffsetA = 2; - OffsetB = 2; - if (Record.size() >= 19) { - HasFn = !HasUnit; - OffsetB++; - } - HasThisAdj = Record.size() >= 20; - HasThrownTypes = Record.size() >= 21; - } - Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]); - DISubprogram *SP = GET_OR_DISTINCT( - DISubprogram, - (Context, - getDITypeRefOrNull(Record[1]), // scope - getMDString(Record[2]), // name - getMDString(Record[3]), // linkageName - getMDOrNull(Record[4]), // file - Record[5], // line - getMDOrNull(Record[6]), // type - Record[7 + OffsetA], // scopeLine - getDITypeRefOrNull(Record[8 + OffsetA]), // containingType - Record[10 + OffsetA], // virtualIndex - HasThisAdj ? Record[16 + OffsetB] : 0, // thisAdjustment - Flags, // flags - SPFlags, // SPFlags - HasUnit ? CUorFn : nullptr, // unit - getMDOrNull(Record[13 + OffsetB]), // templateParams - getMDOrNull(Record[14 + OffsetB]), // declaration - getMDOrNull(Record[15 + OffsetB]), // retainedNodes - HasThrownTypes ? getMDOrNull(Record[17 + OffsetB]) - : nullptr // thrownTypes - )); - MetadataList.assignValue(SP, NextMetadataNo); - NextMetadataNo++; - - // Upgrade sp->function mapping to function->sp mapping. - if (HasFn) { - if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn)) - if (auto *F = dyn_cast<Function>(CMD->getValue())) { - if (F->isMaterializable()) - // Defer until materialized; unmaterialized functions may not have - // metadata. - FunctionsWithSPs[F] = SP; - else if (!F->empty()) - F->setSubprogram(SP); - } - } - break; - } - case bitc::METADATA_LEXICAL_BLOCK: { - if (Record.size() != 5) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue( - GET_OR_DISTINCT(DILexicalBlock, - (Context, getMDOrNull(Record[1]), - getMDOrNull(Record[2]), Record[3], Record[4])), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_LEXICAL_BLOCK_FILE: { - if (Record.size() != 4) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue( - GET_OR_DISTINCT(DILexicalBlockFile, - (Context, getMDOrNull(Record[1]), - getMDOrNull(Record[2]), Record[3])), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_COMMON_BLOCK: { - IsDistinct = Record[0] & 1; - MetadataList.assignValue( - GET_OR_DISTINCT(DICommonBlock, - (Context, getMDOrNull(Record[1]), - getMDOrNull(Record[2]), getMDString(Record[3]), - getMDOrNull(Record[4]), Record[5])), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_NAMESPACE: { - // Newer versions of DINamespace dropped file and line. - MDString *Name; - if (Record.size() == 3) - Name = getMDString(Record[2]); - else if (Record.size() == 5) - Name = getMDString(Record[3]); - else - return error("Invalid record"); - - IsDistinct = Record[0] & 1; - bool ExportSymbols = Record[0] & 2; - MetadataList.assignValue( - GET_OR_DISTINCT(DINamespace, - (Context, getMDOrNull(Record[1]), Name, ExportSymbols)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_MACRO: { - if (Record.size() != 5) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue( - GET_OR_DISTINCT(DIMacro, - (Context, Record[1], Record[2], getMDString(Record[3]), - getMDString(Record[4]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_MACRO_FILE: { - if (Record.size() != 5) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue( - GET_OR_DISTINCT(DIMacroFile, - (Context, Record[1], Record[2], getMDOrNull(Record[3]), - getMDOrNull(Record[4]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_TEMPLATE_TYPE: { - if (Record.size() != 3) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter, - (Context, getMDString(Record[1]), - getDITypeRefOrNull(Record[2]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_TEMPLATE_VALUE: { - if (Record.size() != 5) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue( - GET_OR_DISTINCT(DITemplateValueParameter, - (Context, Record[1], getMDString(Record[2]), - getDITypeRefOrNull(Record[3]), - getMDOrNull(Record[4]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_GLOBAL_VAR: { - if (Record.size() < 11 || Record.size() > 13) - return error("Invalid record"); - - IsDistinct = Record[0] & 1; - unsigned Version = Record[0] >> 1; - - if (Version == 2) { - MetadataList.assignValue( - GET_OR_DISTINCT( - DIGlobalVariable, - (Context, getMDOrNull(Record[1]), getMDString(Record[2]), - getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], - getDITypeRefOrNull(Record[6]), Record[7], Record[8], - getMDOrNull(Record[9]), getMDOrNull(Record[10]), Record[11])), - NextMetadataNo); - - NextMetadataNo++; - } else if (Version == 1) { - // No upgrade necessary. A null field will be introduced to indicate - // that no parameter information is available. - MetadataList.assignValue( - GET_OR_DISTINCT(DIGlobalVariable, - (Context, getMDOrNull(Record[1]), - getMDString(Record[2]), getMDString(Record[3]), - getMDOrNull(Record[4]), Record[5], - getDITypeRefOrNull(Record[6]), Record[7], Record[8], - getMDOrNull(Record[10]), nullptr, Record[11])), - NextMetadataNo); - - NextMetadataNo++; - } else if (Version == 0) { - // Upgrade old metadata, which stored a global variable reference or a - // ConstantInt here. - NeedUpgradeToDIGlobalVariableExpression = true; - Metadata *Expr = getMDOrNull(Record[9]); - uint32_t AlignInBits = 0; - if (Record.size() > 11) { - if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max()) - return error("Alignment value is too large"); - AlignInBits = Record[11]; - } - GlobalVariable *Attach = nullptr; - if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) { - if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) { - Attach = GV; - Expr = nullptr; - } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) { - Expr = DIExpression::get(Context, - {dwarf::DW_OP_constu, CI->getZExtValue(), - dwarf::DW_OP_stack_value}); - } else { - Expr = nullptr; - } - } - DIGlobalVariable *DGV = GET_OR_DISTINCT( - DIGlobalVariable, - (Context, getMDOrNull(Record[1]), getMDString(Record[2]), - getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], - getDITypeRefOrNull(Record[6]), Record[7], Record[8], - getMDOrNull(Record[10]), nullptr, AlignInBits)); - - DIGlobalVariableExpression *DGVE = nullptr; - if (Attach || Expr) - DGVE = DIGlobalVariableExpression::getDistinct( - Context, DGV, Expr ? Expr : DIExpression::get(Context, {})); - if (Attach) - Attach->addDebugInfo(DGVE); - - auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV); - MetadataList.assignValue(MDNode, NextMetadataNo); - NextMetadataNo++; - } else - return error("Invalid record"); - - break; - } - case bitc::METADATA_LOCAL_VAR: { - // 10th field is for the obseleted 'inlinedAt:' field. - if (Record.size() < 8 || Record.size() > 10) - return error("Invalid record"); - - IsDistinct = Record[0] & 1; - bool HasAlignment = Record[0] & 2; - // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or - // DW_TAG_arg_variable, if we have alignment flag encoded it means, that - // this is newer version of record which doesn't have artificial tag. - bool HasTag = !HasAlignment && Record.size() > 8; - DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]); - uint32_t AlignInBits = 0; - if (HasAlignment) { - if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max()) - return error("Alignment value is too large"); - AlignInBits = Record[8 + HasTag]; - } - MetadataList.assignValue( - GET_OR_DISTINCT(DILocalVariable, - (Context, getMDOrNull(Record[1 + HasTag]), - getMDString(Record[2 + HasTag]), - getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag], - getDITypeRefOrNull(Record[5 + HasTag]), - Record[6 + HasTag], Flags, AlignInBits)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_LABEL: { - if (Record.size() != 5) - return error("Invalid record"); - - IsDistinct = Record[0] & 1; - MetadataList.assignValue( - GET_OR_DISTINCT(DILabel, - (Context, getMDOrNull(Record[1]), - getMDString(Record[2]), - getMDOrNull(Record[3]), Record[4])), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_EXPRESSION: { - if (Record.size() < 1) - return error("Invalid record"); - - IsDistinct = Record[0] & 1; - uint64_t Version = Record[0] >> 1; - auto Elts = MutableArrayRef<uint64_t>(Record).slice(1); - - SmallVector<uint64_t, 6> Buffer; - if (Error Err = upgradeDIExpression(Version, Elts, Buffer)) - return Err; - - MetadataList.assignValue( - GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_GLOBAL_VAR_EXPR: { - if (Record.size() != 3) - return error("Invalid record"); - - IsDistinct = Record[0]; - Metadata *Expr = getMDOrNull(Record[2]); - if (!Expr) - Expr = DIExpression::get(Context, {}); - MetadataList.assignValue( - GET_OR_DISTINCT(DIGlobalVariableExpression, - (Context, getMDOrNull(Record[1]), Expr)), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_OBJC_PROPERTY: { - if (Record.size() != 8) - return error("Invalid record"); - - IsDistinct = Record[0]; - MetadataList.assignValue( - GET_OR_DISTINCT(DIObjCProperty, - (Context, getMDString(Record[1]), - getMDOrNull(Record[2]), Record[3], - getMDString(Record[4]), getMDString(Record[5]), - Record[6], getDITypeRefOrNull(Record[7]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_IMPORTED_ENTITY: { - if (Record.size() != 6 && Record.size() != 7) - return error("Invalid record"); - - IsDistinct = Record[0]; - bool HasFile = (Record.size() == 7); - MetadataList.assignValue( - GET_OR_DISTINCT(DIImportedEntity, - (Context, Record[1], getMDOrNull(Record[2]), - getDITypeRefOrNull(Record[3]), - HasFile ? getMDOrNull(Record[6]) : nullptr, - HasFile ? Record[4] : 0, getMDString(Record[5]))), - NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_STRING_OLD: { - std::string String(Record.begin(), Record.end()); - - // Test for upgrading !llvm.loop. - HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String); - ++NumMDStringLoaded; - Metadata *MD = MDString::get(Context, String); - MetadataList.assignValue(MD, NextMetadataNo); - NextMetadataNo++; - break; - } - case bitc::METADATA_STRINGS: { - auto CreateNextMDString = [&](StringRef Str) { - ++NumMDStringLoaded; - MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo); - NextMetadataNo++; - }; - if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString)) - return Err; - break; - } - case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: { - if (Record.size() % 2 == 0) - return error("Invalid record"); - unsigned ValueID = Record[0]; - if (ValueID >= ValueList.size()) - return error("Invalid record"); - if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) - if (Error Err = parseGlobalObjectAttachment( - *GO, ArrayRef<uint64_t>(Record).slice(1))) - return Err; - break; - } - case bitc::METADATA_KIND: { - // Support older bitcode files that had METADATA_KIND records in a - // block with METADATA_BLOCK_ID. - if (Error Err = parseMetadataKindRecord(Record)) - return Err; - break; - } - } - return Error::success(); -#undef GET_OR_DISTINCT -} - -Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings( - ArrayRef<uint64_t> Record, StringRef Blob, - function_ref<void(StringRef)> CallBack) { - // All the MDStrings in the block are emitted together in a single - // record. The strings are concatenated and stored in a blob along with - // their sizes. - if (Record.size() != 2) - return error("Invalid record: metadata strings layout"); - - unsigned NumStrings = Record[0]; - unsigned StringsOffset = Record[1]; - if (!NumStrings) - return error("Invalid record: metadata strings with no strings"); - if (StringsOffset > Blob.size()) - return error("Invalid record: metadata strings corrupt offset"); - - StringRef Lengths = Blob.slice(0, StringsOffset); - SimpleBitstreamCursor R(Lengths); - - StringRef Strings = Blob.drop_front(StringsOffset); - do { - if (R.AtEndOfStream()) - return error("Invalid record: metadata strings bad length"); - - Expected<uint32_t> MaybeSize = R.ReadVBR(6); - if (!MaybeSize) - return MaybeSize.takeError(); - uint32_t Size = MaybeSize.get(); - if (Strings.size() < Size) - return error("Invalid record: metadata strings truncated chars"); - - CallBack(Strings.slice(0, Size)); - Strings = Strings.drop_front(Size); - } while (--NumStrings); - - return Error::success(); -} - -Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment( - GlobalObject &GO, ArrayRef<uint64_t> Record) { - assert(Record.size() % 2 == 0); - for (unsigned I = 0, E = Record.size(); I != E; I += 2) { - auto K = MDKindMap.find(Record[I]); - if (K == MDKindMap.end()) - return error("Invalid ID"); - MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]); - if (!MD) - return error("Invalid metadata attachment: expect fwd ref to MDNode"); - GO.addMetadata(K->second, *MD); - } - return Error::success(); -} - -/// Parse metadata attachments. -Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment( - Function &F, const SmallVectorImpl<Instruction *> &InstructionList) { - if (Error Err = Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) - return Err; - - SmallVector<uint64_t, 64> Record; - PlaceholderQueue Placeholders; - - while (true) { - Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks(); - if (!MaybeEntry) - return MaybeEntry.takeError(); - BitstreamEntry Entry = MaybeEntry.get(); - - switch (Entry.Kind) { - case BitstreamEntry::SubBlock: // Handled for us already. - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: - resolveForwardRefsAndPlaceholders(Placeholders); - return Error::success(); - case BitstreamEntry::Record: - // The interesting case. - break; - } - - // Read a metadata attachment record. - Record.clear(); - ++NumMDRecordLoaded; - Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record); - if (!MaybeRecord) - return MaybeRecord.takeError(); - switch (MaybeRecord.get()) { - default: // Default behavior: ignore. - break; - case bitc::METADATA_ATTACHMENT: { - unsigned RecordLength = Record.size(); - if (Record.empty()) - return error("Invalid record"); - if (RecordLength % 2 == 0) { - // A function attachment. - if (Error Err = parseGlobalObjectAttachment(F, Record)) - return Err; - continue; - } - - // An instruction attachment. - Instruction *Inst = InstructionList[Record[0]]; - for (unsigned i = 1; i != RecordLength; i = i + 2) { - unsigned Kind = Record[i]; - DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind); - if (I == MDKindMap.end()) - return error("Invalid ID"); - if (I->second == LLVMContext::MD_tbaa && StripTBAA) - continue; - - auto Idx = Record[i + 1]; - if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) && - !MetadataList.lookup(Idx)) { - // Load the attachment if it is in the lazy-loadable range and hasn't - // been loaded yet. - lazyLoadOneMetadata(Idx, Placeholders); - resolveForwardRefsAndPlaceholders(Placeholders); - } - - Metadata *Node = MetadataList.getMetadataFwdRef(Idx); - if (isa<LocalAsMetadata>(Node)) - // Drop the attachment. This used to be legal, but there's no - // upgrade path. - break; - MDNode *MD = dyn_cast_or_null<MDNode>(Node); - if (!MD) - return error("Invalid metadata attachment"); - - if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop) - MD = upgradeInstructionLoopAttachment(*MD); - - if (I->second == LLVMContext::MD_tbaa) { - assert(!MD->isTemporary() && "should load MDs before attachments"); - MD = UpgradeTBAANode(*MD); - } - Inst->setMetadata(I->second, MD); - } - break; - } - } - } -} - -/// Parse a single METADATA_KIND record, inserting result in MDKindMap. -Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord( - SmallVectorImpl<uint64_t> &Record) { - if (Record.size() < 2) - return error("Invalid record"); - - unsigned Kind = Record[0]; - SmallString<8> Name(Record.begin() + 1, Record.end()); - - unsigned NewKind = TheModule.getMDKindID(Name.str()); - if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) - return error("Conflicting METADATA_KIND records"); - return Error::success(); -} - -/// Parse the metadata kinds out of the METADATA_KIND_BLOCK. -Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() { - if (Error Err = Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID)) - return Err; - - SmallVector<uint64_t, 64> Record; - - // Read all the records. - while (true) { - Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks(); - if (!MaybeEntry) - return MaybeEntry.takeError(); - BitstreamEntry Entry = MaybeEntry.get(); - - switch (Entry.Kind) { - case BitstreamEntry::SubBlock: // Handled for us already. - case BitstreamEntry::Error: - return error("Malformed block"); - case BitstreamEntry::EndBlock: - return Error::success(); - case BitstreamEntry::Record: - // The interesting case. - break; - } - - // Read a record. - Record.clear(); - ++NumMDRecordLoaded; - Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, Record); - if (!MaybeCode) - return MaybeCode.takeError(); - switch (MaybeCode.get()) { - default: // Default behavior: ignore. - break; - case bitc::METADATA_KIND: { - if (Error Err = parseMetadataKindRecord(Record)) - return Err; - break; - } - } - } -} - -MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) { - Pimpl = std::move(RHS.Pimpl); - return *this; -} -MetadataLoader::MetadataLoader(MetadataLoader &&RHS) - : Pimpl(std::move(RHS.Pimpl)) {} - -MetadataLoader::~MetadataLoader() = default; -MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule, - BitcodeReaderValueList &ValueList, - bool IsImporting, - std::function<Type *(unsigned)> getTypeByID) - : Pimpl(llvm::make_unique<MetadataLoaderImpl>( - Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {} - -Error MetadataLoader::parseMetadata(bool ModuleLevel) { - return Pimpl->parseMetadata(ModuleLevel); -} - -bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); } - -/// Return the given metadata, creating a replaceable forward reference if -/// necessary. -Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) { - return Pimpl->getMetadataFwdRefOrLoad(Idx); -} - -DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) { - return Pimpl->lookupSubprogramForFunction(F); -} - -Error MetadataLoader::parseMetadataAttachment( - Function &F, const SmallVectorImpl<Instruction *> &InstructionList) { - return Pimpl->parseMetadataAttachment(F, InstructionList); -} - -Error MetadataLoader::parseMetadataKinds() { - return Pimpl->parseMetadataKinds(); -} - -void MetadataLoader::setStripTBAA(bool StripTBAA) { - return Pimpl->setStripTBAA(StripTBAA); -} - -bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); } - -unsigned MetadataLoader::size() const { return Pimpl->size(); } -void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); } - -void MetadataLoader::upgradeDebugIntrinsics(Function &F) { - return Pimpl->upgradeDebugIntrinsics(F); -} |