LLVM  8.0.0svn
Metadata.h
Go to the documentation of this file.
1 //===- llvm/IR/Metadata.h - Metadata definitions ----------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 /// @file
11 /// This file contains the declarations for metadata subclasses.
12 /// They represent the different flavors of metadata that live in LLVM.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_IR_METADATA_H
17 #define LLVM_IR_METADATA_H
18 
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/DenseMapInfo.h"
22 #include "llvm/ADT/None.h"
23 #include "llvm/ADT/PointerUnion.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/ADT/ilist_node.h"
29 #include "llvm/IR/Constant.h"
30 #include "llvm/IR/LLVMContext.h"
31 #include "llvm/IR/Value.h"
33 #include "llvm/Support/Casting.h"
35 #include <cassert>
36 #include <cstddef>
37 #include <cstdint>
38 #include <iterator>
39 #include <memory>
40 #include <string>
41 #include <type_traits>
42 #include <utility>
43 
44 namespace llvm {
45 
46 class Module;
47 class ModuleSlotTracker;
48 class raw_ostream;
49 class Type;
50 
52  DEBUG_METADATA_VERSION = 3 // Current debug info version number.
53 };
54 
55 /// Root of the metadata hierarchy.
56 ///
57 /// This is a root class for typeless data in the IR.
58 class Metadata {
60 
61  /// RTTI.
62  const unsigned char SubclassID;
63 
64 protected:
65  /// Active type of storage.
67 
68  /// Storage flag for non-uniqued, otherwise unowned, metadata.
69  unsigned char Storage : 7;
70  // TODO: expose remaining bits to subclasses.
71 
72  unsigned char ImplicitCode : 1;
73 
74  unsigned short SubclassData16 = 0;
75  unsigned SubclassData32 = 0;
76 
77 public:
78  enum MetadataKind {
79 #define HANDLE_METADATA_LEAF(CLASS) CLASS##Kind,
80 #include "llvm/IR/Metadata.def"
81  };
82 
83 protected:
85  : SubclassID(ID), Storage(Storage), ImplicitCode(false) {
86  static_assert(sizeof(*this) == 8, "Metadata fields poorly packed");
87  }
88 
89  ~Metadata() = default;
90 
91  /// Default handling of a changed operand, which asserts.
92  ///
93  /// If subclasses pass themselves in as owners to a tracking node reference,
94  /// they must provide an implementation of this method.
95  void handleChangedOperand(void *, Metadata *) {
96  llvm_unreachable("Unimplemented in Metadata subclass");
97  }
98 
99 public:
100  unsigned getMetadataID() const { return SubclassID; }
101 
102  /// User-friendly dump.
103  ///
104  /// If \c M is provided, metadata nodes will be numbered canonically;
105  /// otherwise, pointer addresses are substituted.
106  ///
107  /// Note: this uses an explicit overload instead of default arguments so that
108  /// the nullptr version is easy to call from a debugger.
109  ///
110  /// @{
111  void dump() const;
112  void dump(const Module *M) const;
113  /// @}
114 
115  /// Print.
116  ///
117  /// Prints definition of \c this.
118  ///
119  /// If \c M is provided, metadata nodes will be numbered canonically;
120  /// otherwise, pointer addresses are substituted.
121  /// @{
122  void print(raw_ostream &OS, const Module *M = nullptr,
123  bool IsForDebug = false) const;
124  void print(raw_ostream &OS, ModuleSlotTracker &MST, const Module *M = nullptr,
125  bool IsForDebug = false) const;
126  /// @}
127 
128  /// Print as operand.
129  ///
130  /// Prints reference of \c this.
131  ///
132  /// If \c M is provided, metadata nodes will be numbered canonically;
133  /// otherwise, pointer addresses are substituted.
134  /// @{
135  void printAsOperand(raw_ostream &OS, const Module *M = nullptr) const;
137  const Module *M = nullptr) const;
138  /// @}
139 };
140 
141 // Create wrappers for C Binding types (see CBindingWrapping.h).
143 
144 // Specialized opaque metadata conversions.
146  return reinterpret_cast<Metadata**>(MDs);
147 }
148 
149 #define HANDLE_METADATA(CLASS) class CLASS;
150 #include "llvm/IR/Metadata.def"
151 
152 // Provide specializations of isa so that we don't need definitions of
153 // subclasses to see if the metadata is a subclass.
154 #define HANDLE_METADATA_LEAF(CLASS) \
155  template <> struct isa_impl<CLASS, Metadata> { \
156  static inline bool doit(const Metadata &MD) { \
157  return MD.getMetadataID() == Metadata::CLASS##Kind; \
158  } \
159  };
160 #include "llvm/IR/Metadata.def"
161 
162 inline raw_ostream &operator<<(raw_ostream &OS, const Metadata &MD) {
163  MD.print(OS);
164  return OS;
165 }
166 
167 /// Metadata wrapper in the Value hierarchy.
168 ///
169 /// A member of the \a Value hierarchy to represent a reference to metadata.
170 /// This allows, e.g., instrinsics to have metadata as operands.
171 ///
172 /// Notably, this is the only thing in either hierarchy that is allowed to
173 /// reference \a LocalAsMetadata.
174 class MetadataAsValue : public Value {
176  friend class LLVMContextImpl;
177 
178  Metadata *MD;
179 
180  MetadataAsValue(Type *Ty, Metadata *MD);
181 
182  /// Drop use of metadata (during teardown).
183  void dropUse() { MD = nullptr; }
184 
185 public:
186  ~MetadataAsValue();
187 
188  static MetadataAsValue *get(LLVMContext &Context, Metadata *MD);
189  static MetadataAsValue *getIfExists(LLVMContext &Context, Metadata *MD);
190 
191  Metadata *getMetadata() const { return MD; }
192 
193  static bool classof(const Value *V) {
194  return V->getValueID() == MetadataAsValueVal;
195  }
196 
197 private:
198  void handleChangedMetadata(Metadata *MD);
199  void track();
200  void untrack();
201 };
202 
203 /// API for tracking metadata references through RAUW and deletion.
204 ///
205 /// Shared API for updating \a Metadata pointers in subclasses that support
206 /// RAUW.
207 ///
208 /// This API is not meant to be used directly. See \a TrackingMDRef for a
209 /// user-friendly tracking reference.
211 public:
212  /// Track the reference to metadata.
213  ///
214  /// Register \c MD with \c *MD, if the subclass supports tracking. If \c *MD
215  /// gets RAUW'ed, \c MD will be updated to the new address. If \c *MD gets
216  /// deleted, \c MD will be set to \c nullptr.
217  ///
218  /// If tracking isn't supported, \c *MD will not change.
219  ///
220  /// \return true iff tracking is supported by \c MD.
221  static bool track(Metadata *&MD) {
222  return track(&MD, *MD, static_cast<Metadata *>(nullptr));
223  }
224 
225  /// Track the reference to metadata for \a Metadata.
226  ///
227  /// As \a track(Metadata*&), but with support for calling back to \c Owner to
228  /// tell it that its operand changed. This could trigger \c Owner being
229  /// re-uniqued.
230  static bool track(void *Ref, Metadata &MD, Metadata &Owner) {
231  return track(Ref, MD, &Owner);
232  }
233 
234  /// Track the reference to metadata for \a MetadataAsValue.
235  ///
236  /// As \a track(Metadata*&), but with support for calling back to \c Owner to
237  /// tell it that its operand changed. This could trigger \c Owner being
238  /// re-uniqued.
239  static bool track(void *Ref, Metadata &MD, MetadataAsValue &Owner) {
240  return track(Ref, MD, &Owner);
241  }
242 
243  /// Stop tracking a reference to metadata.
244  ///
245  /// Stops \c *MD from tracking \c MD.
246  static void untrack(Metadata *&MD) { untrack(&MD, *MD); }
247  static void untrack(void *Ref, Metadata &MD);
248 
249  /// Move tracking from one reference to another.
250  ///
251  /// Semantically equivalent to \c untrack(MD) followed by \c track(New),
252  /// except that ownership callbacks are maintained.
253  ///
254  /// Note: it is an error if \c *MD does not equal \c New.
255  ///
256  /// \return true iff tracking is supported by \c MD.
257  static bool retrack(Metadata *&MD, Metadata *&New) {
258  return retrack(&MD, *MD, &New);
259  }
260  static bool retrack(void *Ref, Metadata &MD, void *New);
261 
262  /// Check whether metadata is replaceable.
263  static bool isReplaceable(const Metadata &MD);
264 
266 
267 private:
268  /// Track a reference to metadata for an owner.
269  ///
270  /// Generalized version of tracking.
271  static bool track(void *Ref, Metadata &MD, OwnerTy Owner);
272 };
273 
274 /// Shared implementation of use-lists for replaceable metadata.
275 ///
276 /// Most metadata cannot be RAUW'ed. This is a shared implementation of
277 /// use-lists and associated API for the two that support it (\a ValueAsMetadata
278 /// and \a TempMDNode).
280  friend class MetadataTracking;
281 
282 public:
284 
285 private:
287  uint64_t NextIndex = 0;
289 
290 public:
291  ReplaceableMetadataImpl(LLVMContext &Context) : Context(Context) {}
292 
294  assert(UseMap.empty() && "Cannot destroy in-use replaceable metadata");
295  }
296 
297  LLVMContext &getContext() const { return Context; }
298 
299  /// Replace all uses of this with MD.
300  ///
301  /// Replace all uses of this with \c MD, which is allowed to be null.
302  void replaceAllUsesWith(Metadata *MD);
303 
304  /// Resolve all uses of this.
305  ///
306  /// Resolve all uses of this, turning off RAUW permanently. If \c
307  /// ResolveUsers, call \a MDNode::resolve() on any users whose last operand
308  /// is resolved.
309  void resolveAllUses(bool ResolveUsers = true);
310 
311 private:
312  void addRef(void *Ref, OwnerTy Owner);
313  void dropRef(void *Ref);
314  void moveRef(void *Ref, void *New, const Metadata &MD);
315 
316  /// Lazily construct RAUW support on MD.
317  ///
318  /// If this is an unresolved MDNode, RAUW support will be created on-demand.
319  /// ValueAsMetadata always has RAUW support.
320  static ReplaceableMetadataImpl *getOrCreate(Metadata &MD);
321 
322  /// Get RAUW support on MD, if it exists.
323  static ReplaceableMetadataImpl *getIfExists(Metadata &MD);
324 
325  /// Check whether this node will support RAUW.
326  ///
327  /// Returns \c true unless getOrCreate() would return null.
328  static bool isReplaceable(const Metadata &MD);
329 };
330 
331 /// Value wrapper in the Metadata hierarchy.
332 ///
333 /// This is a custom value handle that allows other metadata to refer to
334 /// classes in the Value hierarchy.
335 ///
336 /// Because of full uniquing support, each value is only wrapped by a single \a
337 /// ValueAsMetadata object, so the lookup maps are far more efficient than
338 /// those using ValueHandleBase.
341  friend class LLVMContextImpl;
342 
343  Value *V;
344 
345  /// Drop users without RAUW (during teardown).
346  void dropUsers() {
347  ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false);
348  }
349 
350 protected:
351  ValueAsMetadata(unsigned ID, Value *V)
352  : Metadata(ID, Uniqued), ReplaceableMetadataImpl(V->getContext()), V(V) {
353  assert(V && "Expected valid value");
354  }
355 
356  ~ValueAsMetadata() = default;
357 
358 public:
359  static ValueAsMetadata *get(Value *V);
360 
362  return cast<ConstantAsMetadata>(get(C));
363  }
364 
365  static LocalAsMetadata *getLocal(Value *Local) {
366  return cast<LocalAsMetadata>(get(Local));
367  }
368 
369  static ValueAsMetadata *getIfExists(Value *V);
370 
372  return cast_or_null<ConstantAsMetadata>(getIfExists(C));
373  }
374 
376  return cast_or_null<LocalAsMetadata>(getIfExists(Local));
377  }
378 
379  Value *getValue() const { return V; }
380  Type *getType() const { return V->getType(); }
381  LLVMContext &getContext() const { return V->getContext(); }
382 
383  static void handleDeletion(Value *V);
384  static void handleRAUW(Value *From, Value *To);
385 
386 protected:
387  /// Handle collisions after \a Value::replaceAllUsesWith().
388  ///
389  /// RAUW isn't supported directly for \a ValueAsMetadata, but if the wrapped
390  /// \a Value gets RAUW'ed and the target already exists, this is used to
391  /// merge the two metadata nodes.
394  }
395 
396 public:
397  static bool classof(const Metadata *MD) {
398  return MD->getMetadataID() == LocalAsMetadataKind ||
399  MD->getMetadataID() == ConstantAsMetadataKind;
400  }
401 };
402 
404  friend class ValueAsMetadata;
405 
407  : ValueAsMetadata(ConstantAsMetadataKind, C) {}
408 
409 public:
410  static ConstantAsMetadata *get(Constant *C) {
412  }
413 
416  }
417 
418  Constant *getValue() const {
419  return cast<Constant>(ValueAsMetadata::getValue());
420  }
421 
422  static bool classof(const Metadata *MD) {
423  return MD->getMetadataID() == ConstantAsMetadataKind;
424  }
425 };
426 
428  friend class ValueAsMetadata;
429 
430  LocalAsMetadata(Value *Local)
431  : ValueAsMetadata(LocalAsMetadataKind, Local) {
432  assert(!isa<Constant>(Local) && "Expected local value");
433  }
434 
435 public:
436  static LocalAsMetadata *get(Value *Local) {
437  return ValueAsMetadata::getLocal(Local);
438  }
439 
441  return ValueAsMetadata::getLocalIfExists(Local);
442  }
443 
444  static bool classof(const Metadata *MD) {
445  return MD->getMetadataID() == LocalAsMetadataKind;
446  }
447 };
448 
449 /// Transitional API for extracting constants from Metadata.
450 ///
451 /// This namespace contains transitional functions for metadata that points to
452 /// \a Constants.
453 ///
454 /// In prehistory -- when metadata was a subclass of \a Value -- \a MDNode
455 /// operands could refer to any \a Value. There's was a lot of code like this:
456 ///
457 /// \code
458 /// MDNode *N = ...;
459 /// auto *CI = dyn_cast<ConstantInt>(N->getOperand(2));
460 /// \endcode
461 ///
462 /// Now that \a Value and \a Metadata are in separate hierarchies, maintaining
463 /// the semantics for \a isa(), \a cast(), \a dyn_cast() (etc.) requires three
464 /// steps: cast in the \a Metadata hierarchy, extraction of the \a Value, and
465 /// cast in the \a Value hierarchy. Besides creating boiler-plate, this
466 /// requires subtle control flow changes.
467 ///
468 /// The end-goal is to create a new type of metadata, called (e.g.) \a MDInt,
469 /// so that metadata can refer to numbers without traversing a bridge to the \a
470 /// Value hierarchy. In this final state, the code above would look like this:
471 ///
472 /// \code
473 /// MDNode *N = ...;
474 /// auto *MI = dyn_cast<MDInt>(N->getOperand(2));
475 /// \endcode
476 ///
477 /// The API in this namespace supports the transition. \a MDInt doesn't exist
478 /// yet, and even once it does, changing each metadata schema to use it is its
479 /// own mini-project. In the meantime this API prevents us from introducing
480 /// complex and bug-prone control flow that will disappear in the end. In
481 /// particular, the above code looks like this:
482 ///
483 /// \code
484 /// MDNode *N = ...;
485 /// auto *CI = mdconst::dyn_extract<ConstantInt>(N->getOperand(2));
486 /// \endcode
487 ///
488 /// The full set of provided functions includes:
489 ///
490 /// mdconst::hasa <=> isa
491 /// mdconst::extract <=> cast
492 /// mdconst::extract_or_null <=> cast_or_null
493 /// mdconst::dyn_extract <=> dyn_cast
494 /// mdconst::dyn_extract_or_null <=> dyn_cast_or_null
495 ///
496 /// The target of the cast must be a subclass of \a Constant.
497 namespace mdconst {
498 
499 namespace detail {
500 
501 template <class T> T &make();
502 template <class T, class Result> struct HasDereference {
503  using Yes = char[1];
504  using No = char[2];
505  template <size_t N> struct SFINAE {};
506 
507  template <class U, class V>
508  static Yes &hasDereference(SFINAE<sizeof(static_cast<V>(*make<U>()))> * = 0);
509  template <class U, class V> static No &hasDereference(...);
510 
511  static const bool value =
512  sizeof(hasDereference<T, Result>(nullptr)) == sizeof(Yes);
513 };
514 template <class V, class M> struct IsValidPointer {
515  static const bool value = std::is_base_of<Constant, V>::value &&
517 };
518 template <class V, class M> struct IsValidReference {
519  static const bool value = std::is_base_of<Constant, V>::value &&
520  std::is_convertible<M, const Metadata &>::value;
521 };
522 
523 } // end namespace detail
524 
525 /// Check whether Metadata has a Value.
526 ///
527 /// As an analogue to \a isa(), check whether \c MD has an \a Value inside of
528 /// type \c X.
529 template <class X, class Y>
530 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, bool>::type
531 hasa(Y &&MD) {
532  assert(MD && "Null pointer sent into hasa");
533  if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
534  return isa<X>(V->getValue());
535  return false;
536 }
537 template <class X, class Y>
538 inline
539  typename std::enable_if<detail::IsValidReference<X, Y &>::value, bool>::type
540  hasa(Y &MD) {
541  return hasa(&MD);
542 }
543 
544 /// Extract a Value from Metadata.
545 ///
546 /// As an analogue to \a cast(), extract the \a Value subclass \c X from \c MD.
547 template <class X, class Y>
548 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
549 extract(Y &&MD) {
550  return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
551 }
552 template <class X, class Y>
553 inline
554  typename std::enable_if<detail::IsValidReference<X, Y &>::value, X *>::type
555  extract(Y &MD) {
556  return extract(&MD);
557 }
558 
559 /// Extract a Value from Metadata, allowing null.
560 ///
561 /// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X
562 /// from \c MD, allowing \c MD to be null.
563 template <class X, class Y>
564 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
566  if (auto *V = cast_or_null<ConstantAsMetadata>(MD))
567  return cast<X>(V->getValue());
568  return nullptr;
569 }
570 
571 /// Extract a Value from Metadata, if any.
572 ///
573 /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
574 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
575 /// Value it does contain is of the wrong subclass.
576 template <class X, class Y>
577 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
578 dyn_extract(Y &&MD) {
579  if (auto *V = dyn_cast<ConstantAsMetadata>(MD))
580  return dyn_cast<X>(V->getValue());
581  return nullptr;
582 }
583 
584 /// Extract a Value from Metadata, if any, allowing null.
585 ///
586 /// As an analogue to \a dyn_cast_or_null(), extract the \a Value subclass \c X
587 /// from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
588 /// Value it does contain is of the wrong subclass, allowing \c MD to be null.
589 template <class X, class Y>
590 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
592  if (auto *V = dyn_cast_or_null<ConstantAsMetadata>(MD))
593  return dyn_cast<X>(V->getValue());
594  return nullptr;
595 }
596 
597 } // end namespace mdconst
598 
599 //===----------------------------------------------------------------------===//
600 /// A single uniqued string.
601 ///
602 /// These are used to efficiently contain a byte sequence for metadata.
603 /// MDString is always unnamed.
604 class MDString : public Metadata {
605  friend class StringMapEntry<MDString>;
606 
607  StringMapEntry<MDString> *Entry = nullptr;
608 
609  MDString() : Metadata(MDStringKind, Uniqued) {}
610 
611 public:
612  MDString(const MDString &) = delete;
613  MDString &operator=(MDString &&) = delete;
614  MDString &operator=(const MDString &) = delete;
615 
616  static MDString *get(LLVMContext &Context, StringRef Str);
617  static MDString *get(LLVMContext &Context, const char *Str) {
618  return get(Context, Str ? StringRef(Str) : StringRef());
619  }
620 
621  StringRef getString() const;
622 
623  unsigned getLength() const { return (unsigned)getString().size(); }
624 
626 
627  /// Pointer to the first byte of the string.
628  iterator begin() const { return getString().begin(); }
629 
630  /// Pointer to one byte past the end of the string.
631  iterator end() const { return getString().end(); }
632 
633  const unsigned char *bytes_begin() const { return getString().bytes_begin(); }
634  const unsigned char *bytes_end() const { return getString().bytes_end(); }
635 
636  /// Methods for support type inquiry through isa, cast, and dyn_cast.
637  static bool classof(const Metadata *MD) {
638  return MD->getMetadataID() == MDStringKind;
639  }
640 };
641 
642 /// A collection of metadata nodes that might be associated with a
643 /// memory access used by the alias-analysis infrastructure.
644 struct AAMDNodes {
645  explicit AAMDNodes(MDNode *T = nullptr, MDNode *S = nullptr,
646  MDNode *N = nullptr)
647  : TBAA(T), Scope(S), NoAlias(N) {}
648 
649  bool operator==(const AAMDNodes &A) const {
650  return TBAA == A.TBAA && Scope == A.Scope && NoAlias == A.NoAlias;
651  }
652 
653  bool operator!=(const AAMDNodes &A) const { return !(*this == A); }
654 
655  explicit operator bool() const { return TBAA || Scope || NoAlias; }
656 
657  /// The tag for type-based alias analysis.
659 
660  /// The tag for alias scope specification (used with noalias).
662 
663  /// The tag specifying the noalias scope.
665 
666  /// Given two sets of AAMDNodes that apply to the same pointer,
667  /// give the best AAMDNodes that are compatible with both (i.e. a set of
668  /// nodes whose allowable aliasing conclusions are a subset of those
669  /// allowable by both of the inputs). However, for efficiency
670  /// reasons, do not create any new MDNodes.
671  AAMDNodes intersect(const AAMDNodes &Other) {
673  Result.TBAA = Other.TBAA == TBAA ? TBAA : nullptr;
674  Result.Scope = Other.Scope == Scope ? Scope : nullptr;
675  Result.NoAlias = Other.NoAlias == NoAlias ? NoAlias : nullptr;
676  return Result;
677  }
678 };
679 
680 // Specialize DenseMapInfo for AAMDNodes.
681 template<>
683  static inline AAMDNodes getEmptyKey() {
685  nullptr, nullptr);
686  }
687 
688  static inline AAMDNodes getTombstoneKey() {
690  nullptr, nullptr);
691  }
692 
693  static unsigned getHashValue(const AAMDNodes &Val) {
697  }
698 
699  static bool isEqual(const AAMDNodes &LHS, const AAMDNodes &RHS) {
700  return LHS == RHS;
701  }
702 };
703 
704 /// Tracking metadata reference owned by Metadata.
705 ///
706 /// Similar to \a TrackingMDRef, but it's expected to be owned by an instance
707 /// of \a Metadata, which has the option of registering itself for callbacks to
708 /// re-unique itself.
709 ///
710 /// In particular, this is used by \a MDNode.
711 class MDOperand {
712  Metadata *MD = nullptr;
713 
714 public:
715  MDOperand() = default;
716  MDOperand(MDOperand &&) = delete;
717  MDOperand(const MDOperand &) = delete;
718  MDOperand &operator=(MDOperand &&) = delete;
719  MDOperand &operator=(const MDOperand &) = delete;
720  ~MDOperand() { untrack(); }
721 
722  Metadata *get() const { return MD; }
723  operator Metadata *() const { return get(); }
724  Metadata *operator->() const { return get(); }
725  Metadata &operator*() const { return *get(); }
726 
727  void reset() {
728  untrack();
729  MD = nullptr;
730  }
731  void reset(Metadata *MD, Metadata *Owner) {
732  untrack();
733  this->MD = MD;
734  track(Owner);
735  }
736 
737 private:
738  void track(Metadata *Owner) {
739  if (MD) {
740  if (Owner)
741  MetadataTracking::track(this, *MD, *Owner);
742  else
744  }
745  }
746 
747  void untrack() {
748  assert(static_cast<void *>(this) == &MD && "Expected same address");
749  if (MD)
751  }
752 };
753 
754 template <> struct simplify_type<MDOperand> {
755  using SimpleType = Metadata *;
756 
757  static SimpleType getSimplifiedValue(MDOperand &MD) { return MD.get(); }
758 };
759 
760 template <> struct simplify_type<const MDOperand> {
761  using SimpleType = Metadata *;
762 
763  static SimpleType getSimplifiedValue(const MDOperand &MD) { return MD.get(); }
764 };
765 
766 /// Pointer to the context, with optional RAUW support.
767 ///
768 /// Either a raw (non-null) pointer to the \a LLVMContext, or an owned pointer
769 /// to \a ReplaceableMetadataImpl (which has a reference to \a LLVMContext).
772 
773 public:
776  std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses)
777  : Ptr(ReplaceableUses.release()) {
778  assert(getReplaceableUses() && "Expected non-null replaceable uses");
779  }
780  ContextAndReplaceableUses() = delete;
785  operator=(const ContextAndReplaceableUses &) = delete;
786  ~ContextAndReplaceableUses() { delete getReplaceableUses(); }
787 
788  operator LLVMContext &() { return getContext(); }
789 
790  /// Whether this contains RAUW support.
791  bool hasReplaceableUses() const {
792  return Ptr.is<ReplaceableMetadataImpl *>();
793  }
794 
796  if (hasReplaceableUses())
797  return getReplaceableUses()->getContext();
798  return *Ptr.get<LLVMContext *>();
799  }
800 
802  if (hasReplaceableUses())
803  return Ptr.get<ReplaceableMetadataImpl *>();
804  return nullptr;
805  }
806 
807  /// Ensure that this has RAUW support, and then return it.
809  if (!hasReplaceableUses())
810  makeReplaceable(llvm::make_unique<ReplaceableMetadataImpl>(getContext()));
811  return getReplaceableUses();
812  }
813 
814  /// Assign RAUW support to this.
815  ///
816  /// Make this replaceable, taking ownership of \c ReplaceableUses (which must
817  /// not be null).
818  void
819  makeReplaceable(std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses) {
820  assert(ReplaceableUses && "Expected non-null replaceable uses");
821  assert(&ReplaceableUses->getContext() == &getContext() &&
822  "Expected same context");
823  delete getReplaceableUses();
824  Ptr = ReplaceableUses.release();
825  }
826 
827  /// Drop RAUW support.
828  ///
829  /// Cede ownership of RAUW support, returning it.
830  std::unique_ptr<ReplaceableMetadataImpl> takeReplaceableUses() {
831  assert(hasReplaceableUses() && "Expected to own replaceable uses");
832  std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses(
833  getReplaceableUses());
834  Ptr = &ReplaceableUses->getContext();
835  return ReplaceableUses;
836  }
837 };
838 
840  inline void operator()(MDNode *Node) const;
841 };
842 
843 #define HANDLE_MDNODE_LEAF(CLASS) \
844  using Temp##CLASS = std::unique_ptr<CLASS, TempMDNodeDeleter>;
845 #define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_LEAF(CLASS)
846 #include "llvm/IR/Metadata.def"
847 
848 /// Metadata node.
849 ///
850 /// Metadata nodes can be uniqued, like constants, or distinct. Temporary
851 /// metadata nodes (with full support for RAUW) can be used to delay uniquing
852 /// until forward references are known. The basic metadata node is an \a
853 /// MDTuple.
854 ///
855 /// There is limited support for RAUW at construction time. At construction
856 /// time, if any operand is a temporary node (or an unresolved uniqued node,
857 /// which indicates a transitive temporary operand), the node itself will be
858 /// unresolved. As soon as all operands become resolved, it will drop RAUW
859 /// support permanently.
860 ///
861 /// If an unresolved node is part of a cycle, \a resolveCycles() needs
862 /// to be called on some member of the cycle once all temporary nodes have been
863 /// replaced.
864 class MDNode : public Metadata {
866  friend class LLVMContextImpl;
867 
868  unsigned NumOperands;
869  unsigned NumUnresolved;
870 
872 
873 protected:
874  MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
876  ~MDNode() = default;
877 
878  void *operator new(size_t Size, unsigned NumOps);
879  void operator delete(void *Mem);
880 
881  /// Required by std, but never called.
882  void operator delete(void *, unsigned) {
883  llvm_unreachable("Constructor throws?");
884  }
885 
886  /// Required by std, but never called.
887  void operator delete(void *, unsigned, bool) {
888  llvm_unreachable("Constructor throws?");
889  }
890 
891  void dropAllReferences();
892 
893  MDOperand *mutable_begin() { return mutable_end() - NumOperands; }
894  MDOperand *mutable_end() { return reinterpret_cast<MDOperand *>(this); }
895 
897 
899  return mutable_op_range(mutable_begin(), mutable_end());
900  }
901 
902 public:
903  MDNode(const MDNode &) = delete;
904  void operator=(const MDNode &) = delete;
905  void *operator new(size_t) = delete;
906 
907  static inline MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs);
908  static inline MDTuple *getIfExists(LLVMContext &Context,
910  static inline MDTuple *getDistinct(LLVMContext &Context,
912  static inline TempMDTuple getTemporary(LLVMContext &Context,
914 
915  /// Create a (temporary) clone of this.
916  TempMDNode clone() const;
917 
918  /// Deallocate a node created by getTemporary.
919  ///
920  /// Calls \c replaceAllUsesWith(nullptr) before deleting, so any remaining
921  /// references will be reset.
922  static void deleteTemporary(MDNode *N);
923 
924  LLVMContext &getContext() const { return Context.getContext(); }
925 
926  /// Replace a specific operand.
927  void replaceOperandWith(unsigned I, Metadata *New);
928 
929  /// Check if node is fully resolved.
930  ///
931  /// If \a isTemporary(), this always returns \c false; if \a isDistinct(),
932  /// this always returns \c true.
933  ///
934  /// If \a isUniqued(), returns \c true if this has already dropped RAUW
935  /// support (because all operands are resolved).
936  ///
937  /// As forward declarations are resolved, their containers should get
938  /// resolved automatically. However, if this (or one of its operands) is
939  /// involved in a cycle, \a resolveCycles() needs to be called explicitly.
940  bool isResolved() const { return !isTemporary() && !NumUnresolved; }
941 
942  bool isUniqued() const { return Storage == Uniqued; }
943  bool isDistinct() const { return Storage == Distinct; }
944  bool isTemporary() const { return Storage == Temporary; }
945 
946  /// RAUW a temporary.
947  ///
948  /// \pre \a isTemporary() must be \c true.
950  assert(isTemporary() && "Expected temporary node");
951  if (Context.hasReplaceableUses())
952  Context.getReplaceableUses()->replaceAllUsesWith(MD);
953  }
954 
955  /// Resolve cycles.
956  ///
957  /// Once all forward declarations have been resolved, force cycles to be
958  /// resolved.
959  ///
960  /// \pre No operands (or operands' operands, etc.) have \a isTemporary().
961  void resolveCycles();
962 
963  /// Resolve a unique, unresolved node.
964  void resolve();
965 
966  /// Replace a temporary node with a permanent one.
967  ///
968  /// Try to create a uniqued version of \c N -- in place, if possible -- and
969  /// return it. If \c N cannot be uniqued, return a distinct node instead.
970  template <class T>
971  static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
972  replaceWithPermanent(std::unique_ptr<T, TempMDNodeDeleter> N) {
973  return cast<T>(N.release()->replaceWithPermanentImpl());
974  }
975 
976  /// Replace a temporary node with a uniqued one.
977  ///
978  /// Create a uniqued version of \c N -- in place, if possible -- and return
979  /// it. Takes ownership of the temporary node.
980  ///
981  /// \pre N does not self-reference.
982  template <class T>
983  static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
984  replaceWithUniqued(std::unique_ptr<T, TempMDNodeDeleter> N) {
985  return cast<T>(N.release()->replaceWithUniquedImpl());
986  }
987 
988  /// Replace a temporary node with a distinct one.
989  ///
990  /// Create a distinct version of \c N -- in place, if possible -- and return
991  /// it. Takes ownership of the temporary node.
992  template <class T>
993  static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
994  replaceWithDistinct(std::unique_ptr<T, TempMDNodeDeleter> N) {
995  return cast<T>(N.release()->replaceWithDistinctImpl());
996  }
997 
998 private:
999  MDNode *replaceWithPermanentImpl();
1000  MDNode *replaceWithUniquedImpl();
1001  MDNode *replaceWithDistinctImpl();
1002 
1003 protected:
1004  /// Set an operand.
1005  ///
1006  /// Sets the operand directly, without worrying about uniquing.
1007  void setOperand(unsigned I, Metadata *New);
1008 
1009  void storeDistinctInContext();
1010  template <class T, class StoreT>
1011  static T *storeImpl(T *N, StorageType Storage, StoreT &Store);
1012  template <class T> static T *storeImpl(T *N, StorageType Storage);
1013 
1014 private:
1015  void handleChangedOperand(void *Ref, Metadata *New);
1016 
1017  /// Drop RAUW support, if any.
1018  void dropReplaceableUses();
1019 
1020  void resolveAfterOperandChange(Metadata *Old, Metadata *New);
1021  void decrementUnresolvedOperandCount();
1022  void countUnresolvedOperands();
1023 
1024  /// Mutate this to be "uniqued".
1025  ///
1026  /// Mutate this so that \a isUniqued().
1027  /// \pre \a isTemporary().
1028  /// \pre already added to uniquing set.
1029  void makeUniqued();
1030 
1031  /// Mutate this to be "distinct".
1032  ///
1033  /// Mutate this so that \a isDistinct().
1034  /// \pre \a isTemporary().
1035  void makeDistinct();
1036 
1037  void deleteAsSubclass();
1038  MDNode *uniquify();
1039  void eraseFromStore();
1040 
1041  template <class NodeTy> struct HasCachedHash;
1042  template <class NodeTy>
1043  static void dispatchRecalculateHash(NodeTy *N, std::true_type) {
1044  N->recalculateHash();
1045  }
1046  template <class NodeTy>
1047  static void dispatchRecalculateHash(NodeTy *, std::false_type) {}
1048  template <class NodeTy>
1049  static void dispatchResetHash(NodeTy *N, std::true_type) {
1050  N->setHash(0);
1051  }
1052  template <class NodeTy>
1053  static void dispatchResetHash(NodeTy *, std::false_type) {}
1054 
1055 public:
1056  using op_iterator = const MDOperand *;
1058 
1060  return const_cast<MDNode *>(this)->mutable_begin();
1061  }
1062 
1064  return const_cast<MDNode *>(this)->mutable_end();
1065  }
1066 
1067  op_range operands() const { return op_range(op_begin(), op_end()); }
1068 
1069  const MDOperand &getOperand(unsigned I) const {
1070  assert(I < NumOperands && "Out of range");
1071  return op_begin()[I];
1072  }
1073 
1074  /// Return number of MDNode operands.
1075  unsigned getNumOperands() const { return NumOperands; }
1076 
1077  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1078  static bool classof(const Metadata *MD) {
1079  switch (MD->getMetadataID()) {
1080  default:
1081  return false;
1082 #define HANDLE_MDNODE_LEAF(CLASS) \
1083  case CLASS##Kind: \
1084  return true;
1085 #include "llvm/IR/Metadata.def"
1086  }
1087  }
1088 
1089  /// Check whether MDNode is a vtable access.
1090  bool isTBAAVtableAccess() const;
1091 
1092  /// Methods for metadata merging.
1093  static MDNode *concatenate(MDNode *A, MDNode *B);
1094  static MDNode *intersect(MDNode *A, MDNode *B);
1095  static MDNode *getMostGenericTBAA(MDNode *A, MDNode *B);
1096  static MDNode *getMostGenericFPMath(MDNode *A, MDNode *B);
1097  static MDNode *getMostGenericRange(MDNode *A, MDNode *B);
1098  static MDNode *getMostGenericAliasScope(MDNode *A, MDNode *B);
1099  static MDNode *getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B);
1100 };
1101 
1102 /// Tuple of metadata.
1103 ///
1104 /// This is the simple \a MDNode arbitrary tuple. Nodes are uniqued by
1105 /// default based on their operands.
1106 class MDTuple : public MDNode {
1107  friend class LLVMContextImpl;
1108  friend class MDNode;
1109 
1110  MDTuple(LLVMContext &C, StorageType Storage, unsigned Hash,
1111  ArrayRef<Metadata *> Vals)
1112  : MDNode(C, MDTupleKind, Storage, Vals) {
1113  setHash(Hash);
1114  }
1115 
1116  ~MDTuple() { dropAllReferences(); }
1117 
1118  void setHash(unsigned Hash) { SubclassData32 = Hash; }
1119  void recalculateHash();
1120 
1122  StorageType Storage, bool ShouldCreate = true);
1123 
1124  TempMDTuple cloneImpl() const {
1125  return getTemporary(getContext(),
1126  SmallVector<Metadata *, 4>(op_begin(), op_end()));
1127  }
1128 
1129 public:
1130  /// Get the hash, if any.
1131  unsigned getHash() const { return SubclassData32; }
1132 
1134  return getImpl(Context, MDs, Uniqued);
1135  }
1136 
1138  return getImpl(Context, MDs, Uniqued, /* ShouldCreate */ false);
1139  }
1140 
1141  /// Return a distinct node.
1142  ///
1143  /// Return a distinct node -- i.e., a node that is not uniqued.
1145  return getImpl(Context, MDs, Distinct);
1146  }
1147 
1148  /// Return a temporary node.
1149  ///
1150  /// For use in constructing cyclic MDNode structures. A temporary MDNode is
1151  /// not uniqued, may be RAUW'd, and must be manually deleted with
1152  /// deleteTemporary.
1153  static TempMDTuple getTemporary(LLVMContext &Context,
1154  ArrayRef<Metadata *> MDs) {
1155  return TempMDTuple(getImpl(Context, MDs, Temporary));
1156  }
1157 
1158  /// Return a (temporary) clone of this.
1159  TempMDTuple clone() const { return cloneImpl(); }
1160 
1161  static bool classof(const Metadata *MD) {
1162  return MD->getMetadataID() == MDTupleKind;
1163  }
1164 };
1165 
1167  return MDTuple::get(Context, MDs);
1168 }
1169 
1171  return MDTuple::getIfExists(Context, MDs);
1172 }
1173 
1175  return MDTuple::getDistinct(Context, MDs);
1176 }
1177 
1179  ArrayRef<Metadata *> MDs) {
1180  return MDTuple::getTemporary(Context, MDs);
1181 }
1182 
1185 }
1186 
1187 /// Typed iterator through MDNode operands.
1188 ///
1189 /// An iterator that transforms an \a MDNode::iterator into an iterator over a
1190 /// particular Metadata subclass.
1191 template <class T>
1193  : public std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void,
1194  T *> {
1195  MDNode::op_iterator I = nullptr;
1196 
1197 public:
1198  TypedMDOperandIterator() = default;
1200 
1201  T *operator*() const { return cast_or_null<T>(*I); }
1202 
1204  ++I;
1205  return *this;
1206  }
1207 
1209  TypedMDOperandIterator Temp(*this);
1210  ++I;
1211  return Temp;
1212  }
1213 
1214  bool operator==(const TypedMDOperandIterator &X) const { return I == X.I; }
1215  bool operator!=(const TypedMDOperandIterator &X) const { return I != X.I; }
1216 };
1217 
1218 /// Typed, array-like tuple of metadata.
1219 ///
1220 /// This is a wrapper for \a MDTuple that makes it act like an array holding a
1221 /// particular type of metadata.
1222 template <class T> class MDTupleTypedArrayWrapper {
1223  const MDTuple *N = nullptr;
1224 
1225 public:
1226  MDTupleTypedArrayWrapper() = default;
1227  MDTupleTypedArrayWrapper(const MDTuple *N) : N(N) {}
1228 
1229  template <class U>
1231  const MDTupleTypedArrayWrapper<U> &Other,
1232  typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
1233  nullptr)
1234  : N(Other.get()) {}
1235 
1236  template <class U>
1238  const MDTupleTypedArrayWrapper<U> &Other,
1239  typename std::enable_if<!std::is_convertible<U *, T *>::value>::type * =
1240  nullptr)
1241  : N(Other.get()) {}
1242 
1243  explicit operator bool() const { return get(); }
1244  explicit operator MDTuple *() const { return get(); }
1245 
1246  MDTuple *get() const { return const_cast<MDTuple *>(N); }
1247  MDTuple *operator->() const { return get(); }
1248  MDTuple &operator*() const { return *get(); }
1249 
1250  // FIXME: Fix callers and remove condition on N.
1251  unsigned size() const { return N ? N->getNumOperands() : 0u; }
1252  bool empty() const { return N ? N->getNumOperands() == 0 : true; }
1253  T *operator[](unsigned I) const { return cast_or_null<T>(N->getOperand(I)); }
1254 
1255  // FIXME: Fix callers and remove condition on N.
1257 
1258  iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
1259  iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
1260 };
1261 
1262 #define HANDLE_METADATA(CLASS) \
1263  using CLASS##Array = MDTupleTypedArrayWrapper<CLASS>;
1264 #include "llvm/IR/Metadata.def"
1265 
1266 /// Placeholder metadata for operands of distinct MDNodes.
1267 ///
1268 /// This is a lightweight placeholder for an operand of a distinct node. It's
1269 /// purpose is to help track forward references when creating a distinct node.
1270 /// This allows distinct nodes involved in a cycle to be constructed before
1271 /// their operands without requiring a heavyweight temporary node with
1272 /// full-blown RAUW support.
1273 ///
1274 /// Each placeholder supports only a single MDNode user. Clients should pass
1275 /// an ID, retrieved via \a getID(), to indicate the "real" operand that this
1276 /// should be replaced with.
1277 ///
1278 /// While it would be possible to implement move operators, they would be
1279 /// fairly expensive. Leave them unimplemented to discourage their use
1280 /// (clients can use std::deque, std::list, BumpPtrAllocator, etc.).
1282  friend class MetadataTracking;
1283 
1284  Metadata **Use = nullptr;
1285 
1286 public:
1288  : Metadata(DistinctMDOperandPlaceholderKind, Distinct) {
1289  SubclassData32 = ID;
1290  }
1291 
1292  DistinctMDOperandPlaceholder() = delete;
1295 
1297  if (Use)
1298  *Use = nullptr;
1299  }
1300 
1301  unsigned getID() const { return SubclassData32; }
1302 
1303  /// Replace the use of this with MD.
1305  if (!Use)
1306  return;
1307  *Use = MD;
1308 
1309  if (*Use)
1311 
1312  Metadata *T = cast<Metadata>(this);
1314  assert(!Use && "Use is still being tracked despite being untracked!");
1315  }
1316 };
1317 
1318 //===----------------------------------------------------------------------===//
1319 /// A tuple of MDNodes.
1320 ///
1321 /// Despite its name, a NamedMDNode isn't itself an MDNode.
1322 ///
1323 /// NamedMDNodes are named module-level entities that contain lists of MDNodes.
1324 ///
1325 /// It is illegal for a NamedMDNode to appear as an operand of an MDNode.
1326 class NamedMDNode : public ilist_node<NamedMDNode> {
1327  friend class LLVMContextImpl;
1328  friend class Module;
1329 
1330  std::string Name;
1331  Module *Parent = nullptr;
1332  void *Operands; // SmallVector<TrackingMDRef, 4>
1333 
1334  void setParent(Module *M) { Parent = M; }
1335 
1336  explicit NamedMDNode(const Twine &N);
1337 
1338  template<class T1, class T2>
1339  class op_iterator_impl :
1340  public std::iterator<std::bidirectional_iterator_tag, T2> {
1341  friend class NamedMDNode;
1342 
1343  const NamedMDNode *Node = nullptr;
1344  unsigned Idx = 0;
1345 
1346  op_iterator_impl(const NamedMDNode *N, unsigned i) : Node(N), Idx(i) {}
1347 
1348  public:
1349  op_iterator_impl() = default;
1350 
1351  bool operator==(const op_iterator_impl &o) const { return Idx == o.Idx; }
1352  bool operator!=(const op_iterator_impl &o) const { return Idx != o.Idx; }
1353 
1354  op_iterator_impl &operator++() {
1355  ++Idx;
1356  return *this;
1357  }
1358 
1359  op_iterator_impl operator++(int) {
1360  op_iterator_impl tmp(*this);
1361  operator++();
1362  return tmp;
1363  }
1364 
1365  op_iterator_impl &operator--() {
1366  --Idx;
1367  return *this;
1368  }
1369 
1370  op_iterator_impl operator--(int) {
1371  op_iterator_impl tmp(*this);
1372  operator--();
1373  return tmp;
1374  }
1375 
1376  T1 operator*() const { return Node->getOperand(Idx); }
1377  };
1378 
1379 public:
1380  NamedMDNode(const NamedMDNode &) = delete;
1381  ~NamedMDNode();
1382 
1383  /// Drop all references and remove the node from parent module.
1384  void eraseFromParent();
1385 
1386  /// Remove all uses and clear node vector.
1387  void dropAllReferences() { clearOperands(); }
1388  /// Drop all references to this node's operands.
1389  void clearOperands();
1390 
1391  /// Get the module that holds this named metadata collection.
1392  inline Module *getParent() { return Parent; }
1393  inline const Module *getParent() const { return Parent; }
1394 
1395  MDNode *getOperand(unsigned i) const;
1396  unsigned getNumOperands() const;
1397  void addOperand(MDNode *M);
1398  void setOperand(unsigned I, MDNode *New);
1399  StringRef getName() const;
1400  void print(raw_ostream &ROS, bool IsForDebug = false) const;
1401  void print(raw_ostream &ROS, ModuleSlotTracker &MST,
1402  bool IsForDebug = false) const;
1403  void dump() const;
1404 
1405  // ---------------------------------------------------------------------------
1406  // Operand Iterator interface...
1407  //
1408  using op_iterator = op_iterator_impl<MDNode *, MDNode>;
1409 
1410  op_iterator op_begin() { return op_iterator(this, 0); }
1411  op_iterator op_end() { return op_iterator(this, getNumOperands()); }
1412 
1413  using const_op_iterator = op_iterator_impl<const MDNode *, MDNode>;
1414 
1415  const_op_iterator op_begin() const { return const_op_iterator(this, 0); }
1416  const_op_iterator op_end() const { return const_op_iterator(this, getNumOperands()); }
1417 
1419  return make_range(op_begin(), op_end());
1420  }
1422  return make_range(op_begin(), op_end());
1423  }
1424 };
1425 
1426 // Create wrappers for C Binding types (see CBindingWrapping.h).
1428 
1429 } // end namespace llvm
1430 
1431 #endif // LLVM_IR_METADATA_H
void dropAllReferences()
Remove all uses and clear node vector.
Definition: Metadata.h:1387
uint64_t CallInst * C
static void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
Definition: Metadata.cpp:831
bool isUniqued() const
Definition: Metadata.h:942
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:711
unsigned char Storage
Storage flag for non-uniqued, otherwise unowned, metadata.
Definition: Metadata.h:69
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:49
ContextAndReplaceableUses(std::unique_ptr< ReplaceableMetadataImpl > ReplaceableUses)
Definition: Metadata.h:775
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1133
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
bool isDistinct() const
Definition: Metadata.h:943
static bool classof(const Metadata *MD)
Definition: Metadata.h:1161
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:464
LLVMContext & Context
MDNode * Scope
The tag for alias scope specification (used with noalias).
Definition: Metadata.h:661
const unsigned char * bytes_end() const
Definition: Metadata.h:634
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1081
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
MDNode * TBAA
The tag for type-based alias analysis.
Definition: Metadata.h:658
const unsigned char * bytes_end() const
Definition: StringRef.h:113
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMap.h:126
const char * iterator
Definition: StringRef.h:53
TypedMDOperandIterator operator++(int)
Definition: Metadata.h:1208
static std::enable_if< std::is_base_of< MDNode, T >::value, T * >::type replaceWithPermanent(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a permanent one.
Definition: Metadata.h:972
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
iterator begin() const
Pointer to the first byte of the string.
Definition: Metadata.h:628
unsigned getLength() const
Definition: Metadata.h:623
static bool classof(const Metadata *MD)
Definition: Metadata.h:422
std::unique_ptr< ReplaceableMetadataImpl > takeReplaceableUses()
Drop RAUW support.
Definition: Metadata.h:830
Metadata * getMetadata() const
Definition: Metadata.h:191
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
Metadata * operator->() const
Definition: Metadata.h:724
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
ContextAndReplaceableUses(LLVMContext &Context)
Definition: Metadata.h:774
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:714
static ConstantAsMetadata * getConstantIfExists(Value *C)
Definition: Metadata.h:371
MDTupleTypedArrayWrapper(const MDTuple *N)
Definition: Metadata.h:1227
Shared implementation of use-lists for replaceable metadata.
Definition: Metadata.h:279
Metadata node.
Definition: Metadata.h:864
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1069
LLVMContext & getContext() const
Definition: Metadata.h:795
Manage lifetime of a slot tracker for printing IR.
Typed, array-like tuple of metadata.
Definition: Metadata.h:1222
ReplaceableMetadataImpl(LLVMContext &Context)
Definition: Metadata.h:291
void replaceUseWith(Metadata *MD)
Replace the use of this with MD.
Definition: Metadata.h:1304
static bool track(void *Ref, Metadata &MD, Metadata &Owner)
Track the reference to metadata for Metadata.
Definition: Metadata.h:230
op_iterator op_end() const
Definition: Metadata.h:1063
Tuple of metadata.
Definition: Metadata.h:1106
bool operator!=(const AAMDNodes &A) const
Definition: Metadata.h:653
static std::enable_if< std::is_base_of< MDNode, T >::value, T * >::type replaceWithDistinct(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a distinct one.
Definition: Metadata.h:994
Metadata & operator*() const
Definition: Metadata.h:725
static AAMDNodes getEmptyKey()
Definition: Metadata.h:683
static MCDisassembler::DecodeStatus addOperand(MCInst &Inst, const MCOperand &Opnd)
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
A tuple of MDNodes.
Definition: Metadata.h:1326
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
struct LLVMOpaqueNamedMDNode * LLVMNamedMDNodeRef
Represents an LLVM Named Metadata Node.
Definition: Types.h:97
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:195
void makeReplaceable(std::unique_ptr< ReplaceableMetadataImpl > ReplaceableUses)
Assign RAUW support to this.
Definition: Metadata.h:819
bool isResolved() const
Check if node is fully resolved.
Definition: Metadata.h:940
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
static bool track(Metadata *&MD)
Track the reference to metadata.
Definition: Metadata.h:221
The access may reference the value stored in memory.
unsigned getHash() const
Get the hash, if any.
Definition: Metadata.h:1131
unsigned short SubclassData16
Definition: Metadata.h:74
Typed iterator through MDNode operands.
Definition: Metadata.h:1192
static StringRef getName(Value *V)
static MDTuple * getIfExists(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1137
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1178
Placeholder metadata for operands of distinct MDNodes.
Definition: Metadata.h:1281
TypedMDOperandIterator & operator++()
Definition: Metadata.h:1203
op_iterator_impl< const MDNode *, MDNode > const_op_iterator
Definition: Metadata.h:1413
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2085
API for tracking metadata references through RAUW and deletion.
Definition: Metadata.h:210
op_iterator op_begin() const
Definition: Metadata.h:1059
unsigned char ImplicitCode
Definition: Metadata.h:72
static bool classof(const Metadata *MD)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Metadata.h:1078
PointerUnion< MetadataAsValue *, Metadata * > OwnerTy
Definition: Metadata.h:265
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
op_range operands() const
Definition: Metadata.h:1067
MDTuple * operator->() const
Definition: Metadata.h:1247
LLVMContext & getContext() const
Definition: Metadata.h:924
const_op_iterator op_end() const
Definition: Metadata.h:1416
unsigned getMetadataID() const
Definition: Metadata.h:100
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
const Module * getParent() const
Definition: Metadata.h:1393
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:339
void replaceAllUsesWith(Metadata *MD)
RAUW a temporary.
Definition: Metadata.h:949
unsigned SubclassData32
Definition: Metadata.h:75
static MDTuple * getIfExists(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1170
iterator_range< op_iterator > operands()
Definition: Metadata.h:1418
LLVMConstants
Definition: Metadata.h:51
static bool classof(const Metadata *MD)
Definition: Metadata.h:444
static bool classof(const Value *V)
Definition: Metadata.h:193
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Return a temporary node.
Definition: Metadata.h:1153
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1166
AAMDNodes(MDNode *T=nullptr, MDNode *S=nullptr, MDNode *N=nullptr)
Definition: Metadata.h:645
static std::enable_if< std::is_base_of< MDNode, T >::value, T * >::type replaceWithUniqued(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a uniqued one.
Definition: Metadata.h:984
ValueAsMetadata(unsigned ID, Value *V)
Definition: Metadata.h:351
void resolveAllUses(bool ResolveUsers=true)
Resolve all uses of this.
Definition: Metadata.cpp:281
MDOperand * mutable_end()
Definition: Metadata.h:894
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static LocalAsMetadata * getLocal(Value *Local)
Definition: Metadata.h:365
iterator end() const
Pointer to one byte past the end of the string.
Definition: Metadata.h:631
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
LLVMContext & getContext() const
Definition: Metadata.h:381
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
This is an important base class in LLVM.
Definition: Constant.h:42
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1174
amdgpu inline
StorageType
Active type of storage.
Definition: Metadata.h:66
MDTupleTypedArrayWrapper(const MDTupleTypedArrayWrapper< U > &Other, typename std::enable_if<!std::is_convertible< U *, T *>::value >::type *=nullptr)
Definition: Metadata.h:1237
TempMDTuple clone() const
Return a (temporary) clone of this.
Definition: Metadata.h:1159
static ConstantAsMetadata * getIfExists(Constant *C)
Definition: Metadata.h:414
const_op_iterator op_begin() const
Definition: Metadata.h:1415
static bool retrack(Metadata *&MD, Metadata *&New)
Move tracking from one reference to another.
Definition: Metadata.h:257
const unsigned char * bytes_begin() const
Definition: Metadata.h:633
op_iterator_impl< MDNode *, MDNode > op_iterator
Definition: Metadata.h:1408
static SimpleType getSimplifiedValue(MDOperand &MD)
Definition: Metadata.h:757
Metadata wrapper in the Value hierarchy.
Definition: Metadata.h:174
void handleChangedOperand(void *, Metadata *)
Default handling of a changed operand, which asserts.
Definition: Metadata.h:95
Value * getValue() const
Definition: Metadata.h:379
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
mutable_op_range mutable_operands()
Definition: Metadata.h:898
op_iterator op_end()
Definition: Metadata.h:1411
static bool classof(const Metadata *MD)
Methods for support type inquiry through isa, cast, and dyn_cast.
Definition: Metadata.h:637
static bool isEqual(const AAMDNodes &LHS, const AAMDNodes &RHS)
Definition: Metadata.h:699
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Return a distinct node.
Definition: Metadata.h:1144
bool hasReplaceableUses() const
Whether this contains RAUW support.
Definition: Metadata.h:791
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void print(raw_ostream &OS, const Module *M=nullptr, bool IsForDebug=false) const
Print.
Definition: AsmWriter.cpp:4224
BlockVerifier::State From
static bool classof(const Metadata *MD)
Definition: Metadata.h:397
Type * getType() const
Definition: Metadata.h:380
iterator_range< const_op_iterator > operands() const
Definition: Metadata.h:1421
static ConstantAsMetadata * getConstant(Value *C)
Definition: Metadata.h:361
Constant * getValue() const
Definition: Metadata.h:418
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
static LocalAsMetadata * getIfExists(Value *Local)
Definition: Metadata.h:440
~Metadata()=default
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:644
MDNode * NoAlias
The tag specifying the noalias scope.
Definition: Metadata.h:664
static LocalAsMetadata * getLocalIfExists(Value *Local)
Definition: Metadata.h:375
void reset()
Definition: Metadata.h:727
A range adaptor for a pair of iterators.
static void untrack(Metadata *&MD)
Stop tracking a reference to metadata.
Definition: Metadata.h:246
std::enable_if< detail::IsValidPointer< X, Y >::value, X * >::type extract_or_null(Y &&MD)
Extract a Value from Metadata, allowing null.
Definition: Metadata.h:565
T * operator[](unsigned I) const
Definition: Metadata.h:1253
loop extract
iterator begin() const
Definition: StringRef.h:106
std::enable_if< detail::IsValidReference< X, Y & >::value, bool >::type hasa(Y &MD)
Definition: Metadata.h:540
bool operator==(const AAMDNodes &A) const
Definition: Metadata.h:649
Pointer to the context, with optional RAUW support.
Definition: Metadata.h:770
MDOperand * mutable_begin()
Definition: Metadata.h:893
std::enable_if< detail::IsValidPointer< X, Y >::value, X * >::type dyn_extract_or_null(Y &&MD)
Extract a Value from Metadata, if any, allowing null.
Definition: Metadata.h:591
bool operator!=(uint64_t V1, const APInt &V2)
Definition: APInt.h:1963
LLVMContext & getContext() const
Definition: Metadata.h:297
const unsigned char * bytes_begin() const
Definition: StringRef.h:110
DistinctMDOperandPlaceholder(unsigned ID)
Definition: Metadata.h:1287
static ValueLatticeElement intersect(const ValueLatticeElement &A, const ValueLatticeElement &B)
Combine two sets of facts about the same value into a single set of facts.
static AAMDNodes getTombstoneKey()
Definition: Metadata.h:688
void replaceAllUsesWith(Metadata *MD)
Handle collisions after Value::replaceAllUsesWith().
Definition: Metadata.h:392
static SimpleType getSimplifiedValue(const MDOperand &MD)
Definition: Metadata.h:763
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
void dump() const
User-friendly dump.
Definition: AsmWriter.cpp:4267
MDTupleTypedArrayWrapper(const MDTupleTypedArrayWrapper< U > &Other, typename std::enable_if< std::is_convertible< U *, T *>::value >::type *=nullptr)
Definition: Metadata.h:1230
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
uint32_t Size
Definition: Profile.cpp:47
void replaceAllUsesWith(Metadata *MD)
Replace all uses of this with MD.
Definition: Metadata.cpp:233
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2033
op_iterator op_begin()
Definition: Metadata.h:1410
T get() const
Returns the value of the specified pointer type.
Definition: PointerUnion.h:135
void printAsOperand(raw_ostream &OS, const Module *M=nullptr) const
Print as operand.
Definition: AsmWriter.cpp:4214
struct LLVMOpaqueMetadata * LLVMMetadataRef
Represents an LLVM Metadata.
Definition: Types.h:90
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ReplaceableMetadataImpl * getOrCreateReplaceableUses()
Ensure that this has RAUW support, and then return it.
Definition: Metadata.h:808
aarch64 promote const
LLVM Value Representation.
Definition: Value.h:73
void reset(Metadata *MD, Metadata *Owner)
Definition: Metadata.h:731
static unsigned getHashValue(const AAMDNodes &Val)
Definition: Metadata.h:693
Metadata(unsigned ID, StorageType Storage)
Definition: Metadata.h:84
AAMDNodes intersect(const AAMDNodes &Other)
Given two sets of AAMDNodes that apply to the same pointer, give the best AAMDNodes that are compatib...
Definition: Metadata.h:671
Metadata * get() const
Definition: Metadata.h:722
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
bool operator==(const TypedMDOperandIterator &X) const
Definition: Metadata.h:1214
bool isTemporary() const
Definition: Metadata.h:944
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:604
int is() const
Test if the Union currently holds the type matching T.
Definition: PointerUnion.h:123
std::enable_if< detail::IsValidPointer< X, Y >::value, X * >::type dyn_extract(Y &&MD)
Extract a Value from Metadata, if any.
Definition: Metadata.h:578
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1961
MDTuple & operator*() const
Definition: Metadata.h:1248
static LazyValueInfoImpl & getImpl(void *&PImpl, AssumptionCache *AC, const DataLayout *DL, DominatorTree *DT=nullptr)
This lazily constructs the LazyValueInfoImpl.
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1075
static bool track(void *Ref, Metadata &MD, MetadataAsValue &Owner)
Track the reference to metadata for MetadataAsValue.
Definition: Metadata.h:239
TypedMDOperandIterator(MDNode::op_iterator I)
Definition: Metadata.h:1199
ReplaceableMetadataImpl * getReplaceableUses() const
Definition: Metadata.h:801
iterator end() const
Definition: StringRef.h:108
void operator()(MDNode *Node) const
Definition: Metadata.h:1183
Root of the metadata hierarchy.
Definition: Metadata.h:58
#define T1
Module * getParent()
Get the module that holds this named metadata collection.
Definition: Metadata.h:1392
bool operator!=(const TypedMDOperandIterator &X) const
Definition: Metadata.h:1215
A discriminated union of two pointer types, with the discriminator in the low bit of the pointer...
Definition: PointerUnion.h:87