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