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