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 
654  return FunctionsWithSPs.lookup(F);
655  }
656 
657  bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; }
658 
659  Error parseMetadataAttachment(
660  Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
661 
662  Error parseMetadataKinds();
663 
664  void setStripTBAA(bool Value) { StripTBAA = Value; }
665  bool isStrippingTBAA() { return StripTBAA; }
666 
667  unsigned size() const { return MetadataList.size(); }
668  void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
669  void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
670 };
671 
673 MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
674  IndexCursor = Stream;
676  // Get the abbrevs, and preload record positions to make them lazy-loadable.
677  while (true) {
678  BitstreamEntry Entry = IndexCursor.advanceSkippingSubblocks(
680  switch (Entry.Kind) {
681  case BitstreamEntry::SubBlock: // Handled for us already.
683  return error("Malformed block");
685  return true;
686  }
687  case BitstreamEntry::Record: {
688  // The interesting case.
689  ++NumMDRecordLoaded;
690  uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
691  auto Code = IndexCursor.skipRecord(Entry.ID);
692  switch (Code) {
693  case bitc::METADATA_STRINGS: {
694  // Rewind and parse the strings.
695  IndexCursor.JumpToBit(CurrentPos);
696  StringRef Blob;
697  Record.clear();
698  IndexCursor.readRecord(Entry.ID, Record, &Blob);
699  unsigned NumStrings = Record[0];
700  MDStringRef.reserve(NumStrings);
701  auto IndexNextMDString = [&](StringRef Str) {
702  MDStringRef.push_back(Str);
703  };
704  if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
705  return std::move(Err);
706  break;
707  }
709  // This is the offset to the index, when we see this we skip all the
710  // records and load only an index to these.
711  IndexCursor.JumpToBit(CurrentPos);
712  Record.clear();
713  IndexCursor.readRecord(Entry.ID, Record);
714  if (Record.size() != 2)
715  return error("Invalid record");
716  auto Offset = Record[0] + (Record[1] << 32);
717  auto BeginPos = IndexCursor.GetCurrentBitNo();
718  IndexCursor.JumpToBit(BeginPos + Offset);
719  Entry = IndexCursor.advanceSkippingSubblocks(
722  "Corrupted bitcode: Expected `Record` when trying to find the "
723  "Metadata index");
724  Record.clear();
725  auto Code = IndexCursor.readRecord(Entry.ID, Record);
726  (void)Code;
727  assert(Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
728  "`METADATA_INDEX` when trying "
729  "to find the Metadata index");
730 
731  // Delta unpack
732  auto CurrentValue = BeginPos;
733  GlobalMetadataBitPosIndex.reserve(Record.size());
734  for (auto &Elt : Record) {
735  CurrentValue += Elt;
736  GlobalMetadataBitPosIndex.push_back(CurrentValue);
737  }
738  break;
739  }
741  // We don't expect to get there, the Index is loaded when we encounter
742  // the offset.
743  return error("Corrupted Metadata block");
744  case bitc::METADATA_NAME: {
745  // Named metadata need to be materialized now and aren't deferred.
746  IndexCursor.JumpToBit(CurrentPos);
747  Record.clear();
748  unsigned Code = IndexCursor.readRecord(Entry.ID, Record);
749  assert(Code == bitc::METADATA_NAME);
750 
751  // Read name of the named metadata.
752  SmallString<8> Name(Record.begin(), Record.end());
753  Code = IndexCursor.ReadCode();
754 
755  // Named Metadata comes in two parts, we expect the name to be followed
756  // by the node
757  Record.clear();
758  unsigned NextBitCode = IndexCursor.readRecord(Code, Record);
759  assert(NextBitCode == bitc::METADATA_NAMED_NODE);
760  (void)NextBitCode;
761 
762  // Read named metadata elements.
763  unsigned Size = Record.size();
764  NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
765  for (unsigned i = 0; i != Size; ++i) {
766  // FIXME: We could use a placeholder here, however NamedMDNode are
767  // taking MDNode as operand and not using the Metadata infrastructure.
768  // It is acknowledged by 'TODO: Inherit from Metadata' in the
769  // NamedMDNode class definition.
770  MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
771  assert(MD && "Invalid metadata: expect fwd ref to MDNode");
772  NMD->addOperand(MD);
773  }
774  break;
775  }
777  // FIXME: we need to do this early because we don't materialize global
778  // value explicitly.
779  IndexCursor.JumpToBit(CurrentPos);
780  Record.clear();
781  IndexCursor.readRecord(Entry.ID, Record);
782  if (Record.size() % 2 == 0)
783  return error("Invalid record");
784  unsigned ValueID = Record[0];
785  if (ValueID >= ValueList.size())
786  return error("Invalid record");
787  if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
788  if (Error Err = parseGlobalObjectAttachment(
789  *GO, ArrayRef<uint64_t>(Record).slice(1)))
790  return std::move(Err);
791  break;
792  }
793  case bitc::METADATA_KIND:
799  case bitc::METADATA_NODE:
809  case bitc::METADATA_FILE:
826  // We don't expect to see any of these, if we see one, give up on
827  // lazy-loading and fallback.
828  MDStringRef.clear();
829  GlobalMetadataBitPosIndex.clear();
830  return false;
831  }
832  break;
833  }
834  }
835  }
836 }
837 
838 /// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
839 /// module level metadata.
841  if (!ModuleLevel && MetadataList.hasFwdRefs())
842  return error("Invalid metadata: fwd refs into function blocks");
843 
844  // Record the entry position so that we can jump back here and efficiently
845  // skip the whole block in case we lazy-load.
846  auto EntryPos = Stream.GetCurrentBitNo();
847 
849  return error("Invalid record");
850 
852  PlaceholderQueue Placeholders;
853 
854  // We lazy-load module-level metadata: we build an index for each record, and
855  // then load individual record as needed, starting with the named metadata.
856  if (ModuleLevel && IsImporting && MetadataList.empty() &&
858  auto SuccessOrErr = lazyLoadModuleMetadataBlock();
859  if (!SuccessOrErr)
860  return SuccessOrErr.takeError();
861  if (SuccessOrErr.get()) {
862  // An index was successfully created and we will be able to load metadata
863  // on-demand.
864  MetadataList.resize(MDStringRef.size() +
865  GlobalMetadataBitPosIndex.size());
866 
867  // Reading the named metadata created forward references and/or
868  // placeholders, that we flush here.
869  resolveForwardRefsAndPlaceholders(Placeholders);
870  upgradeDebugInfo();
871  // Return at the beginning of the block, since it is easy to skip it
872  // entirely from there.
873  Stream.ReadBlockEnd(); // Pop the abbrev block context.
874  Stream.JumpToBit(EntryPos);
875  if (Stream.SkipBlock())
876  return error("Invalid record");
877  return Error::success();
878  }
879  // Couldn't load an index, fallback to loading all the block "old-style".
880  }
881 
882  unsigned NextMetadataNo = MetadataList.size();
883 
884  // Read all the records.
885  while (true) {
886  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
887 
888  switch (Entry.Kind) {
889  case BitstreamEntry::SubBlock: // Handled for us already.
891  return error("Malformed block");
893  resolveForwardRefsAndPlaceholders(Placeholders);
894  upgradeDebugInfo();
895  return Error::success();
897  // The interesting case.
898  break;
899  }
900 
901  // Read a record.
902  Record.clear();
903  StringRef Blob;
904  ++NumMDRecordLoaded;
905  unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
906  if (Error Err =
907  parseOneMetadata(Record, Code, Placeholders, Blob, NextMetadataNo))
908  return Err;
909  }
910 }
911 
912 MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) {
913  ++NumMDStringLoaded;
914  if (Metadata *MD = MetadataList.lookup(ID))
915  return cast<MDString>(MD);
916  auto MDS = MDString::get(Context, MDStringRef[ID]);
917  MetadataList.assignValue(MDS, ID);
918  return MDS;
919 }
920 
921 void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
922  unsigned ID, PlaceholderQueue &Placeholders) {
923  assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
924  assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString");
925  // Lookup first if the metadata hasn't already been loaded.
926  if (auto *MD = MetadataList.lookup(ID)) {
927  auto *N = dyn_cast_or_null<MDNode>(MD);
928  if (!N->isTemporary())
929  return;
930  }
932  StringRef Blob;
933  IndexCursor.JumpToBit(GlobalMetadataBitPosIndex[ID - MDStringRef.size()]);
934  auto Entry = IndexCursor.advanceSkippingSubblocks();
935  ++NumMDRecordLoaded;
936  unsigned Code = IndexCursor.readRecord(Entry.ID, Record, &Blob);
937  if (Error Err = parseOneMetadata(Record, Code, Placeholders, Blob, ID))
938  report_fatal_error("Can't lazyload MD");
939 }
940 
941 /// Ensure that all forward-references and placeholders are resolved.
942 /// Iteratively lazy-loading metadata on-demand if needed.
943 void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
944  PlaceholderQueue &Placeholders) {
945  DenseSet<unsigned> Temporaries;
946  while (1) {
947  // Populate Temporaries with the placeholders that haven't been loaded yet.
948  Placeholders.getTemporaries(MetadataList, Temporaries);
949 
950  // If we don't have any temporary, or FwdReference, we're done!
951  if (Temporaries.empty() && !MetadataList.hasFwdRefs())
952  break;
953 
954  // First, load all the temporaries. This can add new placeholders or
955  // forward references.
956  for (auto ID : Temporaries)
957  lazyLoadOneMetadata(ID, Placeholders);
958  Temporaries.clear();
959 
960  // Second, load the forward-references. This can also add new placeholders
961  // or forward references.
962  while (MetadataList.hasFwdRefs())
963  lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
964  }
965  // At this point we don't have any forward reference remaining, or temporary
966  // that haven't been loaded. We can safely drop RAUW support and mark cycles
967  // as resolved.
968  MetadataList.tryToResolveCycles();
969 
970  // Finally, everything is in place, we can replace the placeholders operands
971  // with the final node they refer to.
972  Placeholders.flush(MetadataList);
973 }
974 
975 Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
976  SmallVectorImpl<uint64_t> &Record, unsigned Code,
977  PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) {
978 
979  bool IsDistinct = false;
980  auto getMD = [&](unsigned ID) -> Metadata * {
981  if (ID < MDStringRef.size())
982  return lazyLoadOneMDString(ID);
983  if (!IsDistinct) {
984  if (auto *MD = MetadataList.lookup(ID))
985  return MD;
986  // If lazy-loading is enabled, we try recursively to load the operand
987  // instead of creating a temporary.
988  if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
989  // Create a temporary for the node that is referencing the operand we
990  // will lazy-load. It is needed before recursing in case there are
991  // uniquing cycles.
992  MetadataList.getMetadataFwdRef(NextMetadataNo);
993  lazyLoadOneMetadata(ID, Placeholders);
994  return MetadataList.lookup(ID);
995  }
996  // Return a temporary.
997  return MetadataList.getMetadataFwdRef(ID);
998  }
999  if (auto *MD = MetadataList.getMetadataIfResolved(ID))
1000  return MD;
1001  return &Placeholders.getPlaceholderOp(ID);
1002  };
1003  auto getMDOrNull = [&](unsigned ID) -> Metadata * {
1004  if (ID)
1005  return getMD(ID - 1);
1006  return nullptr;
1007  };
1008  auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
1009  if (ID)
1010  return MetadataList.getMetadataFwdRef(ID - 1);
1011  return nullptr;
1012  };
1013  auto getMDString = [&](unsigned ID) -> MDString * {
1014  // This requires that the ID is not really a forward reference. In
1015  // particular, the MDString must already have been resolved.
1016  auto MDS = getMDOrNull(ID);
1017  return cast_or_null<MDString>(MDS);
1018  };
1019 
1020  // Support for old type refs.
1021  auto getDITypeRefOrNull = [&](unsigned ID) {
1022  return MetadataList.upgradeTypeRef(getMDOrNull(ID));
1023  };
1024 
1025 #define GET_OR_DISTINCT(CLASS, ARGS) \
1026  (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1027 
1028  switch (Code) {
1029  default: // Default behavior: ignore.
1030  break;
1031  case bitc::METADATA_NAME: {
1032  // Read name of the named metadata.
1033  SmallString<8> Name(Record.begin(), Record.end());
1034  Record.clear();
1035  Code = Stream.ReadCode();
1036 
1037  ++NumMDRecordLoaded;
1038  unsigned NextBitCode = Stream.readRecord(Code, Record);
1039  if (NextBitCode != bitc::METADATA_NAMED_NODE)
1040  return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
1041 
1042  // Read named metadata elements.
1043  unsigned Size = Record.size();
1044  NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
1045  for (unsigned i = 0; i != Size; ++i) {
1046  MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
1047  if (!MD)
1048  return error("Invalid named metadata: expect fwd ref to MDNode");
1049  NMD->addOperand(MD);
1050  }
1051  break;
1052  }
1054  // FIXME: Remove in 4.0.
1055  // This is a LocalAsMetadata record, the only type of function-local
1056  // metadata.
1057  if (Record.size() % 2 == 1)
1058  return error("Invalid record");
1059 
1060  // If this isn't a LocalAsMetadata record, we're dropping it. This used
1061  // to be legal, but there's no upgrade path.
1062  auto dropRecord = [&] {
1063  MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo);
1064  NextMetadataNo++;
1065  };
1066  if (Record.size() != 2) {
1067  dropRecord();
1068  break;
1069  }
1070 
1071  Type *Ty = getTypeByID(Record[0]);
1072  if (Ty->isMetadataTy() || Ty->isVoidTy()) {
1073  dropRecord();
1074  break;
1075  }
1076 
1077  MetadataList.assignValue(
1078  LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1079  NextMetadataNo);
1080  NextMetadataNo++;
1081  break;
1082  }
1083  case bitc::METADATA_OLD_NODE: {
1084  // FIXME: Remove in 4.0.
1085  if (Record.size() % 2 == 1)
1086  return error("Invalid record");
1087 
1088  unsigned Size = Record.size();
1090  for (unsigned i = 0; i != Size; i += 2) {
1091  Type *Ty = getTypeByID(Record[i]);
1092  if (!Ty)
1093  return error("Invalid record");
1094  if (Ty->isMetadataTy())
1095  Elts.push_back(getMD(Record[i + 1]));
1096  else if (!Ty->isVoidTy()) {
1097  auto *MD =
1098  ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
1099  assert(isa<ConstantAsMetadata>(MD) &&
1100  "Expected non-function-local metadata");
1101  Elts.push_back(MD);
1102  } else
1103  Elts.push_back(nullptr);
1104  }
1105  MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
1106  NextMetadataNo++;
1107  break;
1108  }
1109  case bitc::METADATA_VALUE: {
1110  if (Record.size() != 2)
1111  return error("Invalid record");
1112 
1113  Type *Ty = getTypeByID(Record[0]);
1114  if (Ty->isMetadataTy() || Ty->isVoidTy())
1115  return error("Invalid record");
1116 
1117  MetadataList.assignValue(
1118  ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1119  NextMetadataNo);
1120  NextMetadataNo++;
1121  break;
1122  }
1124  IsDistinct = true;
1126  case bitc::METADATA_NODE: {
1128  Elts.reserve(Record.size());
1129  for (unsigned ID : Record)
1130  Elts.push_back(getMDOrNull(ID));
1131  MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
1132  : MDNode::get(Context, Elts),
1133  NextMetadataNo);
1134  NextMetadataNo++;
1135  break;
1136  }
1137  case bitc::METADATA_LOCATION: {
1138  if (Record.size() != 5 && Record.size() != 6)
1139  return error("Invalid record");
1140 
1141  IsDistinct = Record[0];
1142  unsigned Line = Record[1];
1143  unsigned Column = Record[2];
1144  Metadata *Scope = getMD(Record[3]);
1145  Metadata *InlinedAt = getMDOrNull(Record[4]);
1146  bool ImplicitCode = Record.size() == 6 && Record[5];
1147  MetadataList.assignValue(
1148  GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt,
1149  ImplicitCode)),
1150  NextMetadataNo);
1151  NextMetadataNo++;
1152  break;
1153  }
1155  if (Record.size() < 4)
1156  return error("Invalid record");
1157 
1158  IsDistinct = Record[0];
1159  unsigned Tag = Record[1];
1160  unsigned Version = Record[2];
1161 
1162  if (Tag >= 1u << 16 || Version != 0)
1163  return error("Invalid record");
1164 
1165  auto *Header = getMDString(Record[3]);
1166  SmallVector<Metadata *, 8> DwarfOps;
1167  for (unsigned I = 4, E = Record.size(); I != E; ++I)
1168  DwarfOps.push_back(getMDOrNull(Record[I]));
1169  MetadataList.assignValue(
1170  GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
1171  NextMetadataNo);
1172  NextMetadataNo++;
1173  break;
1174  }
1175  case bitc::METADATA_SUBRANGE: {
1176  Metadata *Val = nullptr;
1177  // Operand 'count' is interpreted as:
1178  // - Signed integer (version 0)
1179  // - Metadata node (version 1)
1180  switch (Record[0] >> 1) {
1181  case 0:
1183  (Context, Record[1], unrotateSign(Record.back())));
1184  break;
1185  case 1:
1186  Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
1187  unrotateSign(Record.back())));
1188  break;
1189  default:
1190  return error("Invalid record: Unsupported version of DISubrange");
1191  }
1192 
1193  MetadataList.assignValue(Val, NextMetadataNo);
1194  IsDistinct = Record[0] & 1;
1195  NextMetadataNo++;
1196  break;
1197  }
1199  if (Record.size() != 3)
1200  return error("Invalid record");
1201 
1202  IsDistinct = Record[0] & 1;
1203  bool IsUnsigned = Record[0] & 2;
1204  MetadataList.assignValue(
1205  GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
1206  IsUnsigned, getMDString(Record[2]))),
1207  NextMetadataNo);
1208  NextMetadataNo++;
1209  break;
1210  }
1212  if (Record.size() < 6 || Record.size() > 7)
1213  return error("Invalid record");
1214 
1215  IsDistinct = Record[0];
1216  DINode::DIFlags Flags = (Record.size() > 6) ?
1217  static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero;
1218 
1219  MetadataList.assignValue(
1221  (Context, Record[1], getMDString(Record[2]), Record[3],
1222  Record[4], Record[5], Flags)),
1223  NextMetadataNo);
1224  NextMetadataNo++;
1225  break;
1226  }
1228  if (Record.size() < 12 || Record.size() > 13)
1229  return error("Invalid record");
1230 
1231  // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
1232  // that there is no DWARF address space associated with DIDerivedType.
1233  Optional<unsigned> DWARFAddressSpace;
1234  if (Record.size() > 12 && Record[12])
1235  DWARFAddressSpace = Record[12] - 1;
1236 
1237  IsDistinct = Record[0];
1238  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1239  MetadataList.assignValue(
1241  (Context, Record[1], getMDString(Record[2]),
1242  getMDOrNull(Record[3]), Record[4],
1243  getDITypeRefOrNull(Record[5]),
1244  getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1245  Record[9], DWARFAddressSpace, Flags,
1246  getDITypeRefOrNull(Record[11]))),
1247  NextMetadataNo);
1248  NextMetadataNo++;
1249  break;
1250  }
1252  if (Record.size() < 16 || Record.size() > 17)
1253  return error("Invalid record");
1254 
1255  // If we have a UUID and this is not a forward declaration, lookup the
1256  // mapping.
1257  IsDistinct = Record[0] & 0x1;
1258  bool IsNotUsedInTypeRef = Record[0] >= 2;
1259  unsigned Tag = Record[1];
1260  MDString *Name = getMDString(Record[2]);
1261  Metadata *File = getMDOrNull(Record[3]);
1262  unsigned Line = Record[4];
1263  Metadata *Scope = getDITypeRefOrNull(Record[5]);
1264  Metadata *BaseType = nullptr;
1265  uint64_t SizeInBits = Record[7];
1266  if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
1267  return error("Alignment value is too large");
1268  uint32_t AlignInBits = Record[8];
1269  uint64_t OffsetInBits = 0;
1270  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1271  Metadata *Elements = nullptr;
1272  unsigned RuntimeLang = Record[12];
1273  Metadata *VTableHolder = nullptr;
1274  Metadata *TemplateParams = nullptr;
1275  Metadata *Discriminator = nullptr;
1276  auto *Identifier = getMDString(Record[15]);
1277  // If this module is being parsed so that it can be ThinLTO imported
1278  // into another module, composite types only need to be imported
1279  // as type declarations (unless full type definitions requested).
1280  // Create type declarations up front to save memory. Also, buildODRType
1281  // handles the case where this is type ODRed with a definition needed
1282  // by the importing module, in which case the existing definition is
1283  // used.
1284  if (IsImporting && !ImportFullTypeDefinitions && Identifier &&
1285  (Tag == dwarf::DW_TAG_enumeration_type ||
1286  Tag == dwarf::DW_TAG_class_type ||
1287  Tag == dwarf::DW_TAG_structure_type ||
1288  Tag == dwarf::DW_TAG_union_type)) {
1289  Flags = Flags | DINode::FlagFwdDecl;
1290  } else {
1291  BaseType = getDITypeRefOrNull(Record[6]);
1292  OffsetInBits = Record[9];
1293  Elements = getMDOrNull(Record[11]);
1294  VTableHolder = getDITypeRefOrNull(Record[13]);
1295  TemplateParams = getMDOrNull(Record[14]);
1296  if (Record.size() > 16)
1297  Discriminator = getMDOrNull(Record[16]);
1298  }
1299  DICompositeType *CT = nullptr;
1300  if (Identifier)
1302  Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
1303  SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1304  VTableHolder, TemplateParams, Discriminator);
1305 
1306  // Create a node if we didn't get a lazy ODR type.
1307  if (!CT)
1309  (Context, Tag, Name, File, Line, Scope, BaseType,
1310  SizeInBits, AlignInBits, OffsetInBits, Flags,
1311  Elements, RuntimeLang, VTableHolder, TemplateParams,
1312  Identifier, Discriminator));
1313  if (!IsNotUsedInTypeRef && Identifier)
1314  MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
1315 
1316  MetadataList.assignValue(CT, NextMetadataNo);
1317  NextMetadataNo++;
1318  break;
1319  }
1321  if (Record.size() < 3 || Record.size() > 4)
1322  return error("Invalid record");
1323  bool IsOldTypeRefArray = Record[0] < 2;
1324  unsigned CC = (Record.size() > 3) ? Record[3] : 0;
1325 
1326  IsDistinct = Record[0] & 0x1;
1327  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
1328  Metadata *Types = getMDOrNull(Record[2]);
1329  if (LLVM_UNLIKELY(IsOldTypeRefArray))
1330  Types = MetadataList.upgradeTypeRefArray(Types);
1331 
1332  MetadataList.assignValue(
1333  GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
1334  NextMetadataNo);
1335  NextMetadataNo++;
1336  break;
1337  }
1338 
1339  case bitc::METADATA_MODULE: {
1340  if (Record.size() != 6)
1341  return error("Invalid record");
1342 
1343  IsDistinct = Record[0];
1344  MetadataList.assignValue(
1346  (Context, getMDOrNull(Record[1]),
1347  getMDString(Record[2]), getMDString(Record[3]),
1348  getMDString(Record[4]), getMDString(Record[5]))),
1349  NextMetadataNo);
1350  NextMetadataNo++;
1351  break;
1352  }
1353 
1354  case bitc::METADATA_FILE: {
1355  if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
1356  return error("Invalid record");
1357 
1358  IsDistinct = Record[0];
1360  // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum
1361  // is not present. This matches up with the old internal representation,
1362  // and the old encoding for CSK_None in the ChecksumKind. The new
1363  // representation reserves the value 0 in the ChecksumKind to continue to
1364  // encode None in a backwards-compatible way.
1365  if (Record.size() > 4 && Record[3] && Record[4])
1366  Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
1367  getMDString(Record[4]));
1368  MetadataList.assignValue(
1370  DIFile,
1371  (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum,
1372  Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5]))
1373  : None)),
1374  NextMetadataNo);
1375  NextMetadataNo++;
1376  break;
1377  }
1379  if (Record.size() < 14 || Record.size() > 19)
1380  return error("Invalid record");
1381 
1382  // Ignore Record[0], which indicates whether this compile unit is
1383  // distinct. It's always distinct.
1384  IsDistinct = true;
1386  Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
1387  Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
1388  Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
1389  getMDOrNull(Record[12]), getMDOrNull(Record[13]),
1390  Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
1391  Record.size() <= 14 ? 0 : Record[14],
1392  Record.size() <= 16 ? true : Record[16],
1393  Record.size() <= 17 ? false : Record[17],
1394  Record.size() <= 18 ? 0 : Record[18],
1395  Record.size() <= 19 ? 0 : Record[19]);
1396 
1397  MetadataList.assignValue(CU, NextMetadataNo);
1398  NextMetadataNo++;
1399 
1400  // Move the Upgrade the list of subprograms.
1401  if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
1402  CUSubprograms.push_back({CU, SPs});
1403  break;
1404  }
1406  if (Record.size() < 18 || Record.size() > 21)
1407  return error("Invalid record");
1408 
1409  bool HasSPFlags = Record[0] & 4;
1410  DISubprogram::DISPFlags SPFlags =
1411  HasSPFlags
1412  ? static_cast<DISubprogram::DISPFlags>(Record[9])
1414  /*IsLocalToUnit=*/Record[7], /*IsDefinition=*/Record[8],
1415  /*IsOptimized=*/Record[14], /*Virtuality=*/Record[11]);
1416 
1417  // All definitions should be distinct.
1418  IsDistinct = (Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition);
1419  // Version 1 has a Function as Record[15].
1420  // Version 2 has removed Record[15].
1421  // Version 3 has the Unit as Record[15].
1422  // Version 4 added thisAdjustment.
1423  // Version 5 repacked flags into DISPFlags, changing many element numbers.
1424  bool HasUnit = Record[0] & 2;
1425  if (!HasSPFlags && HasUnit && Record.size() < 19)
1426  return error("Invalid record");
1427  if (HasSPFlags && !HasUnit)
1428  return error("Invalid record");
1429  // Accommodate older formats.
1430  bool HasFn = false;
1431  bool HasThisAdj = true;
1432  bool HasThrownTypes = true;
1433  unsigned OffsetA = 0;
1434  unsigned OffsetB = 0;
1435  if (!HasSPFlags) {
1436  OffsetA = 2;
1437  OffsetB = 2;
1438  if (Record.size() >= 19) {
1439  HasFn = !HasUnit;
1440  OffsetB++;
1441  }
1442  HasThisAdj = Record.size() >= 20;
1443  HasThrownTypes = Record.size() >= 21;
1444  }
1445  Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]);
1447  DISubprogram,
1448  (Context,
1449  getDITypeRefOrNull(Record[1]), // scope
1450  getMDString(Record[2]), // name
1451  getMDString(Record[3]), // linkageName
1452  getMDOrNull(Record[4]), // file
1453  Record[5], // line
1454  getMDOrNull(Record[6]), // type
1455  Record[7 + OffsetA], // scopeLine
1456  getDITypeRefOrNull(Record[8 + OffsetA]), // containingType
1457  Record[10 + OffsetA], // virtualIndex
1458  HasThisAdj ? Record[16 + OffsetB] : 0, // thisAdjustment
1459  static_cast<DINode::DIFlags>(Record[11 + OffsetA]),// flags
1460  SPFlags, // SPFlags
1461  HasUnit ? CUorFn : nullptr, // unit
1462  getMDOrNull(Record[13 + OffsetB]), // templateParams
1463  getMDOrNull(Record[14 + OffsetB]), // declaration
1464  getMDOrNull(Record[15 + OffsetB]), // retainedNodes
1465  HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
1466  : nullptr // thrownTypes
1467  ));
1468  MetadataList.assignValue(SP, NextMetadataNo);
1469  NextMetadataNo++;
1470 
1471  // Upgrade sp->function mapping to function->sp mapping.
1472  if (HasFn) {
1473  if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1474  if (auto *F = dyn_cast<Function>(CMD->getValue())) {
1475  if (F->isMaterializable())
1476  // Defer until materialized; unmaterialized functions may not have
1477  // metadata.
1478  FunctionsWithSPs[F] = SP;
1479  else if (!F->empty())
1480  F->setSubprogram(SP);
1481  }
1482  }
1483  break;
1484  }
1486  if (Record.size() != 5)
1487  return error("Invalid record");
1488 
1489  IsDistinct = Record[0];
1490  MetadataList.assignValue(
1492  (Context, getMDOrNull(Record[1]),
1493  getMDOrNull(Record[2]), Record[3], Record[4])),
1494  NextMetadataNo);
1495  NextMetadataNo++;
1496  break;
1497  }
1499  if (Record.size() != 4)
1500  return error("Invalid record");
1501 
1502  IsDistinct = Record[0];
1503  MetadataList.assignValue(
1505  (Context, getMDOrNull(Record[1]),
1506  getMDOrNull(Record[2]), Record[3])),
1507  NextMetadataNo);
1508  NextMetadataNo++;
1509  break;
1510  }
1511  case bitc::METADATA_NAMESPACE: {
1512  // Newer versions of DINamespace dropped file and line.
1513  MDString *Name;
1514  if (Record.size() == 3)
1515  Name = getMDString(Record[2]);
1516  else if (Record.size() == 5)
1517  Name = getMDString(Record[3]);
1518  else
1519  return error("Invalid record");
1520 
1521  IsDistinct = Record[0] & 1;
1522  bool ExportSymbols = Record[0] & 2;
1523  MetadataList.assignValue(
1525  (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
1526  NextMetadataNo);
1527  NextMetadataNo++;
1528  break;
1529  }
1530  case bitc::METADATA_MACRO: {
1531  if (Record.size() != 5)
1532  return error("Invalid record");
1533 
1534  IsDistinct = Record[0];
1535  MetadataList.assignValue(
1537  (Context, Record[1], Record[2], getMDString(Record[3]),
1538  getMDString(Record[4]))),
1539  NextMetadataNo);
1540  NextMetadataNo++;
1541  break;
1542  }
1544  if (Record.size() != 5)
1545  return error("Invalid record");
1546 
1547  IsDistinct = Record[0];
1548  MetadataList.assignValue(
1550  (Context, Record[1], Record[2], getMDOrNull(Record[3]),
1551  getMDOrNull(Record[4]))),
1552  NextMetadataNo);
1553  NextMetadataNo++;
1554  break;
1555  }
1557  if (Record.size() != 3)
1558  return error("Invalid record");
1559 
1560  IsDistinct = Record[0];
1561  MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
1562  (Context, getMDString(Record[1]),
1563  getDITypeRefOrNull(Record[2]))),
1564  NextMetadataNo);
1565  NextMetadataNo++;
1566  break;
1567  }
1569  if (Record.size() != 5)
1570  return error("Invalid record");
1571 
1572  IsDistinct = Record[0];
1573  MetadataList.assignValue(
1575  (Context, Record[1], getMDString(Record[2]),
1576  getDITypeRefOrNull(Record[3]),
1577  getMDOrNull(Record[4]))),
1578  NextMetadataNo);
1579  NextMetadataNo++;
1580  break;
1581  }
1583  if (Record.size() < 11 || Record.size() > 13)
1584  return error("Invalid record");
1585 
1586  IsDistinct = Record[0] & 1;
1587  unsigned Version = Record[0] >> 1;
1588 
1589  if (Version == 2) {
1590  MetadataList.assignValue(
1593  (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1594  getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1595  getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1596  getMDOrNull(Record[9]), getMDOrNull(Record[10]), Record[11])),
1597  NextMetadataNo);
1598 
1599  NextMetadataNo++;
1600  } else if (Version == 1) {
1601  // No upgrade necessary. A null field will be introduced to indicate
1602  // that no parameter information is available.
1603  MetadataList.assignValue(
1605  (Context, getMDOrNull(Record[1]),
1606  getMDString(Record[2]), getMDString(Record[3]),
1607  getMDOrNull(Record[4]), Record[5],
1608  getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1609  getMDOrNull(Record[10]), nullptr, Record[11])),
1610  NextMetadataNo);
1611 
1612  NextMetadataNo++;
1613  } else if (Version == 0) {
1614  // Upgrade old metadata, which stored a global variable reference or a
1615  // ConstantInt here.
1616  NeedUpgradeToDIGlobalVariableExpression = true;
1617  Metadata *Expr = getMDOrNull(Record[9]);
1618  uint32_t AlignInBits = 0;
1619  if (Record.size() > 11) {
1620  if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
1621  return error("Alignment value is too large");
1622  AlignInBits = Record[11];
1623  }
1624  GlobalVariable *Attach = nullptr;
1625  if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
1626  if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
1627  Attach = GV;
1628  Expr = nullptr;
1629  } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
1630  Expr = DIExpression::get(Context,
1631  {dwarf::DW_OP_constu, CI->getZExtValue(),
1632  dwarf::DW_OP_stack_value});
1633  } else {
1634  Expr = nullptr;
1635  }
1636  }
1639  (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1640  getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1641  getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1642  getMDOrNull(Record[10]), nullptr, AlignInBits));
1643 
1644  DIGlobalVariableExpression *DGVE = nullptr;
1645  if (Attach || Expr)
1647  Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
1648  if (Attach)
1649  Attach->addDebugInfo(DGVE);
1650 
1651  auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
1652  MetadataList.assignValue(MDNode, NextMetadataNo);
1653  NextMetadataNo++;
1654  } else
1655  return error("Invalid record");
1656 
1657  break;
1658  }
1659  case bitc::METADATA_LOCAL_VAR: {
1660  // 10th field is for the obseleted 'inlinedAt:' field.
1661  if (Record.size() < 8 || Record.size() > 10)
1662  return error("Invalid record");
1663 
1664  IsDistinct = Record[0] & 1;
1665  bool HasAlignment = Record[0] & 2;
1666  // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
1667  // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
1668  // this is newer version of record which doesn't have artificial tag.
1669  bool HasTag = !HasAlignment && Record.size() > 8;
1670  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
1671  uint32_t AlignInBits = 0;
1672  if (HasAlignment) {
1673  if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
1674  return error("Alignment value is too large");
1675  AlignInBits = Record[8 + HasTag];
1676  }
1677  MetadataList.assignValue(
1679  (Context, getMDOrNull(Record[1 + HasTag]),
1680  getMDString(Record[2 + HasTag]),
1681  getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
1682  getDITypeRefOrNull(Record[5 + HasTag]),
1683  Record[6 + HasTag], Flags, AlignInBits)),
1684  NextMetadataNo);
1685  NextMetadataNo++;
1686  break;
1687  }
1688  case bitc::METADATA_LABEL: {
1689  if (Record.size() != 5)
1690  return error("Invalid record");
1691 
1692  IsDistinct = Record[0] & 1;
1693  MetadataList.assignValue(
1695  (Context, getMDOrNull(Record[1]),
1696  getMDString(Record[2]),
1697  getMDOrNull(Record[3]), Record[4])),
1698  NextMetadataNo);
1699  NextMetadataNo++;
1700  break;
1701  }
1703  if (Record.size() < 1)
1704  return error("Invalid record");
1705 
1706  IsDistinct = Record[0] & 1;
1707  uint64_t Version = Record[0] >> 1;
1708  auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
1709 
1710  SmallVector<uint64_t, 6> Buffer;
1711  if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
1712  return Err;
1713 
1714  MetadataList.assignValue(
1715  GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
1716  NextMetadataNo++;
1717  break;
1718  }
1720  if (Record.size() != 3)
1721  return error("Invalid record");
1722 
1723  IsDistinct = Record[0];
1724  Metadata *Expr = getMDOrNull(Record[2]);
1725  if (!Expr)
1726  Expr = DIExpression::get(Context, {});
1727  MetadataList.assignValue(
1729  (Context, getMDOrNull(Record[1]), Expr)),
1730  NextMetadataNo);
1731  NextMetadataNo++;
1732  break;
1733  }
1735  if (Record.size() != 8)
1736  return error("Invalid record");
1737 
1738  IsDistinct = Record[0];
1739  MetadataList.assignValue(
1741  (Context, getMDString(Record[1]),
1742  getMDOrNull(Record[2]), Record[3],
1743  getMDString(Record[4]), getMDString(Record[5]),
1744  Record[6], getDITypeRefOrNull(Record[7]))),
1745  NextMetadataNo);
1746  NextMetadataNo++;
1747  break;
1748  }
1750  if (Record.size() != 6 && Record.size() != 7)
1751  return error("Invalid record");
1752 
1753  IsDistinct = Record[0];
1754  bool HasFile = (Record.size() == 7);
1755  MetadataList.assignValue(
1757  (Context, Record[1], getMDOrNull(Record[2]),
1758  getDITypeRefOrNull(Record[3]),
1759  HasFile ? getMDOrNull(Record[6]) : nullptr,
1760  HasFile ? Record[4] : 0, getMDString(Record[5]))),
1761  NextMetadataNo);
1762  NextMetadataNo++;
1763  break;
1764  }
1766  std::string String(Record.begin(), Record.end());
1767 
1768  // Test for upgrading !llvm.loop.
1769  HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
1770  ++NumMDStringLoaded;
1771  Metadata *MD = MDString::get(Context, String);
1772  MetadataList.assignValue(MD, NextMetadataNo);
1773  NextMetadataNo++;
1774  break;
1775  }
1776  case bitc::METADATA_STRINGS: {
1777  auto CreateNextMDString = [&](StringRef Str) {
1778  ++NumMDStringLoaded;
1779  MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
1780  NextMetadataNo++;
1781  };
1782  if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
1783  return Err;
1784  break;
1785  }
1787  if (Record.size() % 2 == 0)
1788  return error("Invalid record");
1789  unsigned ValueID = Record[0];
1790  if (ValueID >= ValueList.size())
1791  return error("Invalid record");
1792  if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
1793  if (Error Err = parseGlobalObjectAttachment(
1794  *GO, ArrayRef<uint64_t>(Record).slice(1)))
1795  return Err;
1796  break;
1797  }
1798  case bitc::METADATA_KIND: {
1799  // Support older bitcode files that had METADATA_KIND records in a
1800  // block with METADATA_BLOCK_ID.
1801  if (Error Err = parseMetadataKindRecord(Record))
1802  return Err;
1803  break;
1804  }
1805  }
1806  return Error::success();
1807 #undef GET_OR_DISTINCT
1808 }
1809 
1810 Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
1811  ArrayRef<uint64_t> Record, StringRef Blob,
1812  function_ref<void(StringRef)> CallBack) {
1813  // All the MDStrings in the block are emitted together in a single
1814  // record. The strings are concatenated and stored in a blob along with
1815  // their sizes.
1816  if (Record.size() != 2)
1817  return error("Invalid record: metadata strings layout");
1818 
1819  unsigned NumStrings = Record[0];
1820  unsigned StringsOffset = Record[1];
1821  if (!NumStrings)
1822  return error("Invalid record: metadata strings with no strings");
1823  if (StringsOffset > Blob.size())
1824  return error("Invalid record: metadata strings corrupt offset");
1825 
1826  StringRef Lengths = Blob.slice(0, StringsOffset);
1827  SimpleBitstreamCursor R(Lengths);
1828 
1829  StringRef Strings = Blob.drop_front(StringsOffset);
1830  do {
1831  if (R.AtEndOfStream())
1832  return error("Invalid record: metadata strings bad length");
1833 
1834  unsigned Size = R.ReadVBR(6);
1835  if (Strings.size() < Size)
1836  return error("Invalid record: metadata strings truncated chars");
1837 
1838  CallBack(Strings.slice(0, Size));
1839  Strings = Strings.drop_front(Size);
1840  } while (--NumStrings);
1841 
1842  return Error::success();
1843 }
1844 
1845 Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
1846  GlobalObject &GO, ArrayRef<uint64_t> Record) {
1847  assert(Record.size() % 2 == 0);
1848  for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
1849  auto K = MDKindMap.find(Record[I]);
1850  if (K == MDKindMap.end())
1851  return error("Invalid ID");
1852  MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
1853  if (!MD)
1854  return error("Invalid metadata attachment: expect fwd ref to MDNode");
1855  GO.addMetadata(K->second, *MD);
1856  }
1857  return Error::success();
1858 }
1859 
1860 /// Parse metadata attachments.
1862  Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
1864  return error("Invalid record");
1865 
1867  PlaceholderQueue Placeholders;
1868 
1869  while (true) {
1870  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1871 
1872  switch (Entry.Kind) {
1873  case BitstreamEntry::SubBlock: // Handled for us already.
1874  case BitstreamEntry::Error:
1875  return error("Malformed block");
1877  resolveForwardRefsAndPlaceholders(Placeholders);
1878  return Error::success();
1880  // The interesting case.
1881  break;
1882  }
1883 
1884  // Read a metadata attachment record.
1885  Record.clear();
1886  ++NumMDRecordLoaded;
1887  switch (Stream.readRecord(Entry.ID, Record)) {
1888  default: // Default behavior: ignore.
1889  break;
1891  unsigned RecordLength = Record.size();
1892  if (Record.empty())
1893  return error("Invalid record");
1894  if (RecordLength % 2 == 0) {
1895  // A function attachment.
1896  if (Error Err = parseGlobalObjectAttachment(F, Record))
1897  return Err;
1898  continue;
1899  }
1900 
1901  // An instruction attachment.
1902  Instruction *Inst = InstructionList[Record[0]];
1903  for (unsigned i = 1; i != RecordLength; i = i + 2) {
1904  unsigned Kind = Record[i];
1905  DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
1906  if (I == MDKindMap.end())
1907  return error("Invalid ID");
1908  if (I->second == LLVMContext::MD_tbaa && StripTBAA)
1909  continue;
1910 
1911  auto Idx = Record[i + 1];
1912  if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
1913  !MetadataList.lookup(Idx)) {
1914  // Load the attachment if it is in the lazy-loadable range and hasn't
1915  // been loaded yet.
1916  lazyLoadOneMetadata(Idx, Placeholders);
1917  resolveForwardRefsAndPlaceholders(Placeholders);
1918  }
1919 
1920  Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
1921  if (isa<LocalAsMetadata>(Node))
1922  // Drop the attachment. This used to be legal, but there's no
1923  // upgrade path.
1924  break;
1925  MDNode *MD = dyn_cast_or_null<MDNode>(Node);
1926  if (!MD)
1927  return error("Invalid metadata attachment");
1928 
1929  if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
1931 
1932  if (I->second == LLVMContext::MD_tbaa) {
1933  assert(!MD->isTemporary() && "should load MDs before attachments");
1934  MD = UpgradeTBAANode(*MD);
1935  }
1936  Inst->setMetadata(I->second, MD);
1937  }
1938  break;
1939  }
1940  }
1941  }
1942 }
1943 
1944 /// Parse a single METADATA_KIND record, inserting result in MDKindMap.
1945 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
1946  SmallVectorImpl<uint64_t> &Record) {
1947  if (Record.size() < 2)
1948  return error("Invalid record");
1949 
1950  unsigned Kind = Record[0];
1951  SmallString<8> Name(Record.begin() + 1, Record.end());
1952 
1953  unsigned NewKind = TheModule.getMDKindID(Name.str());
1954  if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
1955  return error("Conflicting METADATA_KIND records");
1956  return Error::success();
1957 }
1958 
1959 /// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
1962  return error("Invalid record");
1963 
1965 
1966  // Read all the records.
1967  while (true) {
1968  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1969 
1970  switch (Entry.Kind) {
1971  case BitstreamEntry::SubBlock: // Handled for us already.
1972  case BitstreamEntry::Error:
1973  return error("Malformed block");
1975  return Error::success();
1977  // The interesting case.
1978  break;
1979  }
1980 
1981  // Read a record.
1982  Record.clear();
1983  ++NumMDRecordLoaded;
1984  unsigned Code = Stream.readRecord(Entry.ID, Record);
1985  switch (Code) {
1986  default: // Default behavior: ignore.
1987  break;
1988  case bitc::METADATA_KIND: {
1989  if (Error Err = parseMetadataKindRecord(Record))
1990  return Err;
1991  break;
1992  }
1993  }
1994  }
1995 }
1996 
1998  Pimpl = std::move(RHS.Pimpl);
1999  return *this;
2000 }
2002  : Pimpl(std::move(RHS.Pimpl)) {}
2003 
2006  BitcodeReaderValueList &ValueList,
2007  bool IsImporting,
2008  std::function<Type *(unsigned)> getTypeByID)
2010  Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}
2011 
2012 Error MetadataLoader::parseMetadata(bool ModuleLevel) {
2013  return Pimpl->parseMetadata(ModuleLevel);
2014 }
2015 
2016 bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
2017 
2018 /// Return the given metadata, creating a replaceable forward reference if
2019 /// necessary.
2021  return Pimpl->getMetadataFwdRefOrLoad(Idx);
2022 }
2023 
2025  return Pimpl->lookupSubprogramForFunction(F);
2026 }
2027 
2029  Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
2030  return Pimpl->parseMetadataAttachment(F, InstructionList);
2031 }
2032 
2034  return Pimpl->parseMetadataKinds();
2035 }
2036 
2037 void MetadataLoader::setStripTBAA(bool StripTBAA) {
2038  return Pimpl->setStripTBAA(StripTBAA);
2039 }
2040 
2041 bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
2042 
2043 unsigned MetadataLoader::size() const { return Pimpl->size(); }
2044 void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }
2045 
2047  return Pimpl->upgradeDebugIntrinsics(F);
2048 }
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.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1133
bool empty() const
Definition: Function.h:662
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:139
This class represents lattice values for constants.
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:65
#define LLVM_FALLTHROUGH
Definition: Compiler.h:86
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:135
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:111
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:255
STATISTIC(NumFunctions, "Total number of functions")
Metadata node.
Definition: Metadata.h:864
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:1343
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
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:192
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:221
A tuple of MDNodes.
Definition: Metadata.h:1326
amdgpu Simplify well known AMD library false Value Value const Twine & Name
Definition: BitVector.h:938
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:1178
Placeholder metadata for operands of distinct MDNodes.
Definition: Metadata.h:1281
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:246
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:176
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:1153
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1166
static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:419
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)
enum llvm::BitstreamEntry::@149 Kind
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:1174
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...
bool isMaterializable() const
Definition: Function.h:179
static LocalAsMetadata * get(Value *Local)
Definition: Metadata.h:436
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).
constexpr bool empty(const T &RangeOrContainer)
Test whether RangeOrContainer is empty. Similar to C++17 std::empty.
Definition: STLExtras.h:204
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:327
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:1161
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:268
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.
iterator begin() const
Definition: ArrayRef.h:331
Generic tagged DWARF-like metadata node.
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:212
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.
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:109
uint32_t Size
Definition: Profile.cpp:47
DISPFlags
Debug info subprogram flags.
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:211
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:120
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)
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
iterator end() const
Definition: ArrayRef.h:332
#define LLVM_LIKELY(EXPR)
Definition: Compiler.h:191
bool isTemporary() const
Definition: Metadata.h:944
void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
Definition: Metadata.cpp:1521
print Print MemDeps of function
iterator_range< global_iterator > globals()
Definition: Module.h:575
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:604
If this flag is used, the advance() method does not automatically pop the block scope when the end of...
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