contrib/llvm-project/llvm/lib/Bitcode/Reader/MetadataLoader.cpp

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