LLVM  4.0.0
TrackingMDRef.h
Go to the documentation of this file.
1 //===- llvm/IR/TrackingMDRef.h - Tracking Metadata references ---*- 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 // References to metadata that track RAUW.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_IR_TRACKINGMDREF_H
15 #define LLVM_IR_TRACKINGMDREF_H
16 
17 #include "llvm/IR/Metadata.h"
18 
19 namespace llvm {
20 
21 /// \brief Tracking metadata reference.
22 ///
23 /// This class behaves like \a TrackingVH, but for metadata.
25  Metadata *MD;
26 
27 public:
28  TrackingMDRef() : MD(nullptr) {}
29  explicit TrackingMDRef(Metadata *MD) : MD(MD) { track(); }
30 
31  TrackingMDRef(TrackingMDRef &&X) : MD(X.MD) { retrack(X); }
32  TrackingMDRef(const TrackingMDRef &X) : MD(X.MD) { track(); }
34  if (&X == this)
35  return *this;
36 
37  untrack();
38  MD = X.MD;
39  retrack(X);
40  return *this;
41  }
43  if (&X == this)
44  return *this;
45 
46  untrack();
47  MD = X.MD;
48  track();
49  return *this;
50  }
51  ~TrackingMDRef() { untrack(); }
52 
53  Metadata *get() const { return MD; }
54  operator Metadata *() const { return get(); }
55  Metadata *operator->() const { return get(); }
56  Metadata &operator*() const { return *get(); }
57 
58  void reset() {
59  untrack();
60  MD = nullptr;
61  }
62  void reset(Metadata *MD) {
63  untrack();
64  this->MD = MD;
65  track();
66  }
67 
68  /// \brief Check whether this has a trivial destructor.
69  ///
70  /// If \c MD isn't replaceable, the destructor will be a no-op.
71  bool hasTrivialDestructor() const {
72  return !MD || !MetadataTracking::isReplaceable(*MD);
73  }
74 
75  bool operator==(const TrackingMDRef &X) const { return MD == X.MD; }
76  bool operator!=(const TrackingMDRef &X) const { return MD != X.MD; }
77 
78 private:
79  void track() {
80  if (MD)
82  }
83  void untrack() {
84  if (MD)
86  }
87  void retrack(TrackingMDRef &X) {
88  assert(MD == X.MD && "Expected values to match");
89  if (X.MD) {
90  MetadataTracking::retrack(X.MD, MD);
91  X.MD = nullptr;
92  }
93  }
94 };
95 
96 /// \brief Typed tracking ref.
97 ///
98 /// Track refererences of a particular type. It's useful to use this for \a
99 /// MDNode and \a ValueAsMetadata.
100 template <class T> class TypedTrackingMDRef {
101  TrackingMDRef Ref;
102 
103 public:
105  explicit TypedTrackingMDRef(T *MD) : Ref(static_cast<Metadata *>(MD)) {}
106 
107  TypedTrackingMDRef(TypedTrackingMDRef &&X) : Ref(std::move(X.Ref)) {}
108  TypedTrackingMDRef(const TypedTrackingMDRef &X) : Ref(X.Ref) {}
110  Ref = std::move(X.Ref);
111  return *this;
112  }
114  Ref = X.Ref;
115  return *this;
116  }
117 
118  T *get() const { return (T *)Ref.get(); }
119  operator T *() const { return get(); }
120  T *operator->() const { return get(); }
121  T &operator*() const { return *get(); }
122 
123  bool operator==(const TypedTrackingMDRef &X) const { return Ref == X.Ref; }
124  bool operator!=(const TypedTrackingMDRef &X) const { return Ref != X.Ref; }
125 
126  void reset() { Ref.reset(); }
127  void reset(T *MD) { Ref.reset(static_cast<Metadata *>(MD)); }
128 
129  /// \brief Check whether this has a trivial destructor.
130  bool hasTrivialDestructor() const { return Ref.hasTrivialDestructor(); }
131 };
132 
135 
136 // Expose the underlying metadata to casting.
137 template <> struct simplify_type<TrackingMDRef> {
139  static SimpleType getSimplifiedValue(TrackingMDRef &MD) { return MD.get(); }
140 };
141 
142 template <> struct simplify_type<const TrackingMDRef> {
145  return MD.get();
146  }
147 };
148 
149 template <class T> struct simplify_type<TypedTrackingMDRef<T>> {
150  typedef T *SimpleType;
152  return MD.get();
153  }
154 };
155 
156 template <class T> struct simplify_type<const TypedTrackingMDRef<T>> {
157  typedef T *SimpleType;
159  return MD.get();
160  }
161 };
162 
163 } // end namespace llvm
164 
165 #endif
bool hasTrivialDestructor() const
Check whether this has a trivial destructor.
Definition: TrackingMDRef.h:71
static SimpleType getSimplifiedValue(const TrackingMDRef &MD)
Metadata * operator->() const
Definition: TrackingMDRef.h:55
TrackingMDRef & operator=(TrackingMDRef &&X)
Definition: TrackingMDRef.h:33
Tracking metadata reference.
Definition: TrackingMDRef.h:24
TypedTrackingMDRef & operator=(const TypedTrackingMDRef &X)
This file contains the declarations for metadata subclasses.
bool operator!=(const TrackingMDRef &X) const
Definition: TrackingMDRef.h:76
bool operator==(const TypedTrackingMDRef &X) const
TypedTrackingMDRef< ValueAsMetadata > TrackingValueAsMetadataRef
static bool track(Metadata *&MD)
Track the reference to metadata.
Definition: Metadata.h:206
TypedTrackingMDRef & operator=(TypedTrackingMDRef &&X)
bool hasTrivialDestructor() const
Check whether this has a trivial destructor.
TypedTrackingMDRef(const TypedTrackingMDRef &X)
TrackingMDRef(TrackingMDRef &&X)
Definition: TrackingMDRef.h:31
static SimpleType getSimplifiedValue(TypedTrackingMDRef< T > &MD)
bool operator==(const TrackingMDRef &X) const
Definition: TrackingMDRef.h:75
Metadata * get() const
Definition: TrackingMDRef.h:53
TrackingMDRef(const TrackingMDRef &X)
Definition: TrackingMDRef.h:32
static SimpleType getSimplifiedValue(const TypedTrackingMDRef< T > &MD)
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
static bool retrack(Metadata *&MD, Metadata *&New)
Move tracking from one reference to another.
Definition: Metadata.h:242
Typed tracking ref.
TrackingMDRef & operator=(const TrackingMDRef &X)
Definition: TrackingMDRef.h:42
bool operator!=(const TypedTrackingMDRef &X) const
static void untrack(Metadata *&MD)
Stop tracking a reference to metadata.
Definition: Metadata.h:231
TrackingMDRef(Metadata *MD)
Definition: TrackingMDRef.h:29
Metadata & operator*() const
Definition: TrackingMDRef.h:56
TypedTrackingMDRef< MDNode > TrackingMDNodeRef
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static SimpleType getSimplifiedValue(TrackingMDRef &MD)
aarch64 promote const
void reset(Metadata *MD)
Definition: TrackingMDRef.h:62
static bool isReplaceable(const Metadata &MD)
Check whether metadata is replaceable.
Definition: Metadata.cpp:162
Root of the metadata hierarchy.
Definition: Metadata.h:55
TypedTrackingMDRef(TypedTrackingMDRef &&X)