LLVM  9.0.0svn
MetadataLoader.cpp
Go to the documentation of this file.
1 //===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "MetadataLoader.h"
10 #include "ValueList.h"
11 
12 #include "llvm/ADT/APFloat.h"
13 #include "llvm/ADT/APInt.h"
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/DenseMap.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/None.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/ADT/Twine.h"
27 #include "llvm/IR/Argument.h"
28 #include "llvm/IR/Attributes.h"
29 #include "llvm/IR/AutoUpgrade.h"
30 #include "llvm/IR/BasicBlock.h"
31 #include "llvm/IR/CallingConv.h"
32 #include "llvm/IR/Comdat.h"
33 #include "llvm/IR/Constant.h"
34 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/DebugInfo.h"
37 #include "llvm/IR/DebugLoc.h"
38 #include "llvm/IR/DerivedTypes.h"
40 #include "llvm/IR/Function.h"
41 #include "llvm/IR/GVMaterializer.h"
42 #include "llvm/IR/GlobalAlias.h"
43 #include "llvm/IR/GlobalIFunc.h"
45 #include "llvm/IR/GlobalObject.h"
46 #include "llvm/IR/GlobalValue.h"
47 #include "llvm/IR/GlobalVariable.h"
48 #include "llvm/IR/InlineAsm.h"
49 #include "llvm/IR/InstrTypes.h"
50 #include "llvm/IR/Instruction.h"
51 #include "llvm/IR/Instructions.h"
52 #include "llvm/IR/IntrinsicInst.h"
53 #include "llvm/IR/Intrinsics.h"
54 #include "llvm/IR/LLVMContext.h"
55 #include "llvm/IR/Module.h"
57 #include "llvm/IR/OperandTraits.h"
58 #include "llvm/IR/TrackingMDRef.h"
59 #include "llvm/IR/Type.h"
60 #include "llvm/IR/ValueHandle.h"
62 #include "llvm/Support/Casting.h"
64 #include "llvm/Support/Compiler.h"
65 #include "llvm/Support/Debug.h"
66 #include "llvm/Support/Error.h"
71 #include <algorithm>
72 #include <cassert>
73 #include <cstddef>
74 #include <cstdint>
75 #include <deque>
76 #include <limits>
77 #include <map>
78 #include <memory>
79 #include <string>
80 #include <system_error>
81 #include <tuple>
82 #include <utility>
83 #include <vector>
84 
85 using namespace llvm;
86 
87 #define DEBUG_TYPE "bitcode-reader"
88 
89 STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded");
90 STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created");
91 STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded");
92 
93 /// Flag whether we need to import full type definitions for ThinLTO.
94 /// Currently needed for Darwin and LLDB.
96  "import-full-type-definitions", cl::init(false), cl::Hidden,
97  cl::desc("Import full type definitions for ThinLTO."));
98 
100  "disable-ondemand-mds-loading", cl::init(false), cl::Hidden,
101  cl::desc("Force disable the lazy-loading on-demand of metadata when "
102  "loading bitcode for importing."));
103 
104 namespace {
105 
106 static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; }
107 
108 class BitcodeReaderMetadataList {
109  /// Array of metadata references.
110  ///
111  /// Don't use std::vector here. Some versions of libc++ copy (instead of
112  /// move) on resize, and TrackingMDRef is very expensive to copy.
113  SmallVector<TrackingMDRef, 1> MetadataPtrs;
114 
115  /// The set of indices in MetadataPtrs above of forward references that were
116  /// generated.
117  SmallDenseSet<unsigned, 1> ForwardReference;
118 
119  /// The set of indices in MetadataPtrs above of Metadata that need to be
120  /// resolved.
121  SmallDenseSet<unsigned, 1> UnresolvedNodes;
122 
123  /// Structures for resolving old type refs.
124  struct {
129  } OldTypeRefs;
130 
132 
133 public:
134  BitcodeReaderMetadataList(LLVMContext &C) : Context(C) {}
135 
136  // vector compatibility methods
137  unsigned size() const { return MetadataPtrs.size(); }
138  void resize(unsigned N) { MetadataPtrs.resize(N); }
139  void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); }
140  void clear() { MetadataPtrs.clear(); }
141  Metadata *back() const { return MetadataPtrs.back(); }
142  void pop_back() { MetadataPtrs.pop_back(); }
143  bool empty() const { return MetadataPtrs.empty(); }
144 
145  Metadata *operator[](unsigned i) const {
146  assert(i < MetadataPtrs.size());
147  return MetadataPtrs[i];
148  }
149 
150  Metadata *lookup(unsigned I) const {
151  if (I < MetadataPtrs.size())
152  return MetadataPtrs[I];
153  return nullptr;
154  }
155 
156  void shrinkTo(unsigned N) {
157  assert(N <= size() && "Invalid shrinkTo request!");
158  assert(ForwardReference.empty() && "Unexpected forward refs");
159  assert(UnresolvedNodes.empty() && "Unexpected unresolved node");
160  MetadataPtrs.resize(N);
161  }
162 
163  /// Return the given metadata, creating a replaceable forward reference if
164  /// necessary.
165  Metadata *getMetadataFwdRef(unsigned Idx);
166 
167  /// Return the given metadata only if it is fully resolved.
168  ///
169  /// Gives the same result as \a lookup(), unless \a MDNode::isResolved()
170  /// would give \c false.
171  Metadata *getMetadataIfResolved(unsigned Idx);
172 
173  MDNode *getMDNodeFwdRefOrNull(unsigned Idx);
174  void assignValue(Metadata *MD, unsigned Idx);
175  void tryToResolveCycles();
176  bool hasFwdRefs() const { return !ForwardReference.empty(); }
177  int getNextFwdRef() {
178  assert(hasFwdRefs());
179  return *ForwardReference.begin();
180  }
181 
182  /// Upgrade a type that had an MDString reference.
183  void addTypeRef(MDString &UUID, DICompositeType &CT);
184 
185  /// Upgrade a type that had an MDString reference.
186  Metadata *upgradeTypeRef(Metadata *MaybeUUID);
187 
188  /// Upgrade a type ref array that may have MDString references.
189  Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);
190 
191 private:
192  Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
193 };
194 
195 void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
196  if (auto *MDN = dyn_cast<MDNode>(MD))
197  if (!MDN->isResolved())
198  UnresolvedNodes.insert(Idx);
199 
200  if (Idx == size()) {
201  push_back(MD);
202  return;
203  }
204 
205  if (Idx >= size())
206  resize(Idx + 1);
207 
208  TrackingMDRef &OldMD = MetadataPtrs[Idx];
209  if (!OldMD) {
210  OldMD.reset(MD);
211  return;
212  }
213 
214  // If there was a forward reference to this value, replace it.
215  TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
216  PrevMD->replaceAllUsesWith(MD);
217  ForwardReference.erase(Idx);
218 }
219 
220 Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
221  if (Idx >= size())
222  resize(Idx + 1);
223 
224  if (Metadata *MD = MetadataPtrs[Idx])
225  return MD;
226 
227  // Track forward refs to be resolved later.
228  ForwardReference.insert(Idx);
229 
230  // Create and return a placeholder, which will later be RAUW'd.
231  ++NumMDNodeTemporary;
232  Metadata *MD = MDNode::getTemporary(Context, None).release();
233  MetadataPtrs[Idx].reset(MD);
234  return MD;
235 }
236 
237 Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
238  Metadata *MD = lookup(Idx);
239  if (auto *N = dyn_cast_or_null<MDNode>(MD))
240  if (!N->isResolved())
241  return nullptr;
242  return MD;
243 }
244 
245 MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
246  return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
247 }
248 
249 void BitcodeReaderMetadataList::tryToResolveCycles() {
250  if (!ForwardReference.empty())
251  // Still forward references... can't resolve cycles.
252  return;
253 
254  // Give up on finding a full definition for any forward decls that remain.
255  for (const auto &Ref : OldTypeRefs.FwdDecls)
256  OldTypeRefs.Final.insert(Ref);
257  OldTypeRefs.FwdDecls.clear();
258 
259  // Upgrade from old type ref arrays. In strange cases, this could add to
260  // OldTypeRefs.Unknown.
261  for (const auto &Array : OldTypeRefs.Arrays)
262  Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get()));
263  OldTypeRefs.Arrays.clear();
264 
265  // Replace old string-based type refs with the resolved node, if possible.
266  // If we haven't seen the node, leave it to the verifier to complain about
267  // the invalid string reference.
268  for (const auto &Ref : OldTypeRefs.Unknown) {
269  if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
270  Ref.second->replaceAllUsesWith(CT);
271  else
272  Ref.second->replaceAllUsesWith(Ref.first);
273  }
274  OldTypeRefs.Unknown.clear();
275 
276  if (UnresolvedNodes.empty())
277  // Nothing to do.
278  return;
279 
280  // Resolve any cycles.
281  for (unsigned I : UnresolvedNodes) {
282  auto &MD = MetadataPtrs[I];
283  auto *N = dyn_cast_or_null<MDNode>(MD);
284  if (!N)
285  continue;
286 
287  assert(!N->isTemporary() && "Unexpected forward reference");
288  N->resolveCycles();
289  }
290 
291  // Make sure we return early again until there's another unresolved ref.
292  UnresolvedNodes.clear();
293 }
294 
295 void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
296  DICompositeType &CT) {
297  assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
298  if (CT.isForwardDecl())
299  OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
300  else
301  OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
302 }
303 
304 Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
305  auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
306  if (LLVM_LIKELY(!UUID))
307  return MaybeUUID;
308 
309  if (auto *CT = OldTypeRefs.Final.lookup(UUID))
310  return CT;
311 
312  auto &Ref = OldTypeRefs.Unknown[UUID];
313  if (!Ref)
314  Ref = MDNode::getTemporary(Context, None);
315  return Ref.get();
316 }
317 
318 Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
319  auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
320  if (!Tuple || Tuple->isDistinct())
321  return MaybeTuple;
322 
323  // Look through the array immediately if possible.
324  if (!Tuple->isTemporary())
325  return resolveTypeRefArray(Tuple);
326 
327  // Create and return a placeholder to use for now. Eventually
328  // resolveTypeRefArrays() will be resolve this forward reference.
329  OldTypeRefs.Arrays.emplace_back(
330  std::piecewise_construct, std::forward_as_tuple(Tuple),
331  std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
332  return OldTypeRefs.Arrays.back().second.get();
333 }
334 
335 Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
336  auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
337  if (!Tuple || Tuple->isDistinct())
338  return MaybeTuple;
339 
340  // Look through the DITypeRefArray, upgrading each DITypeRef.
342  Ops.reserve(Tuple->getNumOperands());
343  for (Metadata *MD : Tuple->operands())
344  Ops.push_back(upgradeTypeRef(MD));
345 
346  return MDTuple::get(Context, Ops);
347 }
348 
349 namespace {
350 
351 class PlaceholderQueue {
352  // Placeholders would thrash around when moved, so store in a std::deque
353  // instead of some sort of vector.
354  std::deque<DistinctMDOperandPlaceholder> PHs;
355 
356 public:
357  ~PlaceholderQueue() {
358  assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed");
359  }
360  bool empty() { return PHs.empty(); }
361  DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID);
362  void flush(BitcodeReaderMetadataList &MetadataList);
363 
364  /// Return the list of temporaries nodes in the queue, these need to be
365  /// loaded before we can flush the queue.
366  void getTemporaries(BitcodeReaderMetadataList &MetadataList,
367  DenseSet<unsigned> &Temporaries) {
368  for (auto &PH : PHs) {
369  auto ID = PH.getID();
370  auto *MD = MetadataList.lookup(ID);
371  if (!MD) {
372  Temporaries.insert(ID);
373  continue;
374  }
375  auto *N = dyn_cast_or_null<MDNode>(MD);
376  if (N && N->isTemporary())
377  Temporaries.insert(ID);
378  }
379  }
380 };
381 
382 } // end anonymous namespace
383 
384 DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
385  PHs.emplace_back(ID);
386  return PHs.back();
387 }
388 
389 void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
390  while (!PHs.empty()) {
391  auto *MD = MetadataList.lookup(PHs.front().getID());
392  assert(MD && "Flushing placeholder on unassigned MD");
393 #ifndef NDEBUG
394  if (auto *MDN = dyn_cast<MDNode>(MD))
395  assert(MDN->isResolved() &&
396  "Flushing Placeholder while cycles aren't resolved");
397 #endif
398  PHs.front().replaceUseWith(MD);
399  PHs.pop_front();
400  }
401 }
402 
403 } // anonynous namespace
404 
405 static Error error(const Twine &Message) {
406  return make_error<StringError>(
408 }
409 
411  BitcodeReaderMetadataList MetadataList;
412  BitcodeReaderValueList &ValueList;
413  BitstreamCursor &Stream;
415  Module &TheModule;
416  std::function<Type *(unsigned)> getTypeByID;
417 
418  /// Cursor associated with the lazy-loading of Metadata. This is the easy way
419  /// to keep around the right "context" (Abbrev list) to be able to jump in
420  /// the middle of the metadata block and load any record.
421  BitstreamCursor IndexCursor;
422 
423  /// Index that keeps track of MDString values.
424  std::vector<StringRef> MDStringRef;
425 
426  /// On-demand loading of a single MDString. Requires the index above to be
427  /// populated.
428  MDString *lazyLoadOneMDString(unsigned Idx);
429 
430  /// Index that keeps track of where to find a metadata record in the stream.
431  std::vector<uint64_t> GlobalMetadataBitPosIndex;
432 
433  /// Populate the index above to enable lazily loading of metadata, and load
434  /// the named metadata as well as the transitively referenced global
435  /// Metadata.
436  Expected<bool> lazyLoadModuleMetadataBlock();
437 
438  /// On-demand loading of a single metadata. Requires the index above to be
439  /// populated.
440  void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders);
441 
442  // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to
443  // point from SP to CU after a block is completly parsed.
444  std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
445 
446  /// Functions that need to be matched with subprograms when upgrading old
447  /// metadata.
449 
450  // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
452 
453  bool StripTBAA = false;
454  bool HasSeenOldLoopTags = false;
455  bool NeedUpgradeToDIGlobalVariableExpression = false;
456  bool NeedDeclareExpressionUpgrade = false;
457 
458  /// True if metadata is being parsed for a module being ThinLTO imported.
459  bool IsImporting = false;
460 
461  Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code,
462  PlaceholderQueue &Placeholders, StringRef Blob,
463  unsigned &NextMetadataNo);
464  Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
465  function_ref<void(StringRef)> CallBack);
466  Error parseGlobalObjectAttachment(GlobalObject &GO,
467  ArrayRef<uint64_t> Record);
468  Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);
469 
470  void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
471 
472  /// Upgrade old-style CU <-> SP pointers to point from SP to CU.
473  void upgradeCUSubprograms() {
474  for (auto CU_SP : CUSubprograms)
475  if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
476  for (auto &Op : SPs->operands())
477  if (auto *SP = dyn_cast_or_null<DISubprogram>(Op))
478  SP->replaceUnit(CU_SP.first);
479  CUSubprograms.clear();
480  }
481 
482  /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
483  void upgradeCUVariables() {
484  if (!NeedUpgradeToDIGlobalVariableExpression)
485  return;
486 
487  // Upgrade list of variables attached to the CUs.
488  if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
489  for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
490  auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
491  if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
492  for (unsigned I = 0; I < GVs->getNumOperands(); I++)
493  if (auto *GV =
494  dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
496  Context, GV, DIExpression::get(Context, {}));
497  GVs->replaceOperandWith(I, DGVE);
498  }
499  }
500 
501  // Upgrade variables attached to globals.
502  for (auto &GV : TheModule.globals()) {
504  GV.getMetadata(LLVMContext::MD_dbg, MDs);
505  GV.eraseMetadata(LLVMContext::MD_dbg);
506  for (auto *MD : MDs)
507  if (auto *DGV = dyn_cast_or_null<DIGlobalVariable>(MD)) {
509  Context, DGV, DIExpression::get(Context, {}));
510  GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
511  } else
512  GV.addMetadata(LLVMContext::MD_dbg, *MD);
513  }
514  }
515 
516  /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that
517  /// describes a function argument.
518  void upgradeDeclareExpressions(Function &F) {
519  if (!NeedDeclareExpressionUpgrade)
520  return;
521 
522  for (auto &BB : F)
523  for (auto &I : BB)
524  if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
525  if (auto *DIExpr = DDI->getExpression())
526  if (DIExpr->startsWithDeref() &&
527  dyn_cast_or_null<Argument>(DDI->getAddress())) {
529  Ops.append(std::next(DIExpr->elements_begin()),
530  DIExpr->elements_end());
531  auto *E = DIExpression::get(Context, Ops);
532  DDI->setOperand(2, MetadataAsValue::get(Context, E));
533  }
534  }
535 
536  /// Upgrade the expression from previous versions.
537  Error upgradeDIExpression(uint64_t FromVersion,
539  SmallVectorImpl<uint64_t> &Buffer) {
540  auto N = Expr.size();
541  switch (FromVersion) {
542  default:
543  return error("Invalid record");
544  case 0:
545  if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece)
546  Expr[N - 3] = dwarf::DW_OP_LLVM_fragment;
548  case 1:
549  // Move DW_OP_deref to the end.
550  if (N && Expr[0] == dwarf::DW_OP_deref) {
551  auto End = Expr.end();
552  if (Expr.size() >= 3 &&
553  *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment)
554  End = std::prev(End, 3);
555  std::move(std::next(Expr.begin()), End, Expr.begin());
556  *std::prev(End) = dwarf::DW_OP_deref;
557  }
558  NeedDeclareExpressionUpgrade = true;
560  case 2: {
561  // Change DW_OP_plus to DW_OP_plus_uconst.
562  // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus
563  auto SubExpr = ArrayRef<uint64_t>(Expr);
564  while (!SubExpr.empty()) {
565  // Skip past other operators with their operands
566  // for this version of the IR, obtained from
567  // from historic DIExpression::ExprOperand::getSize().
568  size_t HistoricSize;
569  switch (SubExpr.front()) {
570  default:
571  HistoricSize = 1;
572  break;
573  case dwarf::DW_OP_constu:
574  case dwarf::DW_OP_minus:
575  case dwarf::DW_OP_plus:
576  HistoricSize = 2;
577  break;
579  HistoricSize = 3;
580  break;
581  }
582 
583  // If the expression is malformed, make sure we don't
584  // copy more elements than we should.
585  HistoricSize = std::min(SubExpr.size(), HistoricSize);
586  ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1);
587 
588  switch (SubExpr.front()) {
589  case dwarf::DW_OP_plus:
590  Buffer.push_back(dwarf::DW_OP_plus_uconst);
591  Buffer.append(Args.begin(), Args.end());
592  break;
593  case dwarf::DW_OP_minus:
594  Buffer.push_back(dwarf::DW_OP_constu);
595  Buffer.append(Args.begin(), Args.end());
596  Buffer.push_back(dwarf::DW_OP_minus);
597  break;
598  default:
599  Buffer.push_back(*SubExpr.begin());
600  Buffer.append(Args.begin(), Args.end());
601  break;
602  }
603 
604  // Continue with remaining elements.
605  SubExpr = SubExpr.slice(HistoricSize);
606  }
607  Expr = MutableArrayRef<uint64_t>(Buffer);
609  }
610  case 3:
611  // Up-to-date!
612  break;
613  }
614 
615  return Error::success();
616  }
617 
618  void upgradeDebugInfo() {
619  upgradeCUSubprograms();
620  upgradeCUVariables();
621  }
622 
623 public:
625  BitcodeReaderValueList &ValueList,
626  std::function<Type *(unsigned)> getTypeByID,
627  bool IsImporting)
628  : MetadataList(TheModule.getContext()), ValueList(ValueList),
629  Stream(Stream), Context(TheModule.getContext()), TheModule(TheModule),
630  getTypeByID(std::move(getTypeByID)), IsImporting(IsImporting) {}
631 
632  Error parseMetadata(bool ModuleLevel);
633 
634  bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }
635 
637  if (ID < MDStringRef.size())
638  return lazyLoadOneMDString(ID);
639  if (auto *MD = MetadataList.lookup(ID))
640  return MD;
641  // If lazy-loading is enabled, we try recursively to load the operand
642  // instead of creating a temporary.
643  if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
644  PlaceholderQueue Placeholders;
645  lazyLoadOneMetadata(ID, Placeholders);
646  resolveForwardRefsAndPlaceholders(Placeholders);
647  return MetadataList.lookup(ID);
648  }
649  return MetadataList.getMetadataFwdRef(ID);
650  }
651 
653  return FunctionsWithSPs.lookup(F);
654  }
655 
656  bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; }
657 
658  Error parseMetadataAttachment(
659  Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
660 
661  Error parseMetadataKinds();
662 
663  void setStripTBAA(bool Value) { StripTBAA = Value; }
664  bool isStrippingTBAA() { return StripTBAA; }
665 
666  unsigned size() const { return MetadataList.size(); }
667  void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
668  void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
669 };
670 
672 MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
673  IndexCursor = Stream;
675  // Get the abbrevs, and preload record positions to make them lazy-loadable.
676  while (true) {
679  switch (Entry.Kind) {
680  case BitstreamEntry::SubBlock: // Handled for us already.
682  return error("Malformed block");
684  return true;
685  }
686  case BitstreamEntry::Record: {
687  // The interesting case.
688  ++NumMDRecordLoaded;
689  uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
690  auto Code = IndexCursor.skipRecord(Entry.ID);
691  switch (Code) {
692  case bitc::METADATA_STRINGS: {
693  // Rewind and parse the strings.
694  IndexCursor.JumpToBit(CurrentPos);
695  StringRef Blob;
696  Record.clear();
697  IndexCursor.readRecord(Entry.ID, Record, &Blob);
698  unsigned NumStrings = Record[0];
699  MDStringRef.reserve(NumStrings);
700  auto IndexNextMDString = [&](StringRef Str) {
701  MDStringRef.push_back(Str);
702  };
703  if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
704  return std::move(Err);
705  break;
706  }
708  // This is the offset to the index, when we see this we skip all the
709  // records and load only an index to these.
710  IndexCursor.JumpToBit(CurrentPos);
711  Record.clear();
712  IndexCursor.readRecord(Entry.ID, Record);
713  if (Record.size() != 2)
714  return error("Invalid record");
715  auto Offset = Record[0] + (Record[1] << 32);
716  auto BeginPos = IndexCursor.GetCurrentBitNo();
717  IndexCursor.JumpToBit(BeginPos + Offset);
718  Entry = IndexCursor.advanceSkippingSubblocks(
721  "Corrupted bitcode: Expected `Record` when trying to find the "
722  "Metadata index");
723  Record.clear();
724  auto Code = IndexCursor.readRecord(Entry.ID, Record);
725  (void)Code;
726  assert(Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
727  "`METADATA_INDEX` when trying "
728  "to find the Metadata index");
729 
730  // Delta unpack
731  auto CurrentValue = BeginPos;
732  GlobalMetadataBitPosIndex.reserve(Record.size());
733  for (auto &Elt : Record) {
734  CurrentValue += Elt;
735  GlobalMetadataBitPosIndex.push_back(CurrentValue);
736  }
737  break;
738  }
740  // We don't expect to get there, the Index is loaded when we encounter
741  // the offset.
742  return error("Corrupted Metadata block");
743  case bitc::METADATA_NAME: {
744  // Named metadata need to be materialized now and aren't deferred.
745  IndexCursor.JumpToBit(CurrentPos);
746  Record.clear();
747  unsigned Code = IndexCursor.readRecord(Entry.ID, Record);
748  assert(Code == bitc::METADATA_NAME);
749 
750  // Read name of the named metadata.
751  SmallString<8> Name(Record.begin(), Record.end());
752  Code = IndexCursor.ReadCode();
753 
754  // Named Metadata comes in two parts, we expect the name to be followed
755  // by the node
756  Record.clear();
757  unsigned NextBitCode = IndexCursor.readRecord(Code, Record);
758  assert(NextBitCode == bitc::METADATA_NAMED_NODE);
759  (void)NextBitCode;
760 
761  // Read named metadata elements.
762  unsigned Size = Record.size();
763  NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
764  for (unsigned i = 0; i != Size; ++i) {
765  // FIXME: We could use a placeholder here, however NamedMDNode are
766  // taking MDNode as operand and not using the Metadata infrastructure.
767  // It is acknowledged by 'TODO: Inherit from Metadata' in the
768  // NamedMDNode class definition.
769  MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
770  assert(MD && "Invalid metadata: expect fwd ref to MDNode");
771  NMD->addOperand(MD);
772  }
773  break;
774  }
776  // FIXME: we need to do this early because we don't materialize global
777  // value explicitly.
778  IndexCursor.JumpToBit(CurrentPos);
779  Record.clear();
780  IndexCursor.readRecord(Entry.ID, Record);
781  if (Record.size() % 2 == 0)
782  return error("Invalid record");
783  unsigned ValueID = Record[0];
784  if (ValueID >= ValueList.size())
785  return error("Invalid record");
786  if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
787  if (Error Err = parseGlobalObjectAttachment(
788  *GO, ArrayRef<uint64_t>(Record).slice(1)))
789  return std::move(Err);
790  break;
791  }
792  case bitc::METADATA_KIND:
798  case bitc::METADATA_NODE:
808  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) {
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 
1411  DINode::DIFlags Flags;
1412  DISubprogram::DISPFlags SPFlags;
1413  if (!HasSPFlags)
1414  Flags = static_cast<DINode::DIFlags>(Record[11 + 2]);
1415  else {
1416  Flags = static_cast<DINode::DIFlags>(Record[11]);
1417  SPFlags = static_cast<DISubprogram::DISPFlags>(Record[9]);
1418  }
1419 
1420  // Support for old metadata when
1421  // subprogram specific flags are placed in DIFlags.
1422  const unsigned DIFlagMainSubprogram = 1 << 21;
1423  bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram;
1424  if (HasOldMainSubprogramFlag)
1425  // Remove old DIFlagMainSubprogram from DIFlags.
1426  // Note: This assumes that any future use of bit 21 defaults to it
1427  // being 0.
1428  Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram);
1429 
1430  if (HasOldMainSubprogramFlag && HasSPFlags)
1431  SPFlags |= DISubprogram::SPFlagMainSubprogram;
1432  else if (!HasSPFlags)
1433  SPFlags = DISubprogram::toSPFlags(
1434  /*IsLocalToUnit=*/Record[7], /*IsDefinition=*/Record[8],
1435  /*IsOptimized=*/Record[14], /*Virtuality=*/Record[11],
1436  /*DIFlagMainSubprogram*/HasOldMainSubprogramFlag);
1437 
1438  // All definitions should be distinct.
1439  IsDistinct = (Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition);
1440  // Version 1 has a Function as Record[15].
1441  // Version 2 has removed Record[15].
1442  // Version 3 has the Unit as Record[15].
1443  // Version 4 added thisAdjustment.
1444  // Version 5 repacked flags into DISPFlags, changing many element numbers.
1445  bool HasUnit = Record[0] & 2;
1446  if (!HasSPFlags && HasUnit && Record.size() < 19)
1447  return error("Invalid record");
1448  if (HasSPFlags && !HasUnit)
1449  return error("Invalid record");
1450  // Accommodate older formats.
1451  bool HasFn = false;
1452  bool HasThisAdj = true;
1453  bool HasThrownTypes = true;
1454  unsigned OffsetA = 0;
1455  unsigned OffsetB = 0;
1456  if (!HasSPFlags) {
1457  OffsetA = 2;
1458  OffsetB = 2;
1459  if (Record.size() >= 19) {
1460  HasFn = !HasUnit;
1461  OffsetB++;
1462  }
1463  HasThisAdj = Record.size() >= 20;
1464  HasThrownTypes = Record.size() >= 21;
1465  }
1466  Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]);
1468  DISubprogram,
1469  (Context,
1470  getDITypeRefOrNull(Record[1]), // scope
1471  getMDString(Record[2]), // name
1472  getMDString(Record[3]), // linkageName
1473  getMDOrNull(Record[4]), // file
1474  Record[5], // line
1475  getMDOrNull(Record[6]), // type
1476  Record[7 + OffsetA], // scopeLine
1477  getDITypeRefOrNull(Record[8 + OffsetA]), // containingType
1478  Record[10 + OffsetA], // virtualIndex
1479  HasThisAdj ? Record[16 + OffsetB] : 0, // thisAdjustment
1480  Flags, // flags
1481  SPFlags, // SPFlags
1482  HasUnit ? CUorFn : nullptr, // unit
1483  getMDOrNull(Record[13 + OffsetB]), // templateParams
1484  getMDOrNull(Record[14 + OffsetB]), // declaration
1485  getMDOrNull(Record[15 + OffsetB]), // retainedNodes
1486  HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
1487  : nullptr // thrownTypes
1488  ));
1489  MetadataList.assignValue(SP, NextMetadataNo);
1490  NextMetadataNo++;
1491 
1492  // Upgrade sp->function mapping to function->sp mapping.
1493  if (HasFn) {
1494  if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1495  if (auto *F = dyn_cast<Function>(CMD->getValue())) {
1496  if (F->isMaterializable())
1497  // Defer until materialized; unmaterialized functions may not have
1498  // metadata.
1499  FunctionsWithSPs[F] = SP;
1500  else if (!F->empty())
1501  F->setSubprogram(SP);
1502  }
1503  }
1504  break;
1505  }
1507  if (Record.size() != 5)
1508  return error("Invalid record");
1509 
1510  IsDistinct = Record[0];
1511  MetadataList.assignValue(
1513  (Context, getMDOrNull(Record[1]),
1514  getMDOrNull(Record[2]), Record[3], Record[4])),
1515  NextMetadataNo);
1516  NextMetadataNo++;
1517  break;
1518  }
1520  if (Record.size() != 4)
1521  return error("Invalid record");
1522 
1523  IsDistinct = Record[0];
1524  MetadataList.assignValue(
1526  (Context, getMDOrNull(Record[1]),
1527  getMDOrNull(Record[2]), Record[3])),
1528  NextMetadataNo);
1529  NextMetadataNo++;
1530  break;
1531  }
1533  IsDistinct = Record[0] & 1;
1534  MetadataList.assignValue(
1536  (Context, getMDOrNull(Record[1]),
1537  getMDOrNull(Record[2]), getMDString(Record[3]),
1538  getMDOrNull(Record[4]), Record[5])),
1539  NextMetadataNo);
1540  NextMetadataNo++;
1541  break;
1542  }
1543  case bitc::METADATA_NAMESPACE: {
1544  // Newer versions of DINamespace dropped file and line.
1545  MDString *Name;
1546  if (Record.size() == 3)
1547  Name = getMDString(Record[2]);
1548  else if (Record.size() == 5)
1549  Name = getMDString(Record[3]);
1550  else
1551  return error("Invalid record");
1552 
1553  IsDistinct = Record[0] & 1;
1554  bool ExportSymbols = Record[0] & 2;
1555  MetadataList.assignValue(
1557  (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
1558  NextMetadataNo);
1559  NextMetadataNo++;
1560  break;
1561  }
1562  case bitc::METADATA_MACRO: {
1563  if (Record.size() != 5)
1564  return error("Invalid record");
1565 
1566  IsDistinct = Record[0];
1567  MetadataList.assignValue(
1569  (Context, Record[1], Record[2], getMDString(Record[3]),
1570  getMDString(Record[4]))),
1571  NextMetadataNo);
1572  NextMetadataNo++;
1573  break;
1574  }
1576  if (Record.size() != 5)
1577  return error("Invalid record");
1578 
1579  IsDistinct = Record[0];
1580  MetadataList.assignValue(
1582  (Context, Record[1], Record[2], getMDOrNull(Record[3]),
1583  getMDOrNull(Record[4]))),
1584  NextMetadataNo);
1585  NextMetadataNo++;
1586  break;
1587  }
1589  if (Record.size() != 3)
1590  return error("Invalid record");
1591 
1592  IsDistinct = Record[0];
1593  MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter,
1594  (Context, getMDString(Record[1]),
1595  getDITypeRefOrNull(Record[2]))),
1596  NextMetadataNo);
1597  NextMetadataNo++;
1598  break;
1599  }
1601  if (Record.size() != 5)
1602  return error("Invalid record");
1603 
1604  IsDistinct = Record[0];
1605  MetadataList.assignValue(
1607  (Context, Record[1], getMDString(Record[2]),
1608  getDITypeRefOrNull(Record[3]),
1609  getMDOrNull(Record[4]))),
1610  NextMetadataNo);
1611  NextMetadataNo++;
1612  break;
1613  }
1615  if (Record.size() < 11 || Record.size() > 13)
1616  return error("Invalid record");
1617 
1618  IsDistinct = Record[0] & 1;
1619  unsigned Version = Record[0] >> 1;
1620 
1621  if (Version == 2) {
1622  MetadataList.assignValue(
1625  (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1626  getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1627  getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1628  getMDOrNull(Record[9]), getMDOrNull(Record[10]), Record[11])),
1629  NextMetadataNo);
1630 
1631  NextMetadataNo++;
1632  } else if (Version == 1) {
1633  // No upgrade necessary. A null field will be introduced to indicate
1634  // that no parameter information is available.
1635  MetadataList.assignValue(
1637  (Context, getMDOrNull(Record[1]),
1638  getMDString(Record[2]), getMDString(Record[3]),
1639  getMDOrNull(Record[4]), Record[5],
1640  getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1641  getMDOrNull(Record[10]), nullptr, Record[11])),
1642  NextMetadataNo);
1643 
1644  NextMetadataNo++;
1645  } else if (Version == 0) {
1646  // Upgrade old metadata, which stored a global variable reference or a
1647  // ConstantInt here.
1648  NeedUpgradeToDIGlobalVariableExpression = true;
1649  Metadata *Expr = getMDOrNull(Record[9]);
1650  uint32_t AlignInBits = 0;
1651  if (Record.size() > 11) {
1652  if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
1653  return error("Alignment value is too large");
1654  AlignInBits = Record[11];
1655  }
1656  GlobalVariable *Attach = nullptr;
1657  if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
1658  if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
1659  Attach = GV;
1660  Expr = nullptr;
1661  } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
1662  Expr = DIExpression::get(Context,
1663  {dwarf::DW_OP_constu, CI->getZExtValue(),
1664  dwarf::DW_OP_stack_value});
1665  } else {
1666  Expr = nullptr;
1667  }
1668  }
1671  (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1672  getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1673  getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1674  getMDOrNull(Record[10]), nullptr, AlignInBits));
1675 
1676  DIGlobalVariableExpression *DGVE = nullptr;
1677  if (Attach || Expr)
1679  Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
1680  if (Attach)
1681  Attach->addDebugInfo(DGVE);
1682 
1683  auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
1684  MetadataList.assignValue(MDNode, NextMetadataNo);
1685  NextMetadataNo++;
1686  } else
1687  return error("Invalid record");
1688 
1689  break;
1690  }
1691  case bitc::METADATA_LOCAL_VAR: {
1692  // 10th field is for the obseleted 'inlinedAt:' field.
1693  if (Record.size() < 8 || Record.size() > 10)
1694  return error("Invalid record");
1695 
1696  IsDistinct = Record[0] & 1;
1697  bool HasAlignment = Record[0] & 2;
1698  // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
1699  // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
1700  // this is newer version of record which doesn't have artificial tag.
1701  bool HasTag = !HasAlignment && Record.size() > 8;
1702  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
1703  uint32_t AlignInBits = 0;
1704  if (HasAlignment) {
1705  if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
1706  return error("Alignment value is too large");
1707  AlignInBits = Record[8 + HasTag];
1708  }
1709  MetadataList.assignValue(
1711  (Context, getMDOrNull(Record[1 + HasTag]),
1712  getMDString(Record[2 + HasTag]),
1713  getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
1714  getDITypeRefOrNull(Record[5 + HasTag]),
1715  Record[6 + HasTag], Flags, AlignInBits)),
1716  NextMetadataNo);
1717  NextMetadataNo++;
1718  break;
1719  }
1720  case bitc::METADATA_LABEL: {
1721  if (Record.size() != 5)
1722  return error("Invalid record");
1723 
1724  IsDistinct = Record[0] & 1;
1725  MetadataList.assignValue(
1727  (Context, getMDOrNull(Record[1]),
1728  getMDString(Record[2]),
1729  getMDOrNull(Record[3]), Record[4])),
1730  NextMetadataNo);
1731  NextMetadataNo++;
1732  break;
1733  }
1735  if (Record.size() < 1)
1736  return error("Invalid record");
1737 
1738  IsDistinct = Record[0] & 1;
1739  uint64_t Version = Record[0] >> 1;
1740  auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
1741 
1742  SmallVector<uint64_t, 6> Buffer;
1743  if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
1744  return Err;
1745 
1746  MetadataList.assignValue(
1747  GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
1748  NextMetadataNo++;
1749  break;
1750  }
1752  if (Record.size() != 3)
1753  return error("Invalid record");
1754 
1755  IsDistinct = Record[0];
1756  Metadata *Expr = getMDOrNull(Record[2]);
1757  if (!Expr)
1758  Expr = DIExpression::get(Context, {});
1759  MetadataList.assignValue(
1761  (Context, getMDOrNull(Record[1]), Expr)),
1762  NextMetadataNo);
1763  NextMetadataNo++;
1764  break;
1765  }
1767  if (Record.size() != 8)
1768  return error("Invalid record");
1769 
1770  IsDistinct = Record[0];
1771  MetadataList.assignValue(
1773  (Context, getMDString(Record[1]),
1774  getMDOrNull(Record[2]), Record[3],
1775  getMDString(Record[4]), getMDString(Record[5]),
1776  Record[6], getDITypeRefOrNull(Record[7]))),
1777  NextMetadataNo);
1778  NextMetadataNo++;
1779  break;
1780  }
1782  if (Record.size() != 6 && Record.size() != 7)
1783  return error("Invalid record");
1784 
1785  IsDistinct = Record[0];
1786  bool HasFile = (Record.size() == 7);
1787  MetadataList.assignValue(
1789  (Context, Record[1], getMDOrNull(Record[2]),
1790  getDITypeRefOrNull(Record[3]),
1791  HasFile ? getMDOrNull(Record[6]) : nullptr,
1792  HasFile ? Record[4] : 0, getMDString(Record[5]))),
1793  NextMetadataNo);
1794  NextMetadataNo++;
1795  break;
1796  }
1798  std::string String(Record.begin(), Record.end());
1799 
1800  // Test for upgrading !llvm.loop.
1801  HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
1802  ++NumMDStringLoaded;
1803  Metadata *MD = MDString::get(Context, String);
1804  MetadataList.assignValue(MD, NextMetadataNo);
1805  NextMetadataNo++;
1806  break;
1807  }
1808  case bitc::METADATA_STRINGS: {
1809  auto CreateNextMDString = [&](StringRef Str) {
1810  ++NumMDStringLoaded;
1811  MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
1812  NextMetadataNo++;
1813  };
1814  if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
1815  return Err;
1816  break;
1817  }
1819  if (Record.size() % 2 == 0)
1820  return error("Invalid record");
1821  unsigned ValueID = Record[0];
1822  if (ValueID >= ValueList.size())
1823  return error("Invalid record");
1824  if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
1825  if (Error Err = parseGlobalObjectAttachment(
1826  *GO, ArrayRef<uint64_t>(Record).slice(1)))
1827  return Err;
1828  break;
1829  }
1830  case bitc::METADATA_KIND: {
1831  // Support older bitcode files that had METADATA_KIND records in a
1832  // block with METADATA_BLOCK_ID.
1833  if (Error Err = parseMetadataKindRecord(Record))
1834  return Err;
1835  break;
1836  }
1837  }
1838  return Error::success();
1839 #undef GET_OR_DISTINCT
1840 }
1841 
1842 Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
1843  ArrayRef<uint64_t> Record, StringRef Blob,
1844  function_ref<void(StringRef)> CallBack) {
1845  // All the MDStrings in the block are emitted together in a single
1846  // record. The strings are concatenated and stored in a blob along with
1847  // their sizes.
1848  if (Record.size() != 2)
1849  return error("Invalid record: metadata strings layout");
1850 
1851  unsigned NumStrings = Record[0];
1852  unsigned StringsOffset = Record[1];
1853  if (!NumStrings)
1854  return error("Invalid record: metadata strings with no strings");
1855  if (StringsOffset > Blob.size())
1856  return error("Invalid record: metadata strings corrupt offset");
1857 
1858  StringRef Lengths = Blob.slice(0, StringsOffset);
1859  SimpleBitstreamCursor R(Lengths);
1860 
1861  StringRef Strings = Blob.drop_front(StringsOffset);
1862  do {
1863  if (R.AtEndOfStream())
1864  return error("Invalid record: metadata strings bad length");
1865 
1866  unsigned Size = R.ReadVBR(6);
1867  if (Strings.size() < Size)
1868  return error("Invalid record: metadata strings truncated chars");
1869 
1870  CallBack(Strings.slice(0, Size));
1871  Strings = Strings.drop_front(Size);
1872  } while (--NumStrings);
1873 
1874  return Error::success();
1875 }
1876 
1877 Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
1878  GlobalObject &GO, ArrayRef<uint64_t> Record) {
1879  assert(Record.size() % 2 == 0);
1880  for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
1881  auto K = MDKindMap.find(Record[I]);
1882  if (K == MDKindMap.end())
1883  return error("Invalid ID");
1884  MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
1885  if (!MD)
1886  return error("Invalid metadata attachment: expect fwd ref to MDNode");
1887  GO.addMetadata(K->second, *MD);
1888  }
1889  return Error::success();
1890 }
1891 
1892 /// Parse metadata attachments.
1894  Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
1896  return error("Invalid record");
1897 
1899  PlaceholderQueue Placeholders;
1900 
1901  while (true) {
1903 
1904  switch (Entry.Kind) {
1905  case BitstreamEntry::SubBlock: // Handled for us already.
1906  case BitstreamEntry::Error:
1907  return error("Malformed block");
1909  resolveForwardRefsAndPlaceholders(Placeholders);
1910  return Error::success();
1912  // The interesting case.
1913  break;
1914  }
1915 
1916  // Read a metadata attachment record.
1917  Record.clear();
1918  ++NumMDRecordLoaded;
1919  switch (Stream.readRecord(Entry.ID, Record)) {
1920  default: // Default behavior: ignore.
1921  break;
1923  unsigned RecordLength = Record.size();
1924  if (Record.empty())
1925  return error("Invalid record");
1926  if (RecordLength % 2 == 0) {
1927  // A function attachment.
1928  if (Error Err = parseGlobalObjectAttachment(F, Record))
1929  return Err;
1930  continue;
1931  }
1932 
1933  // An instruction attachment.
1934  Instruction *Inst = InstructionList[Record[0]];
1935  for (unsigned i = 1; i != RecordLength; i = i + 2) {
1936  unsigned Kind = Record[i];
1937  DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
1938  if (I == MDKindMap.end())
1939  return error("Invalid ID");
1940  if (I->second == LLVMContext::MD_tbaa && StripTBAA)
1941  continue;
1942 
1943  auto Idx = Record[i + 1];
1944  if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
1945  !MetadataList.lookup(Idx)) {
1946  // Load the attachment if it is in the lazy-loadable range and hasn't
1947  // been loaded yet.
1948  lazyLoadOneMetadata(Idx, Placeholders);
1949  resolveForwardRefsAndPlaceholders(Placeholders);
1950  }
1951 
1952  Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
1953  if (isa<LocalAsMetadata>(Node))
1954  // Drop the attachment. This used to be legal, but there's no
1955  // upgrade path.
1956  break;
1957  MDNode *MD = dyn_cast_or_null<MDNode>(Node);
1958  if (!MD)
1959  return error("Invalid metadata attachment");
1960 
1961  if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
1963 
1964  if (I->second == LLVMContext::MD_tbaa) {
1965  assert(!MD->isTemporary() && "should load MDs before attachments");
1966  MD = UpgradeTBAANode(*MD);
1967  }
1968  Inst->setMetadata(I->second, MD);
1969  }
1970  break;
1971  }
1972  }
1973  }
1974 }
1975 
1976 /// Parse a single METADATA_KIND record, inserting result in MDKindMap.
1977 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
1978  SmallVectorImpl<uint64_t> &Record) {
1979  if (Record.size() < 2)
1980  return error("Invalid record");
1981 
1982  unsigned Kind = Record[0];
1983  SmallString<8> Name(Record.begin() + 1, Record.end());
1984 
1985  unsigned NewKind = TheModule.getMDKindID(Name.str());
1986  if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
1987  return error("Conflicting METADATA_KIND records");
1988  return Error::success();
1989 }
1990 
1991 /// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
1994  return error("Invalid record");
1995 
1997 
1998  // Read all the records.
1999  while (true) {
2001 
2002  switch (Entry.Kind) {
2003  case BitstreamEntry::SubBlock: // Handled for us already.
2004  case BitstreamEntry::Error:
2005  return error("Malformed block");
2007  return Error::success();
2009  // The interesting case.
2010  break;
2011  }
2012 
2013  // Read a record.
2014  Record.clear();
2015  ++NumMDRecordLoaded;
2016  unsigned Code = Stream.readRecord(Entry.ID, Record);
2017  switch (Code) {
2018  default: // Default behavior: ignore.
2019  break;
2020  case bitc::METADATA_KIND: {
2021  if (Error Err = parseMetadataKindRecord(Record))
2022  return Err;
2023  break;
2024  }
2025  }
2026  }
2027 }
2028 
2030  Pimpl = std::move(RHS.Pimpl);
2031  return *this;
2032 }
2034  : Pimpl(std::move(RHS.Pimpl)) {}
2035 
2038  BitcodeReaderValueList &ValueList,
2039  bool IsImporting,
2040  std::function<Type *(unsigned)> getTypeByID)
2042  Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}
2043 
2044 Error MetadataLoader::parseMetadata(bool ModuleLevel) {
2045  return Pimpl->parseMetadata(ModuleLevel);
2046 }
2047 
2048 bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
2049 
2050 /// Return the given metadata, creating a replaceable forward reference if
2051 /// necessary.
2053  return Pimpl->getMetadataFwdRefOrLoad(Idx);
2054 }
2055 
2057  return Pimpl->lookupSubprogramForFunction(F);
2058 }
2059 
2061  Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
2062  return Pimpl->parseMetadataAttachment(F, InstructionList);
2063 }
2064 
2066  return Pimpl->parseMetadataKinds();
2067 }
2068 
2069 void MetadataLoader::setStripTBAA(bool StripTBAA) {
2070  return Pimpl->setStripTBAA(StripTBAA);
2071 }
2072 
2073 bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
2074 
2075 unsigned MetadataLoader::size() const { return Pimpl->size(); }
2076 void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }
2077 
2079  return Pimpl->upgradeDebugIntrinsics(F);
2080 }
uint64_t CallInst * C
bool mayBeOldLoopAttachmentTag(StringRef Name)
Check whether a string looks like an old loop attachment tag.
Definition: AutoUpgrade.h:83
bool isStrippingTBAA()
Return true if the Loader is stripping TBAA metadata.
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:645
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1132
bool empty() const
Definition: Function.h:664
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:190
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:23
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_UNLIKELY(EXPR)
Definition: Compiler.h:191
#define LLVM_LIKELY(EXPR)
Definition: Compiler.h:190
unsigned size() const
If this flag is used, the advance() method does not automatically pop the block scope when the end of...
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
Tracking metadata reference.
Definition: TrackingMDRef.h:25
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:453
void addOperand(MDNode *M)
Definition: Metadata.cpp:1086
void emplace(ArgTypes &&... Args)
Create a new object by constructing it in place with the given arguments.
Definition: Optional.h:237
static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:116
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:259
STATISTIC(NumFunctions, "Total number of functions")
Metadata node.
Definition: Metadata.h:863
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:1403
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:369
bool isForwardDecl() const
Value * getValueFwdRef(unsigned Idx, Type *Ty)
Definition: ValueList.cpp:112
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:221
enum llvm::BitstreamEntry::@156 Kind
A tuple of MDNodes.
Definition: Metadata.h:1325
Definition: BitVector.h:937
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:80
LLVM_NODISCARD 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:620
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...
LLVM_NODISCARD StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:679
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1177
Placeholder metadata for operands of distinct MDNodes.
Definition: Metadata.h:1280
Only used in LLVM metadata.
Definition: Dwarf.h:132
Tagged union holding either a T or a Error.
Definition: CachePruning.h:22
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:50
Enumeration value.
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:250
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
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:105
bool isVoidTy() const
Return true if this is &#39;void&#39;.
Definition: Type.h:140
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Return a temporary node.
Definition: Metadata.h:1152
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1165
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:427
void setSubprogram(DISubprogram *SP)
Set the attached subprogram.
Definition: Metadata.cpp:1503
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:290
Metadata * get() const
Definition: TrackingMDRef.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
Instrumentation for Order File
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1173
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:178
std::pair< llvm::MachO::Architecture, std::string > UUID
static LocalAsMetadata * get(Value *Local)
Definition: Metadata.h:435
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:52
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1225
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:209
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
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:1166
Helper class that handles loading Metadatas and keeping them available.
static Error error(const Twine &Message)
static ValueAsMetadata * get(Value *V)
Definition: Metadata.cpp:348
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
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:1393
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:267
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:330
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:387
Type array for a subprogram.
DIFlags
Debug info flags.
MDString * getRawIdentifier() const
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:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
iterator end()
Definition: DenseMap.h:108
uint32_t Size
Definition: Profile.cpp:46
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 &&)
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:119
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:72
#define GET_OR_DISTINCT(CLASS, ARGS)
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:250
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
iterator end() const
Definition: ArrayRef.h:331
bool isTemporary() const
Definition: Metadata.h:943
void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
Definition: Metadata.cpp:1520
print Print MemDeps of function
iterator_range< global_iterator > globals()
Definition: Module.h:587
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
A single uniqued string.
Definition: Metadata.h:603
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:57
const uint64_t Version
Definition: InstrProf.h:904
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:344