LCOV - code coverage report
Current view: top level - lib/Bitcode/Reader - MetadataLoader.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 729 829 87.9 %
Date: 2018-06-17 00:07:59 Functions: 54 56 96.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #include "MetadataLoader.h"
      11             : #include "ValueList.h"
      12             : 
      13             : #include "llvm/ADT/APFloat.h"
      14             : #include "llvm/ADT/APInt.h"
      15             : #include "llvm/ADT/ArrayRef.h"
      16             : #include "llvm/ADT/DenseMap.h"
      17             : #include "llvm/ADT/DenseSet.h"
      18             : #include "llvm/ADT/None.h"
      19             : #include "llvm/ADT/STLExtras.h"
      20             : #include "llvm/ADT/SmallString.h"
      21             : #include "llvm/ADT/SmallVector.h"
      22             : #include "llvm/ADT/Statistic.h"
      23             : #include "llvm/ADT/StringRef.h"
      24             : #include "llvm/ADT/Twine.h"
      25             : #include "llvm/Bitcode/BitcodeReader.h"
      26             : #include "llvm/Bitcode/BitstreamReader.h"
      27             : #include "llvm/Bitcode/LLVMBitCodes.h"
      28             : #include "llvm/IR/Argument.h"
      29             : #include "llvm/IR/Attributes.h"
      30             : #include "llvm/IR/AutoUpgrade.h"
      31             : #include "llvm/IR/BasicBlock.h"
      32             : #include "llvm/IR/CallingConv.h"
      33             : #include "llvm/IR/Comdat.h"
      34             : #include "llvm/IR/Constant.h"
      35             : #include "llvm/IR/Constants.h"
      36             : #include "llvm/IR/DebugInfo.h"
      37             : #include "llvm/IR/DebugInfoMetadata.h"
      38             : #include "llvm/IR/DebugLoc.h"
      39             : #include "llvm/IR/DerivedTypes.h"
      40             : #include "llvm/IR/DiagnosticPrinter.h"
      41             : #include "llvm/IR/Function.h"
      42             : #include "llvm/IR/GVMaterializer.h"
      43             : #include "llvm/IR/GlobalAlias.h"
      44             : #include "llvm/IR/GlobalIFunc.h"
      45             : #include "llvm/IR/GlobalIndirectSymbol.h"
      46             : #include "llvm/IR/GlobalObject.h"
      47             : #include "llvm/IR/GlobalValue.h"
      48             : #include "llvm/IR/GlobalVariable.h"
      49             : #include "llvm/IR/InlineAsm.h"
      50             : #include "llvm/IR/InstrTypes.h"
      51             : #include "llvm/IR/Instruction.h"
      52             : #include "llvm/IR/Instructions.h"
      53             : #include "llvm/IR/IntrinsicInst.h"
      54             : #include "llvm/IR/Intrinsics.h"
      55             : #include "llvm/IR/LLVMContext.h"
      56             : #include "llvm/IR/Module.h"
      57             : #include "llvm/IR/ModuleSummaryIndex.h"
      58             : #include "llvm/IR/OperandTraits.h"
      59             : #include "llvm/IR/TrackingMDRef.h"
      60             : #include "llvm/IR/Type.h"
      61             : #include "llvm/IR/ValueHandle.h"
      62             : #include "llvm/Support/AtomicOrdering.h"
      63             : #include "llvm/Support/Casting.h"
      64             : #include "llvm/Support/CommandLine.h"
      65             : #include "llvm/Support/Compiler.h"
      66             : #include "llvm/Support/Debug.h"
      67             : #include "llvm/Support/Error.h"
      68             : #include "llvm/Support/ErrorHandling.h"
      69             : #include "llvm/Support/ManagedStatic.h"
      70             : #include "llvm/Support/MemoryBuffer.h"
      71             : #include "llvm/Support/raw_ostream.h"
      72             : #include <algorithm>
      73             : #include <cassert>
      74             : #include <cstddef>
      75             : #include <cstdint>
      76             : #include <deque>
      77             : #include <limits>
      78             : #include <map>
      79             : #include <memory>
      80             : #include <string>
      81             : #include <system_error>
      82             : #include <tuple>
      83             : #include <utility>
      84             : #include <vector>
      85             : 
      86             : using namespace llvm;
      87             : 
      88             : #define DEBUG_TYPE "bitcode-reader"
      89             : 
      90             : STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded");
      91             : STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created");
      92             : STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded");
      93             : 
      94             : /// Flag whether we need to import full type definitions for ThinLTO.
      95             : /// Currently needed for Darwin and LLDB.
      96      101193 : static cl::opt<bool> ImportFullTypeDefinitions(
      97      202386 :     "import-full-type-definitions", cl::init(false), cl::Hidden,
      98      303579 :     cl::desc("Import full type definitions for ThinLTO."));
      99             : 
     100      101193 : static cl::opt<bool> DisableLazyLoading(
     101      202386 :     "disable-ondemand-mds-loading", cl::init(false), cl::Hidden,
     102      101193 :     cl::desc("Force disable the lazy-loading on-demand of metadata when "
     103      303579 :              "loading bitcode for importing."));
     104             : 
     105             : namespace {
     106             : 
     107          74 : static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; }
     108             : 
     109        6628 : class BitcodeReaderMetadataList {
     110             :   /// Array of metadata references.
     111             :   ///
     112             :   /// Don't use std::vector here.  Some versions of libc++ copy (instead of
     113             :   /// move) on resize, and TrackingMDRef is very expensive to copy.
     114             :   SmallVector<TrackingMDRef, 1> MetadataPtrs;
     115             : 
     116             :   /// The set of indices in MetadataPtrs above of forward references that were
     117             :   /// generated.
     118             :   SmallDenseSet<unsigned, 1> ForwardReference;
     119             : 
     120             :   /// The set of indices in MetadataPtrs above of Metadata that need to be
     121             :   /// resolved.
     122             :   SmallDenseSet<unsigned, 1> UnresolvedNodes;
     123             : 
     124             :   /// Structures for resolving old type refs.
     125       19912 :   struct {
     126             :     SmallDenseMap<MDString *, TempMDTuple, 1> Unknown;
     127             :     SmallDenseMap<MDString *, DICompositeType *, 1> Final;
     128             :     SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls;
     129             :     SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays;
     130             :   } OldTypeRefs;
     131             : 
     132             :   LLVMContext &Context;
     133             : 
     134             : public:
     135        6642 :   BitcodeReaderMetadataList(LLVMContext &C) : Context(C) {}
     136             : 
     137             :   // vector compatibility methods
     138       57497 :   unsigned size() const { return MetadataPtrs.size(); }
     139         293 :   void resize(unsigned N) { MetadataPtrs.resize(N); }
     140       23127 :   void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); }
     141             :   void clear() { MetadataPtrs.clear(); }
     142             :   Metadata *back() const { return MetadataPtrs.back(); }
     143             :   void pop_back() { MetadataPtrs.pop_back(); }
     144          15 :   bool empty() const { return MetadataPtrs.empty(); }
     145             : 
     146             :   Metadata *operator[](unsigned i) const {
     147             :     assert(i < MetadataPtrs.size());
     148             :     return MetadataPtrs[i];
     149             :   }
     150             : 
     151             :   Metadata *lookup(unsigned I) const {
     152       60495 :     if (I < MetadataPtrs.size())
     153             :       return MetadataPtrs[I];
     154             :     return nullptr;
     155             :   }
     156             : 
     157             :   void shrinkTo(unsigned N) {
     158             :     assert(N <= size() && "Invalid shrinkTo request!");
     159             :     assert(ForwardReference.empty() && "Unexpected forward refs");
     160             :     assert(UnresolvedNodes.empty() && "Unexpected unresolved node");
     161       11909 :     MetadataPtrs.resize(N);
     162             :   }
     163             : 
     164             :   /// Return the given metadata, creating a replaceable forward reference if
     165             :   /// necessary.
     166             :   Metadata *getMetadataFwdRef(unsigned Idx);
     167             : 
     168             :   /// Return the given metadata only if it is fully resolved.
     169             :   ///
     170             :   /// Gives the same result as \a lookup(), unless \a MDNode::isResolved()
     171             :   /// would give \c false.
     172             :   Metadata *getMetadataIfResolved(unsigned Idx);
     173             : 
     174             :   MDNode *getMDNodeFwdRefOrNull(unsigned Idx);
     175             :   void assignValue(Metadata *MD, unsigned Idx);
     176             :   void tryToResolveCycles();
     177       23848 :   bool hasFwdRefs() const { return !ForwardReference.empty(); }
     178             :   int getNextFwdRef() {
     179             :     assert(hasFwdRefs());
     180           8 :     return *ForwardReference.begin();
     181             :   }
     182             : 
     183             :   /// Upgrade a type that had an MDString reference.
     184             :   void addTypeRef(MDString &UUID, DICompositeType &CT);
     185             : 
     186             :   /// Upgrade a type that had an MDString reference.
     187             :   Metadata *upgradeTypeRef(Metadata *MaybeUUID);
     188             : 
     189             :   /// Upgrade a type ref array that may have MDString references.
     190             :   Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);
     191             : 
     192             : private:
     193             :   Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
     194             : };
     195             : 
     196       24258 : void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
     197             :   if (auto *MDN = dyn_cast<MDNode>(MD))
     198             :     if (!MDN->isResolved())
     199             :       UnresolvedNodes.insert(Idx);
     200             : 
     201       24258 :   if (Idx == size()) {
     202             :     push_back(MD);
     203             :     return;
     204             :   }
     205             : 
     206        1131 :   if (Idx >= size())
     207           0 :     resize(Idx + 1);
     208             : 
     209        1131 :   TrackingMDRef &OldMD = MetadataPtrs[Idx];
     210        1131 :   if (!OldMD) {
     211         226 :     OldMD.reset(MD);
     212         226 :     return;
     213             :   }
     214             : 
     215             :   // If there was a forward reference to this value, replace it.
     216             :   TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
     217             :   PrevMD->replaceAllUsesWith(MD);
     218             :   ForwardReference.erase(Idx);
     219             : }
     220             : 
     221       19190 : Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
     222       19190 :   if (Idx >= size())
     223         290 :     resize(Idx + 1);
     224             : 
     225       38380 :   if (Metadata *MD = MetadataPtrs[Idx])
     226             :     return MD;
     227             : 
     228             :   // Track forward refs to be resolved later.
     229             :   ForwardReference.insert(Idx);
     230             : 
     231             :   // Create and return a placeholder, which will later be RAUW'd.
     232             :   ++NumMDNodeTemporary;
     233         905 :   Metadata *MD = MDNode::getTemporary(Context, None).release();
     234        1810 :   MetadataPtrs[Idx].reset(MD);
     235         905 :   return MD;
     236             : }
     237             : 
     238        6569 : Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
     239             :   Metadata *MD = lookup(Idx);
     240        4895 :   if (auto *N = dyn_cast_or_null<MDNode>(MD))
     241             :     if (!N->isResolved())
     242             :       return nullptr;
     243             :   return MD;
     244             : }
     245             : 
     246             : MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
     247       13378 :   return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
     248             : }
     249             : 
     250        3218 : void BitcodeReaderMetadataList::tryToResolveCycles() {
     251        3218 :   if (!ForwardReference.empty())
     252             :     // Still forward references... can't resolve cycles.
     253             :     return;
     254             : 
     255             :   // Give up on finding a full definition for any forward decls that remain.
     256        6436 :   for (const auto &Ref : OldTypeRefs.FwdDecls)
     257           0 :     OldTypeRefs.Final.insert(Ref);
     258        3218 :   OldTypeRefs.FwdDecls.clear();
     259             : 
     260             :   // Upgrade from old type ref arrays.  In strange cases, this could add to
     261             :   // OldTypeRefs.Unknown.
     262        3218 :   for (const auto &Array : OldTypeRefs.Arrays)
     263           0 :     Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get()));
     264             :   OldTypeRefs.Arrays.clear();
     265             : 
     266             :   // Replace old string-based type refs with the resolved node, if possible.
     267             :   // If we haven't seen the node, leave it to the verifier to complain about
     268             :   // the invalid string reference.
     269        6438 :   for (const auto &Ref : OldTypeRefs.Unknown) {
     270           4 :     if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
     271             :       Ref.second->replaceAllUsesWith(CT);
     272             :     else
     273           0 :       Ref.second->replaceAllUsesWith(Ref.first);
     274             :   }
     275        3218 :   OldTypeRefs.Unknown.clear();
     276             : 
     277        3218 :   if (UnresolvedNodes.empty())
     278             :     // Nothing to do.
     279             :     return;
     280             : 
     281             :   // Resolve any cycles.
     282        1385 :   for (unsigned I : UnresolvedNodes) {
     283        1361 :     auto &MD = MetadataPtrs[I];
     284             :     auto *N = dyn_cast_or_null<MDNode>(MD);
     285           0 :     if (!N)
     286           0 :       continue;
     287             : 
     288             :     assert(!N->isTemporary() && "Unexpected forward reference");
     289        1361 :     N->resolveCycles();
     290             :   }
     291             : 
     292             :   // Make sure we return early again until there's another unresolved ref.
     293             :   UnresolvedNodes.clear();
     294             : }
     295             : 
     296           6 : void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
     297             :                                            DICompositeType &CT) {
     298             :   assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
     299           6 :   if (CT.isForwardDecl())
     300           0 :     OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
     301             :   else
     302          12 :     OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
     303           6 : }
     304             : 
     305        2097 : Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
     306        2097 :   auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
     307        2097 :   if (LLVM_LIKELY(!UUID))
     308             :     return MaybeUUID;
     309             : 
     310          66 :   if (auto *CT = OldTypeRefs.Final.lookup(UUID))
     311             :     return CT;
     312             : 
     313           2 :   auto &Ref = OldTypeRefs.Unknown[UUID];
     314           2 :   if (!Ref)
     315           2 :     Ref = MDNode::getTemporary(Context, None);
     316           2 :   return Ref.get();
     317             : }
     318             : 
     319           4 : Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
     320           4 :   auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
     321           4 :   if (!Tuple || Tuple->isDistinct())
     322             :     return MaybeTuple;
     323             : 
     324             :   // Look through the array immediately if possible.
     325           4 :   if (!Tuple->isTemporary())
     326           4 :     return resolveTypeRefArray(Tuple);
     327             : 
     328             :   // Create and return a placeholder to use for now.  Eventually
     329             :   // resolveTypeRefArrays() will be resolve this forward reference.
     330           0 :   OldTypeRefs.Arrays.emplace_back(
     331           0 :       std::piecewise_construct, std::forward_as_tuple(Tuple),
     332           0 :       std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
     333           0 :   return OldTypeRefs.Arrays.back().second.get();
     334             : }
     335             : 
     336           4 : Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
     337             :   auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
     338           4 :   if (!Tuple || Tuple->isDistinct())
     339             :     return MaybeTuple;
     340             : 
     341             :   // Look through the DITypeRefArray, upgrading each DITypeRef.
     342             :   SmallVector<Metadata *, 32> Ops;
     343           4 :   Ops.reserve(Tuple->getNumOperands());
     344          16 :   for (Metadata *MD : Tuple->operands())
     345           4 :     Ops.push_back(upgradeTypeRef(MD));
     346             : 
     347           4 :   return MDTuple::get(Context, Ops);
     348             : }
     349             : 
     350             : namespace {
     351             : 
     352             : class PlaceholderQueue {
     353             :   // Placeholders would thrash around when moved, so store in a std::deque
     354             :   // instead of some sort of vector.
     355             :   std::deque<DistinctMDOperandPlaceholder> PHs;
     356             : 
     357             : public:
     358        3217 :   ~PlaceholderQueue() {
     359             :     assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed");
     360             :   }
     361             :   bool empty() { return PHs.empty(); }
     362             :   DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID);
     363             :   void flush(BitcodeReaderMetadataList &MetadataList);
     364             : 
     365             :   /// Return the list of temporaries nodes in the queue, these need to be
     366             :   /// loaded before we can flush the queue.
     367        3223 :   void getTemporaries(BitcodeReaderMetadataList &MetadataList,
     368             :                       DenseSet<unsigned> &Temporaries) {
     369        5850 :     for (auto &PH : PHs) {
     370        2627 :       auto ID = PH.getID();
     371             :       auto *MD = MetadataList.lookup(ID);
     372        2639 :       if (!MD) {
     373             :         Temporaries.insert(ID);
     374          12 :         continue;
     375             :       }
     376             :       auto *N = dyn_cast_or_null<MDNode>(MD);
     377        2615 :       if (N && N->isTemporary())
     378             :         Temporaries.insert(ID);
     379             :     }
     380        3223 :   }
     381             : };
     382             : 
     383             : } // end anonymous namespace
     384             : 
     385             : DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
     386        2607 :   PHs.emplace_back(ID);
     387             :   return PHs.back();
     388             : }
     389             : 
     390        3218 : void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
     391        8432 :   while (!PHs.empty()) {
     392        2607 :     auto *MD = MetadataList.lookup(PHs.front().getID());
     393             :     assert(MD && "Flushing placeholder on unassigned MD");
     394             : #ifndef NDEBUG
     395             :     if (auto *MDN = dyn_cast<MDNode>(MD))
     396             :       assert(MDN->isResolved() &&
     397             :              "Flushing Placeholder while cycles aren't resolved");
     398             : #endif
     399        2607 :     PHs.front().replaceUseWith(MD);
     400        2607 :     PHs.pop_front();
     401             :   }
     402        3218 : }
     403             : 
     404             : } // anonynous namespace
     405             : 
     406           0 : static Error error(const Twine &Message) {
     407             :   return make_error<StringError>(
     408           0 :       Message, make_error_code(BitcodeError::CorruptedBitcode));
     409             : }
     410             : 
     411        6628 : class MetadataLoader::MetadataLoaderImpl {
     412             :   BitcodeReaderMetadataList MetadataList;
     413             :   BitcodeReaderValueList &ValueList;
     414             :   BitstreamCursor &Stream;
     415             :   LLVMContext &Context;
     416             :   Module &TheModule;
     417             :   std::function<Type *(unsigned)> getTypeByID;
     418             : 
     419             :   /// Cursor associated with the lazy-loading of Metadata. This is the easy way
     420             :   /// to keep around the right "context" (Abbrev list) to be able to jump in
     421             :   /// the middle of the metadata block and load any record.
     422             :   BitstreamCursor IndexCursor;
     423             : 
     424             :   /// Index that keeps track of MDString values.
     425             :   std::vector<StringRef> MDStringRef;
     426             : 
     427             :   /// On-demand loading of a single MDString. Requires the index above to be
     428             :   /// populated.
     429             :   MDString *lazyLoadOneMDString(unsigned Idx);
     430             : 
     431             :   /// Index that keeps track of where to find a metadata record in the stream.
     432             :   std::vector<uint64_t> GlobalMetadataBitPosIndex;
     433             : 
     434             :   /// Populate the index above to enable lazily loading of metadata, and load
     435             :   /// the named metadata as well as the transitively referenced global
     436             :   /// Metadata.
     437             :   Expected<bool> lazyLoadModuleMetadataBlock();
     438             : 
     439             :   /// On-demand loading of a single metadata. Requires the index above to be
     440             :   /// populated.
     441             :   void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders);
     442             : 
     443             :   // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to
     444             :   // point from SP to CU after a block is completly parsed.
     445             :   std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
     446             : 
     447             :   /// Functions that need to be matched with subprograms when upgrading old
     448             :   /// metadata.
     449             :   SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;
     450             : 
     451             :   // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
     452             :   DenseMap<unsigned, unsigned> MDKindMap;
     453             : 
     454             :   bool StripTBAA = false;
     455             :   bool HasSeenOldLoopTags = false;
     456             :   bool NeedUpgradeToDIGlobalVariableExpression = false;
     457             :   bool NeedDeclareExpressionUpgrade = false;
     458             : 
     459             :   /// True if metadata is being parsed for a module being ThinLTO imported.
     460             :   bool IsImporting = false;
     461             : 
     462             :   Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code,
     463             :                          PlaceholderQueue &Placeholders, StringRef Blob,
     464             :                          unsigned &NextMetadataNo);
     465             :   Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
     466             :                              function_ref<void(StringRef)> CallBack);
     467             :   Error parseGlobalObjectAttachment(GlobalObject &GO,
     468             :                                     ArrayRef<uint64_t> Record);
     469             :   Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);
     470             : 
     471             :   void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
     472             : 
     473             :   /// Upgrade old-style CU <-> SP pointers to point from SP to CU.
     474        2113 :   void upgradeCUSubprograms() {
     475        2118 :     for (auto CU_SP : CUSubprograms)
     476             :       if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
     477          18 :         for (auto &Op : SPs->operands())
     478             :           if (auto *SP = dyn_cast_or_null<DISubprogram>(Op))
     479             :             SP->replaceUnit(CU_SP.first);
     480             :     CUSubprograms.clear();
     481        2113 :   }
     482             : 
     483             :   /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
     484        2113 :   void upgradeCUVariables() {
     485        2113 :     if (!NeedUpgradeToDIGlobalVariableExpression)
     486             :       return;
     487             : 
     488             :     // Upgrade list of variables attached to the CUs.
     489          22 :     if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
     490          18 :       for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
     491           9 :         auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
     492             :         if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
     493          35 :           for (unsigned I = 0; I < GVs->getNumOperands(); I++)
     494             :             if (auto *GV =
     495          13 :                     dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
     496           5 :               auto *DGVE = DIGlobalVariableExpression::getDistinct(
     497           5 :                   Context, GV, DIExpression::get(Context, {}));
     498           5 :               GVs->replaceOperandWith(I, DGVE);
     499             :             }
     500             :       }
     501             : 
     502             :     // Upgrade variables attached to globals.
     503          34 :     for (auto &GV : TheModule.globals()) {
     504             :       SmallVector<MDNode *, 1> MDs;
     505          12 :       GV.getMetadata(LLVMContext::MD_dbg, MDs);
     506          12 :       GV.eraseMetadata(LLVMContext::MD_dbg);
     507          36 :       for (auto *MD : MDs)
     508             :         if (auto *DGV = dyn_cast_or_null<DIGlobalVariable>(MD)) {
     509           3 :           auto *DGVE = DIGlobalVariableExpression::getDistinct(
     510           3 :               Context, DGV, DIExpression::get(Context, {}));
     511           3 :           GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
     512             :         } else
     513           9 :           GV.addMetadata(LLVMContext::MD_dbg, *MD);
     514             :     }
     515             :   }
     516             : 
     517             :   /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that
     518             :   /// describes a function argument.
     519       52244 :   void upgradeDeclareExpressions(Function &F) {
     520       52244 :     if (!NeedDeclareExpressionUpgrade)
     521             :       return;
     522             : 
     523           9 :     for (auto &BB : F)
     524          24 :       for (auto &I : BB)
     525             :         if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
     526           7 :           if (auto *DIExpr = DDI->getExpression())
     527             :             if (DIExpr->startsWithDeref() &&
     528             :                 dyn_cast_or_null<Argument>(DDI->getAddress())) {
     529             :               SmallVector<uint64_t, 8> Ops;
     530           1 :               Ops.append(std::next(DIExpr->elements_begin()),
     531             :                          DIExpr->elements_end());
     532           1 :               auto *E = DIExpression::get(Context, Ops);
     533           1 :               DDI->setOperand(2, MetadataAsValue::get(Context, E));
     534             :             }
     535             :   }
     536             : 
     537             :   /// Upgrade the expression from previous versions.
     538         105 :   Error upgradeDIExpression(uint64_t FromVersion,
     539             :                             MutableArrayRef<uint64_t> &Expr,
     540             :                             SmallVectorImpl<uint64_t> &Buffer) {
     541         105 :     auto N = Expr.size();
     542         105 :     switch (FromVersion) {
     543             :     default:
     544           0 :       return error("Invalid record");
     545           3 :     case 0:
     546           4 :       if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece)
     547           1 :         Expr[N - 3] = dwarf::DW_OP_LLVM_fragment;
     548             :       LLVM_FALLTHROUGH;
     549             :     case 1:
     550             :       // Move DW_OP_deref to the end.
     551          23 :       if (N && Expr[0] == dwarf::DW_OP_deref) {
     552             :         auto End = Expr.end();
     553           6 :         if (Expr.size() >= 3 &&
     554           2 :             *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment)
     555             :           End = std::prev(End, 3);
     556             :         std::move(std::next(Expr.begin()), End, Expr.begin());
     557           4 :         *std::prev(End) = dwarf::DW_OP_deref;
     558             :       }
     559          13 :       NeedDeclareExpressionUpgrade = true;
     560             :       LLVM_FALLTHROUGH;
     561          14 :     case 2: {
     562             :       // Change DW_OP_plus to DW_OP_plus_uconst.
     563             :       // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus
     564          14 :       auto SubExpr = ArrayRef<uint64_t>(Expr);
     565          48 :       while (!SubExpr.empty()) {
     566             :         // Skip past other operators with their operands
     567             :         // for this version of the IR, obtained from
     568             :         // from historic DIExpression::ExprOperand::getSize().
     569             :         size_t HistoricSize;
     570          17 :         switch (SubExpr.front()) {
     571           7 :         default:
     572           7 :           HistoricSize = 1;
     573           7 :           break;
     574           8 :         case dwarf::DW_OP_constu:
     575             :         case dwarf::DW_OP_minus:
     576             :         case dwarf::DW_OP_plus:
     577           8 :           HistoricSize = 2;
     578           8 :           break;
     579           2 :         case dwarf::DW_OP_LLVM_fragment:
     580           2 :           HistoricSize = 3;
     581           2 :           break;
     582             :         }
     583             : 
     584             :         // If the expression is malformed, make sure we don't
     585             :         // copy more elements than we should.
     586          34 :         HistoricSize = std::min(SubExpr.size(), HistoricSize);
     587          17 :         ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1);
     588             : 
     589          17 :         switch (SubExpr.front()) {
     590           5 :         case dwarf::DW_OP_plus:
     591           5 :           Buffer.push_back(dwarf::DW_OP_plus_uconst);
     592           5 :           Buffer.append(Args.begin(), Args.end());
     593           5 :           break;
     594           1 :         case dwarf::DW_OP_minus:
     595           1 :           Buffer.push_back(dwarf::DW_OP_constu);
     596           1 :           Buffer.append(Args.begin(), Args.end());
     597           1 :           Buffer.push_back(dwarf::DW_OP_minus);
     598           1 :           break;
     599          11 :         default:
     600          11 :           Buffer.push_back(*SubExpr.begin());
     601          11 :           Buffer.append(Args.begin(), Args.end());
     602          11 :           break;
     603             :         }
     604             : 
     605             :         // Continue with remaining elements.
     606          17 :         SubExpr = SubExpr.slice(HistoricSize);
     607             :       }
     608          14 :       Expr = MutableArrayRef<uint64_t>(Buffer);
     609             :       LLVM_FALLTHROUGH;
     610             :     }
     611             :     case 3:
     612             :       // Up-to-date!
     613             :       break;
     614             :     }
     615             : 
     616             :     return Error::success();
     617             :   }
     618             : 
     619             :   void upgradeDebugInfo() {
     620        2113 :     upgradeCUSubprograms();
     621        2113 :     upgradeCUVariables();
     622             :   }
     623             : 
     624             : public:
     625        3321 :   MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
     626             :                      BitcodeReaderValueList &ValueList,
     627             :                      std::function<Type *(unsigned)> getTypeByID,
     628             :                      bool IsImporting)
     629        3321 :       : MetadataList(TheModule.getContext()), ValueList(ValueList),
     630        3321 :         Stream(Stream), Context(TheModule.getContext()), TheModule(TheModule),
     631       16605 :         getTypeByID(std::move(getTypeByID)), IsImporting(IsImporting) {}
     632             : 
     633             :   Error parseMetadata(bool ModuleLevel);
     634             : 
     635             :   bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }
     636             : 
     637        9682 :   Metadata *getMetadataFwdRefOrLoad(unsigned ID) {
     638       19364 :     if (ID < MDStringRef.size())
     639           0 :       return lazyLoadOneMDString(ID);
     640        9682 :     if (auto *MD = MetadataList.lookup(ID))
     641             :       return MD;
     642             :     // If lazy-loading is enabled, we try recursively to load the operand
     643             :     // instead of creating a temporary.
     644           0 :     if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
     645             :       PlaceholderQueue Placeholders;
     646           0 :       lazyLoadOneMetadata(ID, Placeholders);
     647           0 :       resolveForwardRefsAndPlaceholders(Placeholders);
     648             :       return MetadataList.lookup(ID);
     649             :     }
     650           0 :     return MetadataList.getMetadataFwdRef(ID);
     651             :   }
     652             : 
     653             :   MDNode *getMDNodeFwdRefOrNull(unsigned Idx) {
     654        8096 :     return MetadataList.getMDNodeFwdRefOrNull(Idx);
     655             :   }
     656             : 
     657             :   DISubprogram *lookupSubprogramForFunction(Function *F) {
     658       11909 :     return FunctionsWithSPs.lookup(F);
     659             :   }
     660             : 
     661             :   bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; }
     662             : 
     663             :   Error parseMetadataAttachment(
     664             :       Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
     665             : 
     666             :   Error parseMetadataKinds();
     667             : 
     668           2 :   void setStripTBAA(bool Value) { StripTBAA = Value; }
     669             :   bool isStrippingTBAA() { return StripTBAA; }
     670             : 
     671             :   unsigned size() const { return MetadataList.size(); }
     672             :   void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
     673       52244 :   void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
     674             : };
     675             : 
     676             : Expected<bool>
     677          15 : MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
     678          15 :   IndexCursor = Stream;
     679             :   SmallVector<uint64_t, 64> Record;
     680             :   // Get the abbrevs, and preload record positions to make them lazy-loadable.
     681             :   while (true) {
     682             :     BitstreamEntry Entry = IndexCursor.advanceSkippingSubblocks(
     683          39 :         BitstreamCursor::AF_DontPopBlockAtEnd);
     684          39 :     switch (Entry.Kind) {
     685             :     case BitstreamEntry::SubBlock: // Handled for us already.
     686             :     case BitstreamEntry::Error:
     687           0 :       return error("Malformed block");
     688           3 :     case BitstreamEntry::EndBlock: {
     689             :       return true;
     690             :     }
     691             :     case BitstreamEntry::Record: {
     692             :       // The interesting case.
     693             :       ++NumMDRecordLoaded;
     694          36 :       uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
     695          36 :       auto Code = IndexCursor.skipRecord(Entry.ID);
     696          36 :       switch (Code) {
     697          15 :       case bitc::METADATA_STRINGS: {
     698             :         // Rewind and parse the strings.
     699          15 :         IndexCursor.JumpToBit(CurrentPos);
     700          15 :         StringRef Blob;
     701             :         Record.clear();
     702          15 :         IndexCursor.readRecord(Entry.ID, Record, &Blob);
     703          15 :         unsigned NumStrings = Record[0];
     704          15 :         MDStringRef.reserve(NumStrings);
     705             :         auto IndexNextMDString = [&](StringRef Str) {
     706          94 :           MDStringRef.push_back(Str);
     707          15 :         };
     708          30 :         if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
     709             :           return std::move(Err);
     710          15 :         break;
     711             :       }
     712           3 :       case bitc::METADATA_INDEX_OFFSET: {
     713             :         // This is the offset to the index, when we see this we skip all the
     714             :         // records and load only an index to these.
     715           3 :         IndexCursor.JumpToBit(CurrentPos);
     716             :         Record.clear();
     717           3 :         IndexCursor.readRecord(Entry.ID, Record);
     718           3 :         if (Record.size() != 2)
     719           0 :           return error("Invalid record");
     720           3 :         auto Offset = Record[0] + (Record[1] << 32);
     721           3 :         auto BeginPos = IndexCursor.GetCurrentBitNo();
     722           3 :         IndexCursor.JumpToBit(BeginPos + Offset);
     723           3 :         Entry = IndexCursor.advanceSkippingSubblocks(
     724             :             BitstreamCursor::AF_DontPopBlockAtEnd);
     725             :         assert(Entry.Kind == BitstreamEntry::Record &&
     726             :                "Corrupted bitcode: Expected `Record` when trying to find the "
     727             :                "Metadata index");
     728             :         Record.clear();
     729           3 :         auto Code = IndexCursor.readRecord(Entry.ID, Record);
     730             :         (void)Code;
     731             :         assert(Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
     732             :                                                "`METADATA_INDEX` when trying "
     733             :                                                "to find the Metadata index");
     734             : 
     735             :         // Delta unpack
     736           3 :         auto CurrentValue = BeginPos;
     737           6 :         GlobalMetadataBitPosIndex.reserve(Record.size());
     738         195 :         for (auto &Elt : Record) {
     739          96 :           CurrentValue += Elt;
     740          96 :           GlobalMetadataBitPosIndex.push_back(CurrentValue);
     741             :         }
     742           3 :         break;
     743             :       }
     744             :       case bitc::METADATA_INDEX:
     745             :         // We don't expect to get there, the Index is loaded when we encounter
     746             :         // the offset.
     747           0 :         return error("Corrupted Metadata block");
     748           6 :       case bitc::METADATA_NAME: {
     749             :         // Named metadata need to be materialized now and aren't deferred.
     750           6 :         IndexCursor.JumpToBit(CurrentPos);
     751             :         Record.clear();
     752           6 :         unsigned Code = IndexCursor.readRecord(Entry.ID, Record);
     753             :         assert(Code == bitc::METADATA_NAME);
     754             : 
     755             :         // Read name of the named metadata.
     756             :         SmallString<8> Name(Record.begin(), Record.end());
     757             :         Code = IndexCursor.ReadCode();
     758             : 
     759             :         // Named Metadata comes in two parts, we expect the name to be followed
     760             :         // by the node
     761             :         Record.clear();
     762           6 :         unsigned NextBitCode = IndexCursor.readRecord(Code, Record);
     763             :         assert(NextBitCode == bitc::METADATA_NAMED_NODE);
     764             :         (void)NextBitCode;
     765             : 
     766             :         // Read named metadata elements.
     767           6 :         unsigned Size = Record.size();
     768          12 :         NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
     769          22 :         for (unsigned i = 0; i != Size; ++i) {
     770             :           // FIXME: We could use a placeholder here, however NamedMDNode are
     771             :           // taking MDNode as operand and not using the Metadata infrastructure.
     772             :           // It is acknowledged by 'TODO: Inherit from Metadata' in the
     773             :           // NamedMDNode class definition.
     774          16 :           MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
     775             :           assert(MD && "Invalid record");
     776           8 :           NMD->addOperand(MD);
     777             :         }
     778             :         break;
     779             :       }
     780           0 :       case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
     781             :         // FIXME: we need to do this early because we don't materialize global
     782             :         // value explicitly.
     783           0 :         IndexCursor.JumpToBit(CurrentPos);
     784             :         Record.clear();
     785           0 :         IndexCursor.readRecord(Entry.ID, Record);
     786           0 :         if (Record.size() % 2 == 0)
     787           0 :           return error("Invalid record");
     788           0 :         unsigned ValueID = Record[0];
     789           0 :         if (ValueID >= ValueList.size())
     790           0 :           return error("Invalid record");
     791             :         if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
     792           0 :           if (Error Err = parseGlobalObjectAttachment(
     793           0 :                   *GO, ArrayRef<uint64_t>(Record).slice(1)))
     794             :             return std::move(Err);
     795             :         break;
     796             :       }
     797          12 :       case bitc::METADATA_KIND:
     798             :       case bitc::METADATA_STRING_OLD:
     799             :       case bitc::METADATA_OLD_FN_NODE:
     800             :       case bitc::METADATA_OLD_NODE:
     801             :       case bitc::METADATA_VALUE:
     802             :       case bitc::METADATA_DISTINCT_NODE:
     803             :       case bitc::METADATA_NODE:
     804             :       case bitc::METADATA_LOCATION:
     805             :       case bitc::METADATA_GENERIC_DEBUG:
     806             :       case bitc::METADATA_SUBRANGE:
     807             :       case bitc::METADATA_ENUMERATOR:
     808             :       case bitc::METADATA_BASIC_TYPE:
     809             :       case bitc::METADATA_DERIVED_TYPE:
     810             :       case bitc::METADATA_COMPOSITE_TYPE:
     811             :       case bitc::METADATA_SUBROUTINE_TYPE:
     812             :       case bitc::METADATA_MODULE:
     813             :       case bitc::METADATA_FILE:
     814             :       case bitc::METADATA_COMPILE_UNIT:
     815             :       case bitc::METADATA_SUBPROGRAM:
     816             :       case bitc::METADATA_LEXICAL_BLOCK:
     817             :       case bitc::METADATA_LEXICAL_BLOCK_FILE:
     818             :       case bitc::METADATA_NAMESPACE:
     819             :       case bitc::METADATA_MACRO:
     820             :       case bitc::METADATA_MACRO_FILE:
     821             :       case bitc::METADATA_TEMPLATE_TYPE:
     822             :       case bitc::METADATA_TEMPLATE_VALUE:
     823             :       case bitc::METADATA_GLOBAL_VAR:
     824             :       case bitc::METADATA_LOCAL_VAR:
     825             :       case bitc::METADATA_LABEL:
     826             :       case bitc::METADATA_EXPRESSION:
     827             :       case bitc::METADATA_OBJC_PROPERTY:
     828             :       case bitc::METADATA_IMPORTED_ENTITY:
     829             :       case bitc::METADATA_GLOBAL_VAR_EXPR:
     830             :         // We don't expect to see any of these, if we see one, give up on
     831             :         // lazy-loading and fallback.
     832             :         MDStringRef.clear();
     833             :         GlobalMetadataBitPosIndex.clear();
     834             :         return false;
     835             :       }
     836             :       break;
     837             :     }
     838             :     }
     839          24 :   }
     840             : }
     841             : 
     842             : /// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
     843             : /// module level metadata.
     844        2113 : Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) {
     845        3201 :   if (!ModuleLevel && MetadataList.hasFwdRefs())
     846           0 :     return error("Invalid metadata: fwd refs into function blocks");
     847             : 
     848             :   // Record the entry position so that we can jump back here and efficiently
     849             :   // skip the whole block in case we lazy-load.
     850        2113 :   auto EntryPos = Stream.GetCurrentBitNo();
     851             : 
     852        2113 :   if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
     853           0 :     return error("Invalid record");
     854             : 
     855             :   SmallVector<uint64_t, 64> Record;
     856             :   PlaceholderQueue Placeholders;
     857             : 
     858             :   // We lazy-load module-level metadata: we build an index for each record, and
     859             :   // then load individual record as needed, starting with the named metadata.
     860        2143 :   if (ModuleLevel && IsImporting && MetadataList.empty() &&
     861             :       !DisableLazyLoading) {
     862          15 :     auto SuccessOrErr = lazyLoadModuleMetadataBlock();
     863          15 :     if (!SuccessOrErr)
     864             :       return SuccessOrErr.takeError();
     865          15 :     if (SuccessOrErr.get()) {
     866             :       // An index was successfully created and we will be able to load metadata
     867             :       // on-demand.
     868           9 :       MetadataList.resize(MDStringRef.size() +
     869           3 :                           GlobalMetadataBitPosIndex.size());
     870             : 
     871             :       // Reading the named metadata created forward references and/or
     872             :       // placeholders, that we flush here.
     873           3 :       resolveForwardRefsAndPlaceholders(Placeholders);
     874             :       upgradeDebugInfo();
     875             :       // Return at the beginning of the block, since it is easy to skip it
     876             :       // entirely from there.
     877           3 :       Stream.ReadBlockEnd(); // Pop the abbrev block context.
     878           3 :       Stream.JumpToBit(EntryPos);
     879           3 :       if (Stream.SkipBlock())
     880           0 :         return error("Invalid record");
     881             :       return Error::success();
     882             :     }
     883             :     // Couldn't load an index, fallback to loading all the block "old-style".
     884             :   }
     885             : 
     886        2110 :   unsigned NextMetadataNo = MetadataList.size();
     887             : 
     888             :   // Read all the records.
     889             :   while (true) {
     890       24251 :     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
     891             : 
     892       24251 :     switch (Entry.Kind) {
     893             :     case BitstreamEntry::SubBlock: // Handled for us already.
     894             :     case BitstreamEntry::Error:
     895           0 :       return error("Malformed block");
     896        2110 :     case BitstreamEntry::EndBlock:
     897        2110 :       resolveForwardRefsAndPlaceholders(Placeholders);
     898             :       upgradeDebugInfo();
     899             :       return Error::success();
     900             :     case BitstreamEntry::Record:
     901             :       // The interesting case.
     902             :       break;
     903             :     }
     904             : 
     905             :     // Read a record.
     906             :     Record.clear();
     907       22141 :     StringRef Blob;
     908             :     ++NumMDRecordLoaded;
     909       22141 :     unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
     910       22141 :     if (Error Err =
     911       22141 :             parseOneMetadata(Record, Code, Placeholders, Blob, NextMetadataNo))
     912             :       return Err;
     913             :   }
     914             : }
     915             : 
     916          38 : MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) {
     917             :   ++NumMDStringLoaded;
     918          38 :   if (Metadata *MD = MetadataList.lookup(ID))
     919             :     return cast<MDString>(MD);
     920          72 :   auto MDS = MDString::get(Context, MDStringRef[ID]);
     921          36 :   MetadataList.assignValue(MDS, ID);
     922          36 :   return MDS;
     923             : }
     924             : 
     925          97 : void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
     926             :     unsigned ID, PlaceholderQueue &Placeholders) {
     927             :   assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
     928             :   assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString");
     929             :   // Lookup first if the metadata hasn't already been loaded.
     930         194 :   if (auto *MD = MetadataList.lookup(ID)) {
     931             :     auto *N = dyn_cast_or_null<MDNode>(MD);
     932           9 :     if (!N->isTemporary())
     933           1 :       return;
     934             :   }
     935             :   SmallVector<uint64_t, 64> Record;
     936          96 :   StringRef Blob;
     937         288 :   IndexCursor.JumpToBit(GlobalMetadataBitPosIndex[ID - MDStringRef.size()]);
     938          96 :   auto Entry = IndexCursor.advanceSkippingSubblocks();
     939             :   ++NumMDRecordLoaded;
     940          96 :   unsigned Code = IndexCursor.readRecord(Entry.ID, Record, &Blob);
     941         192 :   if (Error Err = parseOneMetadata(Record, Code, Placeholders, Blob, ID))
     942           0 :     report_fatal_error("Can't lazyload MD");
     943             : }
     944             : 
     945             : /// Ensure that all forward-references and placeholders are resolved.
     946             : /// Iteratively lazy-loading metadata on-demand if needed.
     947        3218 : void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
     948             :     PlaceholderQueue &Placeholders) {
     949             :   DenseSet<unsigned> Temporaries;
     950             :   while (1) {
     951             :     // Populate Temporaries with the placeholders that haven't been loaded yet.
     952        3223 :     Placeholders.getTemporaries(MetadataList, Temporaries);
     953             : 
     954             :     // If we don't have any temporary, or FwdReference, we're done!
     955        6443 :     if (Temporaries.empty() && !MetadataList.hasFwdRefs())
     956             :       break;
     957             : 
     958             :     // First, load all the temporaries. This can add new placeholders or
     959             :     // forward references.
     960          17 :     for (auto ID : Temporaries)
     961          12 :       lazyLoadOneMetadata(ID, Placeholders);
     962             :     Temporaries.clear();
     963             : 
     964             :     // Second, load the forward-references. This can also add new placeholders
     965             :     // or forward references.
     966          21 :     while (MetadataList.hasFwdRefs())
     967           8 :       lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
     968             :   }
     969             :   // At this point we don't have any forward reference remaining, or temporary
     970             :   // that haven't been loaded. We can safely drop RAUW support and mark cycles
     971             :   // as resolved.
     972        3218 :   MetadataList.tryToResolveCycles();
     973             : 
     974             :   // Finally, everything is in place, we can replace the placeholders operands
     975             :   // with the final node they refer to.
     976        3218 :   Placeholders.flush(MetadataList);
     977        3218 : }
     978             : 
     979       22237 : Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
     980             :     SmallVectorImpl<uint64_t> &Record, unsigned Code,
     981             :     PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) {
     982             : 
     983       22237 :   bool IsDistinct = false;
     984       33466 :   auto getMD = [&](unsigned ID) -> Metadata * {
     985       67084 :     if (ID < MDStringRef.size())
     986          38 :       return lazyLoadOneMDString(ID);
     987       33428 :     if (!IsDistinct) {
     988       26577 :       if (auto *MD = MetadataList.lookup(ID))
     989             :         return MD;
     990             :       // If lazy-loading is enabled, we try recursively to load the operand
     991             :       // instead of creating a temporary.
     992        1868 :       if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
     993             :         // Create a temporary for the node that is referencing the operand we
     994             :         // will lazy-load. It is needed before recursing in case there are
     995             :         // uniquing cycles.
     996          76 :         MetadataList.getMetadataFwdRef(NextMetadataNo);
     997        2683 :         lazyLoadOneMetadata(ID, Placeholders);
     998             :         return MetadataList.lookup(ID);
     999             :       }
    1000             :       // Return a temporary.
    1001         858 :       return MetadataList.getMetadataFwdRef(ID);
    1002             :     }
    1003        6569 :     if (auto *MD = MetadataList.getMetadataIfResolved(ID))
    1004             :       return MD;
    1005        2607 :     return &Placeholders.getPlaceholderOp(ID);
    1006       22237 :   };
    1007       28413 :   auto getMDOrNull = [&](unsigned ID) -> Metadata * {
    1008       34711 :     if (ID)
    1009       27827 :       return getMD(ID - 1);
    1010             :     return nullptr;
    1011       22237 :   };
    1012             :   auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
    1013         395 :     if (ID)
    1014           5 :       return MetadataList.getMetadataFwdRef(ID - 1);
    1015             :     return nullptr;
    1016             :   };
    1017        4205 :   auto getMDString = [&](unsigned ID) -> MDString * {
    1018             :     // This requires that the ID is not really a forward reference.  In
    1019             :     // particular, the MDString must already have been resolved.
    1020        4205 :     auto MDS = getMDOrNull(ID);
    1021        4205 :     return cast_or_null<MDString>(MDS);
    1022       22237 :   };
    1023             : 
    1024             :   // Support for old type refs.
    1025        2093 :   auto getDITypeRefOrNull = [&](unsigned ID) {
    1026        2093 :     return MetadataList.upgradeTypeRef(getMDOrNull(ID));
    1027       24330 :   };
    1028             : 
    1029             : #define GET_OR_DISTINCT(CLASS, ARGS)                                           \
    1030             :   (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
    1031             : 
    1032       22237 :   switch (Code) {
    1033             :   default: // Default behavior: ignore.
    1034             :     break;
    1035        2018 :   case bitc::METADATA_NAME: {
    1036             :     // Read name of the named metadata.
    1037             :     SmallString<8> Name(Record.begin(), Record.end());
    1038             :     Record.clear();
    1039        2018 :     Code = Stream.ReadCode();
    1040             : 
    1041             :     ++NumMDRecordLoaded;
    1042        2018 :     unsigned NextBitCode = Stream.readRecord(Code, Record);
    1043        2018 :     if (NextBitCode != bitc::METADATA_NAMED_NODE)
    1044           0 :       return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
    1045             : 
    1046             :     // Read named metadata elements.
    1047        2018 :     unsigned Size = Record.size();
    1048        4036 :     NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
    1049       11832 :     for (unsigned i = 0; i != Size; ++i) {
    1050        9814 :       MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
    1051             :       if (!MD)
    1052           0 :         return error("Invalid record");
    1053        4907 :       NMD->addOperand(MD);
    1054             :     }
    1055             :     break;
    1056             :   }
    1057         598 :   case bitc::METADATA_OLD_FN_NODE: {
    1058             :     // FIXME: Remove in 4.0.
    1059             :     // This is a LocalAsMetadata record, the only type of function-local
    1060             :     // metadata.
    1061         598 :     if (Record.size() % 2 == 1)
    1062           0 :       return error("Invalid record");
    1063             : 
    1064             :     // If this isn't a LocalAsMetadata record, we're dropping it.  This used
    1065             :     // to be legal, but there's no upgrade path.
    1066           2 :     auto dropRecord = [&] {
    1067           4 :       MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo);
    1068           2 :       NextMetadataNo++;
    1069         600 :     };
    1070         598 :     if (Record.size() != 2) {
    1071           1 :       dropRecord();
    1072         599 :       break;
    1073             :     }
    1074             : 
    1075         597 :     Type *Ty = getTypeByID(Record[0]);
    1076         597 :     if (Ty->isMetadataTy() || Ty->isVoidTy()) {
    1077           1 :       dropRecord();
    1078           1 :       break;
    1079             :     }
    1080             : 
    1081        1192 :     MetadataList.assignValue(
    1082        1192 :         LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
    1083             :         NextMetadataNo);
    1084         596 :     NextMetadataNo++;
    1085         596 :     break;
    1086             :   }
    1087        1346 :   case bitc::METADATA_OLD_NODE: {
    1088             :     // FIXME: Remove in 4.0.
    1089        1346 :     if (Record.size() % 2 == 1)
    1090           0 :       return error("Invalid record");
    1091             : 
    1092        1346 :     unsigned Size = Record.size();
    1093             :     SmallVector<Metadata *, 8> Elts;
    1094       22314 :     for (unsigned i = 0; i != Size; i += 2) {
    1095       20968 :       Type *Ty = getTypeByID(Record[i]);
    1096       10484 :       if (!Ty)
    1097           0 :         return error("Invalid record");
    1098       10484 :       if (Ty->isMetadataTy())
    1099       11206 :         Elts.push_back(getMD(Record[i + 1]));
    1100        4881 :       else if (!Ty->isVoidTy()) {
    1101             :         auto *MD =
    1102        9248 :             ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
    1103             :         assert(isa<ConstantAsMetadata>(MD) &&
    1104             :                "Expected non-function-local metadata");
    1105        4624 :         Elts.push_back(MD);
    1106             :       } else
    1107         257 :         Elts.push_back(nullptr);
    1108             :     }
    1109        4038 :     MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
    1110        1346 :     NextMetadataNo++;
    1111             :     break;
    1112             :   }
    1113        5905 :   case bitc::METADATA_VALUE: {
    1114        5905 :     if (Record.size() != 2)
    1115           0 :       return error("Invalid record");
    1116             : 
    1117        5905 :     Type *Ty = getTypeByID(Record[0]);
    1118        5905 :     if (Ty->isMetadataTy() || Ty->isVoidTy())
    1119           0 :       return error("Invalid record");
    1120             : 
    1121       11810 :     MetadataList.assignValue(
    1122       11810 :         ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
    1123             :         NextMetadataNo);
    1124        5905 :     NextMetadataNo++;
    1125        5905 :     break;
    1126             :   }
    1127        1608 :   case bitc::METADATA_DISTINCT_NODE:
    1128        1608 :     IsDistinct = true;
    1129             :     LLVM_FALLTHROUGH;
    1130        6914 :   case bitc::METADATA_NODE: {
    1131             :     SmallVector<Metadata *, 8> Elts;
    1132        6914 :     Elts.reserve(Record.size());
    1133       49560 :     for (unsigned ID : Record)
    1134       21323 :       Elts.push_back(getMDOrNull(ID));
    1135       15436 :     MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
    1136        5306 :                                         : MDNode::get(Context, Elts),
    1137             :                              NextMetadataNo);
    1138        6914 :     NextMetadataNo++;
    1139             :     break;
    1140             :   }
    1141          36 :   case bitc::METADATA_LOCATION: {
    1142          36 :     if (Record.size() != 5)
    1143           0 :       return error("Invalid record");
    1144             : 
    1145          36 :     IsDistinct = Record[0];
    1146          36 :     unsigned Line = Record[1];
    1147          36 :     unsigned Column = Record[2];
    1148          36 :     Metadata *Scope = getMD(Record[3]);
    1149          36 :     Metadata *InlinedAt = getMDOrNull(Record[4]);
    1150          72 :     MetadataList.assignValue(
    1151          36 :         GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt)),
    1152             :         NextMetadataNo);
    1153          36 :     NextMetadataNo++;
    1154          36 :     break;
    1155             :   }
    1156          20 :   case bitc::METADATA_GENERIC_DEBUG: {
    1157          20 :     if (Record.size() < 4)
    1158           0 :       return error("Invalid record");
    1159             : 
    1160          20 :     IsDistinct = Record[0];
    1161          20 :     unsigned Tag = Record[1];
    1162          20 :     unsigned Version = Record[2];
    1163             : 
    1164          20 :     if (Tag >= 1u << 16 || Version != 0)
    1165           0 :       return error("Invalid record");
    1166             : 
    1167          20 :     auto *Header = getMDString(Record[3]);
    1168             :     SmallVector<Metadata *, 8> DwarfOps;
    1169          35 :     for (unsigned I = 4, E = Record.size(); I != E; ++I)
    1170          30 :       DwarfOps.push_back(getMDOrNull(Record[I]));
    1171          40 :     MetadataList.assignValue(
    1172          20 :         GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
    1173             :         NextMetadataNo);
    1174          20 :     NextMetadataNo++;
    1175             :     break;
    1176             :   }
    1177          42 :   case bitc::METADATA_SUBRANGE: {
    1178             :     Metadata *Val = nullptr;
    1179             :     // Operand 'count' is interpreted as:
    1180             :     // - Signed integer (version 0)
    1181             :     // - Metadata node  (version 1)
    1182          42 :     switch (Record[0] >> 1) {
    1183             :     case 0:
    1184           4 :       Val = GET_OR_DISTINCT(DISubrange,
    1185             :                             (Context, Record[1], unrotateSign(Record.back())));
    1186           2 :       break;
    1187             :     case 1:
    1188          80 :       Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
    1189             :                                          unrotateSign(Record.back())));
    1190          40 :       break;
    1191             :     default:
    1192           0 :       return error("Invalid record: Unsupported version of DISubrange");
    1193             :     }
    1194             : 
    1195          42 :     MetadataList.assignValue(Val, NextMetadataNo);
    1196             :     IsDistinct = Record[0] & 1;
    1197          42 :     NextMetadataNo++;
    1198          42 :     break;
    1199             :   }
    1200          32 :   case bitc::METADATA_ENUMERATOR: {
    1201          32 :     if (Record.size() != 3)
    1202           0 :       return error("Invalid record");
    1203             : 
    1204          32 :     IsDistinct = Record[0] & 1;
    1205          32 :     bool IsUnsigned = Record[0] & 2;
    1206          64 :     MetadataList.assignValue(
    1207          96 :         GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
    1208             :                                        IsUnsigned, getMDString(Record[2]))),
    1209             :         NextMetadataNo);
    1210          32 :     NextMetadataNo++;
    1211          32 :     break;
    1212             :   }
    1213         191 :   case bitc::METADATA_BASIC_TYPE: {
    1214         191 :     if (Record.size() != 6)
    1215           0 :       return error("Invalid record");
    1216             : 
    1217         191 :     IsDistinct = Record[0];
    1218         382 :     MetadataList.assignValue(
    1219         382 :         GET_OR_DISTINCT(DIBasicType,
    1220             :                         (Context, Record[1], getMDString(Record[2]), Record[3],
    1221             :                          Record[4], Record[5])),
    1222             :         NextMetadataNo);
    1223         191 :     NextMetadataNo++;
    1224         191 :     break;
    1225             :   }
    1226         157 :   case bitc::METADATA_DERIVED_TYPE: {
    1227         157 :     if (Record.size() < 12 || Record.size() > 13)
    1228           0 :       return error("Invalid record");
    1229             : 
    1230             :     // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
    1231             :     // that there is no DWARF address space associated with DIDerivedType.
    1232             :     Optional<unsigned> DWARFAddressSpace;
    1233         306 :     if (Record.size() > 12 && Record[12])
    1234           6 :       DWARFAddressSpace = Record[12] - 1;
    1235             : 
    1236         157 :     IsDistinct = Record[0];
    1237         157 :     DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
    1238         314 :     MetadataList.assignValue(
    1239         942 :         GET_OR_DISTINCT(DIDerivedType,
    1240             :                         (Context, Record[1], getMDString(Record[2]),
    1241             :                          getMDOrNull(Record[3]), Record[4],
    1242             :                          getDITypeRefOrNull(Record[5]),
    1243             :                          getDITypeRefOrNull(Record[6]), Record[7], Record[8],
    1244             :                          Record[9], DWARFAddressSpace, Flags,
    1245             :                          getDITypeRefOrNull(Record[11]))),
    1246             :         NextMetadataNo);
    1247         157 :     NextMetadataNo++;
    1248             :     break;
    1249             :   }
    1250         227 :   case bitc::METADATA_COMPOSITE_TYPE: {
    1251         227 :     if (Record.size() < 16 || Record.size() > 17)
    1252           0 :       return error("Invalid record");
    1253             : 
    1254             :     // If we have a UUID and this is not a forward declaration, lookup the
    1255             :     // mapping.
    1256         227 :     IsDistinct = Record[0] & 0x1;
    1257             :     bool IsNotUsedInTypeRef = Record[0] >= 2;
    1258         227 :     unsigned Tag = Record[1];
    1259         227 :     MDString *Name = getMDString(Record[2]);
    1260         227 :     Metadata *File = getMDOrNull(Record[3]);
    1261         227 :     unsigned Line = Record[4];
    1262         227 :     Metadata *Scope = getDITypeRefOrNull(Record[5]);
    1263             :     Metadata *BaseType = nullptr;
    1264         227 :     uint64_t SizeInBits = Record[7];
    1265         227 :     if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
    1266           0 :       return error("Alignment value is too large");
    1267         227 :     uint32_t AlignInBits = Record[8];
    1268             :     uint64_t OffsetInBits = 0;
    1269         227 :     DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
    1270             :     Metadata *Elements = nullptr;
    1271         227 :     unsigned RuntimeLang = Record[12];
    1272             :     Metadata *VTableHolder = nullptr;
    1273             :     Metadata *TemplateParams = nullptr;
    1274             :     Metadata *Discriminator = nullptr;
    1275         227 :     auto *Identifier = getMDString(Record[15]);
    1276             :     // If this module is being parsed so that it can be ThinLTO imported
    1277             :     // into another module, composite types only need to be imported
    1278             :     // as type declarations (unless full type definitions requested).
    1279             :     // Create type declarations up front to save memory. Also, buildODRType
    1280             :     // handles the case where this is type ODRed with a definition needed
    1281             :     // by the importing module, in which case the existing definition is
    1282             :     // used.
    1283         273 :     if (IsImporting && !ImportFullTypeDefinitions && Identifier &&
    1284          38 :         (Tag == dwarf::DW_TAG_enumeration_type ||
    1285          19 :          Tag == dwarf::DW_TAG_class_type ||
    1286          22 :          Tag == dwarf::DW_TAG_structure_type ||
    1287          11 :          Tag == dwarf::DW_TAG_union_type)) {
    1288             :       Flags = Flags | DINode::FlagFwdDecl;
    1289             :     } else {
    1290         208 :       BaseType = getDITypeRefOrNull(Record[6]);
    1291         208 :       OffsetInBits = Record[9];
    1292         208 :       Elements = getMDOrNull(Record[11]);
    1293         208 :       VTableHolder = getDITypeRefOrNull(Record[13]);
    1294         208 :       TemplateParams = getMDOrNull(Record[14]);
    1295         208 :       if (Record.size() > 16)
    1296         198 :         Discriminator = getMDOrNull(Record[16]);
    1297             :     }
    1298             :     DICompositeType *CT = nullptr;
    1299         227 :     if (Identifier)
    1300         160 :       CT = DICompositeType::buildODRType(
    1301             :           Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
    1302             :           SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
    1303             :           VTableHolder, TemplateParams, Discriminator);
    1304             : 
    1305             :     // Create a node if we didn't get a lazy ODR type.
    1306         160 :     if (!CT)
    1307         265 :       CT = GET_OR_DISTINCT(DICompositeType,
    1308             :                            (Context, Tag, Name, File, Line, Scope, BaseType,
    1309             :                             SizeInBits, AlignInBits, OffsetInBits, Flags,
    1310             :                             Elements, RuntimeLang, VTableHolder, TemplateParams,
    1311             :                             Identifier));
    1312         227 :     if (!IsNotUsedInTypeRef && Identifier)
    1313           6 :       MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
    1314             : 
    1315         227 :     MetadataList.assignValue(CT, NextMetadataNo);
    1316         227 :     NextMetadataNo++;
    1317         227 :     break;
    1318             :   }
    1319         233 :   case bitc::METADATA_SUBROUTINE_TYPE: {
    1320         233 :     if (Record.size() < 3 || Record.size() > 4)
    1321           0 :       return error("Invalid record");
    1322         233 :     bool IsOldTypeRefArray = Record[0] < 2;
    1323         460 :     unsigned CC = (Record.size() > 3) ? Record[3] : 0;
    1324             : 
    1325         233 :     IsDistinct = Record[0] & 0x1;
    1326         233 :     DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
    1327         233 :     Metadata *Types = getMDOrNull(Record[2]);
    1328         233 :     if (LLVM_UNLIKELY(IsOldTypeRefArray))
    1329           4 :       Types = MetadataList.upgradeTypeRefArray(Types);
    1330             : 
    1331         466 :     MetadataList.assignValue(
    1332         233 :         GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
    1333             :         NextMetadataNo);
    1334         233 :     NextMetadataNo++;
    1335         233 :     break;
    1336             :   }
    1337             : 
    1338          12 :   case bitc::METADATA_MODULE: {
    1339          12 :     if (Record.size() != 6)
    1340           0 :       return error("Invalid record");
    1341             : 
    1342          12 :     IsDistinct = Record[0];
    1343          24 :     MetadataList.assignValue(
    1344          60 :         GET_OR_DISTINCT(DIModule,
    1345             :                         (Context, getMDOrNull(Record[1]),
    1346             :                          getMDString(Record[2]), getMDString(Record[3]),
    1347             :                          getMDString(Record[4]), getMDString(Record[5]))),
    1348             :         NextMetadataNo);
    1349          12 :     NextMetadataNo++;
    1350          12 :     break;
    1351             :   }
    1352             : 
    1353         465 :   case bitc::METADATA_FILE: {
    1354         465 :     if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
    1355           0 :       return error("Invalid record");
    1356             : 
    1357         465 :     IsDistinct = Record[0];
    1358             :     Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
    1359             :     // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum
    1360             :     // is not present. This matches up with the old internal representation,
    1361             :     // and the old encoding for CSK_None in the ChecksumKind. The new
    1362             :     // representation reserves the value 0 in the ChecksumKind to continue to
    1363             :     // encode None in a backwards-compatible way.
    1364         913 :     if (Record.size() > 4 && Record[3] && Record[4])
    1365          24 :       Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
    1366          24 :                        getMDString(Record[4]));
    1367         930 :     MetadataList.assignValue(
    1368        1860 :         GET_OR_DISTINCT(
    1369             :             DIFile,
    1370             :             (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum,
    1371             :              Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5]))
    1372             :                                : None)),
    1373             :         NextMetadataNo);
    1374         465 :     NextMetadataNo++;
    1375             :     break;
    1376             :   }
    1377         395 :   case bitc::METADATA_COMPILE_UNIT: {
    1378         395 :     if (Record.size() < 14 || Record.size() > 19)
    1379           0 :       return error("Invalid record");
    1380             : 
    1381             :     // Ignore Record[0], which indicates whether this compile unit is
    1382             :     // distinct.  It's always distinct.
    1383         395 :     IsDistinct = true;
    1384        5463 :     auto *CU = DICompileUnit::getDistinct(
    1385             :         Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
    1386             :         Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
    1387             :         Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
    1388             :         getMDOrNull(Record[12]), getMDOrNull(Record[13]),
    1389         389 :         Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
    1390             :         Record.size() <= 14 ? 0 : Record[14],
    1391             :         Record.size() <= 16 ? true : Record[16],
    1392             :         Record.size() <= 17 ? false : Record[17],
    1393        1124 :         Record.size() <= 18 ? false : Record[18]);
    1394             : 
    1395         395 :     MetadataList.assignValue(CU, NextMetadataNo);
    1396         395 :     NextMetadataNo++;
    1397             : 
    1398             :     // Move the Upgrade the list of subprograms.
    1399         400 :     if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
    1400          10 :       CUSubprograms.push_back({CU, SPs});
    1401             :     break;
    1402             :   }
    1403         346 :   case bitc::METADATA_SUBPROGRAM: {
    1404         346 :     if (Record.size() < 18 || Record.size() > 21)
    1405           0 :       return error("Invalid record");
    1406             : 
    1407         346 :     IsDistinct =
    1408         419 :         (Record[0] & 1) || Record[8]; // All definitions should be distinct.
    1409             :     // Version 1 has a Function as Record[15].
    1410             :     // Version 2 has removed Record[15].
    1411             :     // Version 3 has the Unit as Record[15].
    1412             :     // Version 4 added thisAdjustment.
    1413             :     bool HasUnit = Record[0] >= 2;
    1414         346 :     if (HasUnit && Record.size() < 19)
    1415           0 :       return error("Invalid record");
    1416         346 :     Metadata *CUorFn = getMDOrNull(Record[15]);
    1417         346 :     unsigned Offset = Record.size() >= 19 ? 1 : 0;
    1418         346 :     bool HasFn = Offset && !HasUnit;
    1419             :     bool HasThisAdj = Record.size() >= 20;
    1420             :     bool HasThrownTypes = Record.size() >= 21;
    1421        3532 :     DISubprogram *SP = GET_OR_DISTINCT(
    1422             :         DISubprogram,
    1423             :         (Context,
    1424             :          getDITypeRefOrNull(Record[1]),                     // scope
    1425             :          getMDString(Record[2]),                            // name
    1426             :          getMDString(Record[3]),                            // linkageName
    1427             :          getMDOrNull(Record[4]),                            // file
    1428             :          Record[5],                                         // line
    1429             :          getMDOrNull(Record[6]),                            // type
    1430             :          Record[7],                                         // isLocal
    1431             :          Record[8],                                         // isDefinition
    1432             :          Record[9],                                         // scopeLine
    1433             :          getDITypeRefOrNull(Record[10]),                    // containingType
    1434             :          Record[11],                                        // virtuality
    1435             :          Record[12],                                        // virtualIndex
    1436             :          HasThisAdj ? Record[19] : 0,                       // thisAdjustment
    1437             :          static_cast<DINode::DIFlags>(Record[13]),          // flags
    1438             :          Record[14],                                        // isOptimized
    1439             :          HasUnit ? CUorFn : nullptr,                        // unit
    1440             :          getMDOrNull(Record[15 + Offset]),                  // templateParams
    1441             :          getMDOrNull(Record[16 + Offset]),                  // declaration
    1442             :          getMDOrNull(Record[17 + Offset]),                  // retainedNodes
    1443             :          HasThrownTypes ? getMDOrNull(Record[20]) : nullptr // thrownTypes
    1444             :          ));
    1445         346 :     MetadataList.assignValue(SP, NextMetadataNo);
    1446         346 :     NextMetadataNo++;
    1447             : 
    1448             :     // Upgrade sp->function mapping to function->sp mapping.
    1449         346 :     if (HasFn) {
    1450             :       if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
    1451           2 :         if (auto *F = dyn_cast<Function>(CMD->getValue())) {
    1452           2 :           if (F->isMaterializable())
    1453             :             // Defer until materialized; unmaterialized functions may not have
    1454             :             // metadata.
    1455           4 :             FunctionsWithSPs[F] = SP;
    1456           0 :           else if (!F->empty())
    1457           0 :             F->setSubprogram(SP);
    1458             :         }
    1459             :     }
    1460             :     break;
    1461             :   }
    1462          94 :   case bitc::METADATA_LEXICAL_BLOCK: {
    1463          94 :     if (Record.size() != 5)
    1464           0 :       return error("Invalid record");
    1465             : 
    1466          94 :     IsDistinct = Record[0];
    1467         188 :     MetadataList.assignValue(
    1468         188 :         GET_OR_DISTINCT(DILexicalBlock,
    1469             :                         (Context, getMDOrNull(Record[1]),
    1470             :                          getMDOrNull(Record[2]), Record[3], Record[4])),
    1471             :         NextMetadataNo);
    1472          94 :     NextMetadataNo++;
    1473          94 :     break;
    1474             :   }
    1475          42 :   case bitc::METADATA_LEXICAL_BLOCK_FILE: {
    1476          42 :     if (Record.size() != 4)
    1477           0 :       return error("Invalid record");
    1478             : 
    1479          42 :     IsDistinct = Record[0];
    1480          84 :     MetadataList.assignValue(
    1481          84 :         GET_OR_DISTINCT(DILexicalBlockFile,
    1482             :                         (Context, getMDOrNull(Record[1]),
    1483             :                          getMDOrNull(Record[2]), Record[3])),
    1484             :         NextMetadataNo);
    1485          42 :     NextMetadataNo++;
    1486          42 :     break;
    1487             :   }
    1488          38 :   case bitc::METADATA_NAMESPACE: {
    1489             :     // Newer versions of DINamespace dropped file and line.
    1490             :     MDString *Name;
    1491          38 :     if (Record.size() == 3)
    1492          37 :       Name = getMDString(Record[2]);
    1493           1 :     else if (Record.size() == 5)
    1494           1 :       Name = getMDString(Record[3]);
    1495             :     else
    1496           0 :       return error("Invalid record");
    1497             : 
    1498          38 :     IsDistinct = Record[0] & 1;
    1499          38 :     bool ExportSymbols = Record[0] & 2;
    1500          76 :     MetadataList.assignValue(
    1501          38 :         GET_OR_DISTINCT(DINamespace,
    1502             :                         (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
    1503             :         NextMetadataNo);
    1504          38 :     NextMetadataNo++;
    1505          38 :     break;
    1506             :   }
    1507          13 :   case bitc::METADATA_MACRO: {
    1508          13 :     if (Record.size() != 5)
    1509           0 :       return error("Invalid record");
    1510             : 
    1511          13 :     IsDistinct = Record[0];
    1512          26 :     MetadataList.assignValue(
    1513          39 :         GET_OR_DISTINCT(DIMacro,
    1514             :                         (Context, Record[1], Record[2], getMDString(Record[3]),
    1515             :                          getMDString(Record[4]))),
    1516             :         NextMetadataNo);
    1517          13 :     NextMetadataNo++;
    1518          13 :     break;
    1519             :   }
    1520          19 :   case bitc::METADATA_MACRO_FILE: {
    1521          19 :     if (Record.size() != 5)
    1522           0 :       return error("Invalid record");
    1523             : 
    1524          19 :     IsDistinct = Record[0];
    1525          38 :     MetadataList.assignValue(
    1526          57 :         GET_OR_DISTINCT(DIMacroFile,
    1527             :                         (Context, Record[1], Record[2], getMDOrNull(Record[3]),
    1528             :                          getMDOrNull(Record[4]))),
    1529             :         NextMetadataNo);
    1530          19 :     NextMetadataNo++;
    1531          19 :     break;
    1532             :   }
    1533          24 :   case bitc::METADATA_TEMPLATE_TYPE: {
    1534          24 :     if (Record.size() != 3)
    1535           0 :       return error("Invalid record");
    1536             : 
    1537          24 :     IsDistinct = Record[0];
    1538          96 :     MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
    1539             :                                              (Context, getMDString(Record[1]),
    1540             :                                               getDITypeRefOrNull(Record[2]))),
    1541             :                              NextMetadataNo);
    1542          24 :     NextMetadataNo++;
    1543          24 :     break;
    1544             :   }
    1545          33 :   case bitc::METADATA_TEMPLATE_VALUE: {
    1546          33 :     if (Record.size() != 5)
    1547           0 :       return error("Invalid record");
    1548             : 
    1549          33 :     IsDistinct = Record[0];
    1550          66 :     MetadataList.assignValue(
    1551         132 :         GET_OR_DISTINCT(DITemplateValueParameter,
    1552             :                         (Context, Record[1], getMDString(Record[2]),
    1553             :                          getDITypeRefOrNull(Record[3]),
    1554             :                          getMDOrNull(Record[4]))),
    1555             :         NextMetadataNo);
    1556          33 :     NextMetadataNo++;
    1557          33 :     break;
    1558             :   }
    1559          61 :   case bitc::METADATA_GLOBAL_VAR: {
    1560          61 :     if (Record.size() < 11 || Record.size() > 12)
    1561           0 :       return error("Invalid record");
    1562             : 
    1563          61 :     IsDistinct = Record[0] & 1;
    1564          61 :     unsigned Version = Record[0] >> 1;
    1565             : 
    1566          61 :     if (Version == 1) {
    1567          96 :       MetadataList.assignValue(
    1568         288 :           GET_OR_DISTINCT(DIGlobalVariable,
    1569             :                           (Context, getMDOrNull(Record[1]),
    1570             :                            getMDString(Record[2]), getMDString(Record[3]),
    1571             :                            getMDOrNull(Record[4]), Record[5],
    1572             :                            getDITypeRefOrNull(Record[6]), Record[7], Record[8],
    1573             :                            getMDOrNull(Record[10]), Record[11])),
    1574             :           NextMetadataNo);
    1575          48 :       NextMetadataNo++;
    1576          13 :     } else if (Version == 0) {
    1577             :       // Upgrade old metadata, which stored a global variable reference or a
    1578             :       // ConstantInt here.
    1579          13 :       NeedUpgradeToDIGlobalVariableExpression = true;
    1580          13 :       Metadata *Expr = getMDOrNull(Record[9]);
    1581             :       uint32_t AlignInBits = 0;
    1582          13 :       if (Record.size() > 11) {
    1583           7 :         if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
    1584           0 :           return error("Alignment value is too large");
    1585           7 :         AlignInBits = Record[11];
    1586             :       }
    1587             :       GlobalVariable *Attach = nullptr;
    1588             :       if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
    1589             :         if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
    1590             :           Attach = GV;
    1591             :           Expr = nullptr;
    1592             :         } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
    1593           3 :           Expr = DIExpression::get(Context,
    1594             :                                    {dwarf::DW_OP_constu, CI->getZExtValue(),
    1595             :                                     dwarf::DW_OP_stack_value});
    1596             :         } else {
    1597             :           Expr = nullptr;
    1598             :         }
    1599             :       }
    1600          91 :       DIGlobalVariable *DGV = GET_OR_DISTINCT(
    1601             :           DIGlobalVariable,
    1602             :           (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
    1603             :            getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
    1604             :            getDITypeRefOrNull(Record[6]), Record[7], Record[8],
    1605             :            getMDOrNull(Record[10]), AlignInBits));
    1606             : 
    1607             :       DIGlobalVariableExpression *DGVE = nullptr;
    1608          13 :       if (Attach || Expr)
    1609          20 :         DGVE = DIGlobalVariableExpression::getDistinct(
    1610           4 :             Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
    1611          13 :       if (Attach)
    1612           4 :         Attach->addDebugInfo(DGVE);
    1613             : 
    1614          13 :       auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
    1615          13 :       MetadataList.assignValue(MDNode, NextMetadataNo);
    1616          13 :       NextMetadataNo++;
    1617             :     } else
    1618           0 :       return error("Invalid record");
    1619             : 
    1620             :     break;
    1621             :   }
    1622         120 :   case bitc::METADATA_LOCAL_VAR: {
    1623             :     // 10th field is for the obseleted 'inlinedAt:' field.
    1624         120 :     if (Record.size() < 8 || Record.size() > 10)
    1625           0 :       return error("Invalid record");
    1626             : 
    1627         120 :     IsDistinct = Record[0] & 1;
    1628         120 :     bool HasAlignment = Record[0] & 2;
    1629             :     // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
    1630             :     // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
    1631             :     // this is newer version of record which doesn't have artificial tag.
    1632         127 :     bool HasTag = !HasAlignment && Record.size() > 8;
    1633         240 :     DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
    1634             :     uint32_t AlignInBits = 0;
    1635         120 :     if (HasAlignment) {
    1636         226 :       if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
    1637           0 :         return error("Alignment value is too large");
    1638         113 :       AlignInBits = Record[8 + HasTag];
    1639             :     }
    1640         240 :     MetadataList.assignValue(
    1641         840 :         GET_OR_DISTINCT(DILocalVariable,
    1642             :                         (Context, getMDOrNull(Record[1 + HasTag]),
    1643             :                          getMDString(Record[2 + HasTag]),
    1644             :                          getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
    1645             :                          getDITypeRefOrNull(Record[5 + HasTag]),
    1646             :                          Record[6 + HasTag], Flags, AlignInBits)),
    1647             :         NextMetadataNo);
    1648         120 :     NextMetadataNo++;
    1649         120 :     break;
    1650             :   }
    1651          12 :   case bitc::METADATA_LABEL: {
    1652          12 :     if (Record.size() != 5)
    1653           0 :       return error("Invalid record");
    1654             : 
    1655          12 :     IsDistinct = Record[0] & 1;
    1656          24 :     MetadataList.assignValue(
    1657          36 :         GET_OR_DISTINCT(DILabel,
    1658             :                         (Context, getMDOrNull(Record[1]),
    1659             :                          getMDString(Record[2]),
    1660             :                          getMDOrNull(Record[3]), Record[4])),
    1661             :         NextMetadataNo);
    1662          12 :     NextMetadataNo++;
    1663          12 :     break;
    1664             :   }
    1665         105 :   case bitc::METADATA_EXPRESSION: {
    1666         105 :     if (Record.size() < 1)
    1667           0 :       return error("Invalid record");
    1668             : 
    1669         105 :     IsDistinct = Record[0] & 1;
    1670         105 :     uint64_t Version = Record[0] >> 1;
    1671         105 :     auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
    1672             : 
    1673             :     SmallVector<uint64_t, 6> Buffer;
    1674         210 :     if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
    1675             :       return Err;
    1676             : 
    1677         210 :     MetadataList.assignValue(
    1678         105 :         GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
    1679         105 :     NextMetadataNo++;
    1680             :     break;
    1681             :   }
    1682          35 :   case bitc::METADATA_GLOBAL_VAR_EXPR: {
    1683          35 :     if (Record.size() != 3)
    1684           0 :       return error("Invalid record");
    1685             : 
    1686          35 :     IsDistinct = Record[0];
    1687          35 :     Metadata *Expr = getMDOrNull(Record[2]);
    1688          35 :     if (!Expr)
    1689           0 :       Expr = DIExpression::get(Context, {});
    1690          70 :     MetadataList.assignValue(
    1691          35 :         GET_OR_DISTINCT(DIGlobalVariableExpression,
    1692             :                         (Context, getMDOrNull(Record[1]), Expr)),
    1693             :         NextMetadataNo);
    1694          35 :     NextMetadataNo++;
    1695          35 :     break;
    1696             :   }
    1697          18 :   case bitc::METADATA_OBJC_PROPERTY: {
    1698          18 :     if (Record.size() != 8)
    1699           0 :       return error("Invalid record");
    1700             : 
    1701          18 :     IsDistinct = Record[0];
    1702          36 :     MetadataList.assignValue(
    1703          90 :         GET_OR_DISTINCT(DIObjCProperty,
    1704             :                         (Context, getMDString(Record[1]),
    1705             :                          getMDOrNull(Record[2]), Record[3],
    1706             :                          getMDString(Record[4]), getMDString(Record[5]),
    1707             :                          Record[6], getDITypeRefOrNull(Record[7]))),
    1708             :         NextMetadataNo);
    1709          18 :     NextMetadataNo++;
    1710          18 :     break;
    1711             :   }
    1712          31 :   case bitc::METADATA_IMPORTED_ENTITY: {
    1713          31 :     if (Record.size() != 6 && Record.size() != 7)
    1714           0 :       return error("Invalid record");
    1715             : 
    1716          31 :     IsDistinct = Record[0];
    1717             :     bool HasFile = (Record.size() == 7);
    1718          62 :     MetadataList.assignValue(
    1719         174 :         GET_OR_DISTINCT(DIImportedEntity,
    1720             :                         (Context, Record[1], getMDOrNull(Record[2]),
    1721             :                          getDITypeRefOrNull(Record[3]),
    1722             :                          HasFile ? getMDOrNull(Record[6]) : nullptr,
    1723             :                          HasFile ? Record[4] : 0, getMDString(Record[5]))),
    1724             :         NextMetadataNo);
    1725          31 :     NextMetadataNo++;
    1726          31 :     break;
    1727             :   }
    1728             :   case bitc::METADATA_STRING_OLD: {
    1729             :     std::string String(Record.begin(), Record.end());
    1730             : 
    1731             :     // Test for upgrading !llvm.loop.
    1732         274 :     HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
    1733             :     ++NumMDStringLoaded;
    1734         274 :     Metadata *MD = MDString::get(Context, String);
    1735         274 :     MetadataList.assignValue(MD, NextMetadataNo);
    1736         274 :     NextMetadataNo++;
    1737             :     break;
    1738             :   }
    1739        1280 :   case bitc::METADATA_STRINGS: {
    1740        6384 :     auto CreateNextMDString = [&](StringRef Str) {
    1741             :       ++NumMDStringLoaded;
    1742        6384 :       MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
    1743        6384 :       NextMetadataNo++;
    1744        7664 :     };
    1745        2560 :     if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
    1746             :       return Err;
    1747        1280 :     break;
    1748             :   }
    1749          73 :   case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
    1750          73 :     if (Record.size() % 2 == 0)
    1751           0 :       return error("Invalid record");
    1752          73 :     unsigned ValueID = Record[0];
    1753         146 :     if (ValueID >= ValueList.size())
    1754           0 :       return error("Invalid record");
    1755             :     if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
    1756          73 :       if (Error Err = parseGlobalObjectAttachment(
    1757          73 :               *GO, ArrayRef<uint64_t>(Record).slice(1)))
    1758             :         return Err;
    1759             :     break;
    1760             :   }
    1761         804 :   case bitc::METADATA_KIND: {
    1762             :     // Support older bitcode files that had METADATA_KIND records in a
    1763             :     // block with METADATA_BLOCK_ID.
    1764        1608 :     if (Error Err = parseMetadataKindRecord(Record))
    1765             :       return Err;
    1766             :     break;
    1767             :   }
    1768             :   }
    1769             :   return Error::success();
    1770             : #undef GET_OR_DISTINCT
    1771             : }
    1772             : 
    1773        1295 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
    1774             :     ArrayRef<uint64_t> Record, StringRef Blob,
    1775             :     function_ref<void(StringRef)> CallBack) {
    1776             :   // All the MDStrings in the block are emitted together in a single
    1777             :   // record.  The strings are concatenated and stored in a blob along with
    1778             :   // their sizes.
    1779        1295 :   if (Record.size() != 2)
    1780           0 :     return error("Invalid record: metadata strings layout");
    1781             : 
    1782        1295 :   unsigned NumStrings = Record[0];
    1783        1295 :   unsigned StringsOffset = Record[1];
    1784        1295 :   if (!NumStrings)
    1785           0 :     return error("Invalid record: metadata strings with no strings");
    1786        1295 :   if (StringsOffset > Blob.size())
    1787           0 :     return error("Invalid record: metadata strings corrupt offset");
    1788             : 
    1789             :   StringRef Lengths = Blob.slice(0, StringsOffset);
    1790             :   SimpleBitstreamCursor R(Lengths);
    1791             : 
    1792        1295 :   StringRef Strings = Blob.drop_front(StringsOffset);
    1793             :   do {
    1794             :     if (R.AtEndOfStream())
    1795           0 :       return error("Invalid record: metadata strings bad length");
    1796             : 
    1797        6478 :     unsigned Size = R.ReadVBR(6);
    1798        6478 :     if (Strings.size() < Size)
    1799           0 :       return error("Invalid record: metadata strings truncated chars");
    1800             : 
    1801             :     CallBack(Strings.slice(0, Size));
    1802        6478 :     Strings = Strings.drop_front(Size);
    1803        6478 :   } while (--NumStrings);
    1804             : 
    1805             :   return Error::success();
    1806             : }
    1807             : 
    1808         313 : Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
    1809             :     GlobalObject &GO, ArrayRef<uint64_t> Record) {
    1810             :   assert(Record.size() % 2 == 0);
    1811         680 :   for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
    1812         734 :     auto K = MDKindMap.find(Record[I]);
    1813         367 :     if (K == MDKindMap.end())
    1814           0 :       return error("Invalid ID");
    1815         734 :     MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
    1816             :     if (!MD)
    1817           0 :       return error("Invalid metadata attachment");
    1818         367 :     GO.addMetadata(K->second, *MD);
    1819             :   }
    1820             :   return Error::success();
    1821             : }
    1822             : 
    1823             : /// Parse metadata attachments.
    1824        1104 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
    1825             :     Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
    1826        1104 :   if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
    1827           0 :     return error("Invalid record");
    1828             : 
    1829             :   SmallVector<uint64_t, 64> Record;
    1830             :   PlaceholderQueue Placeholders;
    1831             : 
    1832             :   while (true) {
    1833        6131 :     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
    1834             : 
    1835        6131 :     switch (Entry.Kind) {
    1836             :     case BitstreamEntry::SubBlock: // Handled for us already.
    1837             :     case BitstreamEntry::Error:
    1838           0 :       return error("Malformed block");
    1839        1104 :     case BitstreamEntry::EndBlock:
    1840        1104 :       resolveForwardRefsAndPlaceholders(Placeholders);
    1841             :       return Error::success();
    1842             :     case BitstreamEntry::Record:
    1843             :       // The interesting case.
    1844             :       break;
    1845             :     }
    1846             : 
    1847             :     // Read a metadata attachment record.
    1848             :     Record.clear();
    1849             :     ++NumMDRecordLoaded;
    1850        5027 :     switch (Stream.readRecord(Entry.ID, Record)) {
    1851             :     default: // Default behavior: ignore.
    1852             :       break;
    1853             :     case bitc::METADATA_ATTACHMENT: {
    1854        5027 :       unsigned RecordLength = Record.size();
    1855        5027 :       if (Record.empty())
    1856           0 :         return error("Invalid record");
    1857        5027 :       if (RecordLength % 2 == 0) {
    1858             :         // A function attachment.
    1859         480 :         if (Error Err = parseGlobalObjectAttachment(F, Record))
    1860             :           return Err;
    1861         240 :         continue;
    1862             :       }
    1863             : 
    1864             :       // An instruction attachment.
    1865        9574 :       Instruction *Inst = InstructionList[Record[0]];
    1866       14553 :       for (unsigned i = 1; i != RecordLength; i = i + 2) {
    1867        9768 :         unsigned Kind = Record[i];
    1868        4884 :         DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
    1869        4884 :         if (I == MDKindMap.end())
    1870           0 :           return error("Invalid ID");
    1871        4884 :         if (I->second == LLVMContext::MD_tbaa && StripTBAA)
    1872          11 :           continue;
    1873             : 
    1874        9746 :         auto Idx = Record[i + 1];
    1875       14621 :         if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
    1876           2 :             !MetadataList.lookup(Idx)) {
    1877             :           // Load the attachment if it is in the lazy-loadable range and hasn't
    1878             :           // been loaded yet.
    1879           1 :           lazyLoadOneMetadata(Idx, Placeholders);
    1880           1 :           resolveForwardRefsAndPlaceholders(Placeholders);
    1881             :         }
    1882             : 
    1883        4873 :         Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
    1884        4873 :         if (isa<LocalAsMetadata>(Node))
    1885             :           // Drop the attachment.  This used to be legal, but there's no
    1886             :           // upgrade path.
    1887             :           break;
    1888             :         MDNode *MD = dyn_cast_or_null<MDNode>(Node);
    1889             :         if (!MD)
    1890           0 :           return error("Invalid metadata attachment");
    1891             : 
    1892        4872 :         if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
    1893           2 :           MD = upgradeInstructionLoopAttachment(*MD);
    1894             : 
    1895        4872 :         if (I->second == LLVMContext::MD_tbaa) {
    1896             :           assert(!MD->isTemporary() && "should load MDs before attachments");
    1897         393 :           MD = UpgradeTBAANode(*MD);
    1898             :         }
    1899        4872 :         Inst->setMetadata(I->second, MD);
    1900             :       }
    1901             :       break;
    1902             :     }
    1903             :     }
    1904             :   }
    1905             : }
    1906             : 
    1907             : /// Parse a single METADATA_KIND record, inserting result in MDKindMap.
    1908       80616 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
    1909             :     SmallVectorImpl<uint64_t> &Record) {
    1910       80616 :   if (Record.size() < 2)
    1911           0 :     return error("Invalid record");
    1912             : 
    1913       80616 :   unsigned Kind = Record[0];
    1914       80616 :   SmallString<8> Name(Record.begin() + 1, Record.end());
    1915             : 
    1916      161232 :   unsigned NewKind = TheModule.getMDKindID(Name.str());
    1917      161231 :   if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
    1918           0 :     return error("Conflicting METADATA_KIND records");
    1919             :   return Error::success();
    1920             : }
    1921             : 
    1922             : /// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
    1923        3191 : Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() {
    1924        3191 :   if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
    1925           0 :     return error("Invalid record");
    1926             : 
    1927             :   SmallVector<uint64_t, 64> Record;
    1928             : 
    1929             :   // Read all the records.
    1930             :   while (true) {
    1931       83003 :     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
    1932             : 
    1933       83003 :     switch (Entry.Kind) {
    1934             :     case BitstreamEntry::SubBlock: // Handled for us already.
    1935             :     case BitstreamEntry::Error:
    1936           0 :       return error("Malformed block");
    1937             :     case BitstreamEntry::EndBlock:
    1938             :       return Error::success();
    1939             :     case BitstreamEntry::Record:
    1940             :       // The interesting case.
    1941             :       break;
    1942             :     }
    1943             : 
    1944             :     // Read a record.
    1945             :     Record.clear();
    1946             :     ++NumMDRecordLoaded;
    1947       79812 :     unsigned Code = Stream.readRecord(Entry.ID, Record);
    1948       79812 :     switch (Code) {
    1949             :     default: // Default behavior: ignore.
    1950             :       break;
    1951       79812 :     case bitc::METADATA_KIND: {
    1952      159624 :       if (Error Err = parseMetadataKindRecord(Record))
    1953             :         return Err;
    1954             :       break;
    1955             :     }
    1956             :     }
    1957       79812 :   }
    1958             : }
    1959             : 
    1960           0 : MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
    1961           0 :   Pimpl = std::move(RHS.Pimpl);
    1962           0 :   return *this;
    1963             : }
    1964        3321 : MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
    1965        3321 :     : Pimpl(std::move(RHS.Pimpl)) {}
    1966             : 
    1967             : MetadataLoader::~MetadataLoader() = default;
    1968        3321 : MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
    1969             :                                BitcodeReaderValueList &ValueList,
    1970             :                                bool IsImporting,
    1971        3321 :                                std::function<Type *(unsigned)> getTypeByID)
    1972             :     : Pimpl(llvm::make_unique<MetadataLoaderImpl>(
    1973        3321 :           Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}
    1974             : 
    1975        2113 : Error MetadataLoader::parseMetadata(bool ModuleLevel) {
    1976        2113 :   return Pimpl->parseMetadata(ModuleLevel);
    1977             : }
    1978             : 
    1979       47696 : bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
    1980             : 
    1981             : /// Return the given metadata, creating a replaceable forward reference if
    1982             : /// necessary.
    1983        9682 : Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) {
    1984        9682 :   return Pimpl->getMetadataFwdRefOrLoad(Idx);
    1985             : }
    1986             : 
    1987        8096 : MDNode *MetadataLoader::getMDNodeFwdRefOrNull(unsigned Idx) {
    1988        8096 :   return Pimpl->getMDNodeFwdRefOrNull(Idx);
    1989             : }
    1990             : 
    1991       11909 : DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) {
    1992       11908 :   return Pimpl->lookupSubprogramForFunction(F);
    1993             : }
    1994             : 
    1995        1104 : Error MetadataLoader::parseMetadataAttachment(
    1996             :     Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
    1997        1104 :   return Pimpl->parseMetadataAttachment(F, InstructionList);
    1998             : }
    1999             : 
    2000        3191 : Error MetadataLoader::parseMetadataKinds() {
    2001        3191 :   return Pimpl->parseMetadataKinds();
    2002             : }
    2003             : 
    2004           2 : void MetadataLoader::setStripTBAA(bool StripTBAA) {
    2005           2 :   return Pimpl->setStripTBAA(StripTBAA);
    2006             : }
    2007             : 
    2008       23818 : bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
    2009             : 
    2010       23878 : unsigned MetadataLoader::size() const { return Pimpl->size(); }
    2011       23818 : void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }
    2012             : 
    2013       52244 : void MetadataLoader::upgradeDebugIntrinsics(Function &F) {
    2014       52244 :   return Pimpl->upgradeDebugIntrinsics(F);
    2015      303579 : }

Generated by: LCOV version 1.13