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