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

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