1 //===- llvm/IR/TrackingMDRef.h - Tracking Metadata references ---*- C++ -*-===//
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 // References to metadata that track RAUW.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_IR_TRACKINGMDREF_H
14 #define LLVM_IR_TRACKINGMDREF_H
15 
16 #include "llvm/IR/Metadata.h"
17 #include <algorithm>
18 #include <cassert>
19 
20 namespace llvm {
21 
22 /// Tracking metadata reference.
23 ///
24 /// This class behaves like \a TrackingVH, but for metadata.
25 class TrackingMDRef {
26   Metadata *MD = nullptr;
27 
28 public:
29   TrackingMDRef() = default;
30   explicit TrackingMDRef(Metadata *MD) : MD(MD) { track(); }
31 
32   TrackingMDRef(TrackingMDRef &&X) : MD(X.MD) { retrack(X); }
33   TrackingMDRef(const TrackingMDRef &X) : MD(X.MD) { track(); }
34 
35   TrackingMDRef &operator=(TrackingMDRef &&X) {
36     if (&X == this)
37       return *this;
38 
39     untrack();
40     MD = X.MD;
41     retrack(X);
42     return *this;
43   }
44 
45   TrackingMDRef &operator=(const TrackingMDRef &X) {
46     if (&X == this)
47       return *this;
48 
49     untrack();
50     MD = X.MD;
51     track();
52     return *this;
53   }
54 
55   ~TrackingMDRef() { untrack(); }
56 
57   Metadata *get() const { return MD; }
58   operator Metadata *() const { return get(); }
59   Metadata *operator->() const { return get(); }
60   Metadata &operator*() const { return *get(); }
61 
62   void reset() {
63     untrack();
64     MD = nullptr;
65   }
66   void reset(Metadata *MD) {
67     untrack();
68     this->MD = MD;
69     track();
70   }
71 
72   /// Check whether this has a trivial destructor.
73   ///
74   /// If \c MD isn't replaceable, the destructor will be a no-op.
75   bool hasTrivialDestructor() const {
76     return !MD || !MetadataTracking::isReplaceable(*MD);
77   }
78 
79   bool operator==(const TrackingMDRef &X) const { return MD == X.MD; }
80   bool operator!=(const TrackingMDRef &X) const { return MD != X.MD; }
81 
82 private:
83   void track() {
84     if (MD)
85       MetadataTracking::track(MD);
86   }
87 
88   void untrack() {
89     if (MD)
90       MetadataTracking::untrack(MD);
91   }
92 
93   void retrack(TrackingMDRef &X) {
94     assert(MD == X.MD && "Expected values to match");
95     if (X.MD) {
96       MetadataTracking::retrack(X.MD, MD);
97       X.MD = nullptr;
98     }
99   }
100 };
101 
102 /// Typed tracking ref.
103 ///
104 /// Track refererences of a particular type.  It's useful to use this for \a
105 /// MDNode and \a ValueAsMetadata.
106 template <class T> class TypedTrackingMDRef {
107   TrackingMDRef Ref;
108 
109 public:
110   TypedTrackingMDRef() = default;
111   explicit TypedTrackingMDRef(T *MD) : Ref(static_cast<Metadata *>(MD)) {}
112 
113   TypedTrackingMDRef(TypedTrackingMDRef &&X) : Ref(std::move(X.Ref)) {}
114   TypedTrackingMDRef(const TypedTrackingMDRef &X) : Ref(X.Ref) {}
115 
116   TypedTrackingMDRef &operator=(TypedTrackingMDRef &&X) {
117     Ref = std::move(X.Ref);
118     return *this;
119   }
120 
121   TypedTrackingMDRef &operator=(const TypedTrackingMDRef &X) {
122     Ref = X.Ref;
123     return *this;
124   }
125 
126   T *get() const { return (T *)Ref.get(); }
127   operator T *() const { return get(); }
128   T *operator->() const { return get(); }
129   T &operator*() const { return *get(); }
130 
131   bool operator==(const TypedTrackingMDRef &X) const { return Ref == X.Ref; }
132   bool operator!=(const TypedTrackingMDRef &X) const { return Ref != X.Ref; }
133 
134   void reset() { Ref.reset(); }
135   void reset(T *MD) { Ref.reset(static_cast<Metadata *>(MD)); }
136 
137   /// Check whether this has a trivial destructor.
138   bool hasTrivialDestructor() const { return Ref.hasTrivialDestructor(); }
139 };
140 
141 using TrackingMDNodeRef = TypedTrackingMDRef<MDNode>;
142 using TrackingValueAsMetadataRef = TypedTrackingMDRef<ValueAsMetadata>;
143 
144 // Expose the underlying metadata to casting.
145 template <> struct simplify_type<TrackingMDRef> {
146   using SimpleType = Metadata *;
147 
148   static SimpleType getSimplifiedValue(TrackingMDRef &MD) { return MD.get(); }
149 };
150 
151 template <> struct simplify_type<const TrackingMDRef> {
152   using SimpleType = Metadata *;
153 
154   static SimpleType getSimplifiedValue(const TrackingMDRef &MD) {
155     return MD.get();
156   }
157 };
158 
159 template <class T> struct simplify_type<TypedTrackingMDRef<T>> {
160   using SimpleType = T *;
161 
162   static SimpleType getSimplifiedValue(TypedTrackingMDRef<T> &MD) {
163     return MD.get();
164   }
165 };
166 
167 template <class T> struct simplify_type<const TypedTrackingMDRef<T>> {
168   using SimpleType = T *;
169 
170   static SimpleType getSimplifiedValue(const TypedTrackingMDRef<T> &MD) {
171     return MD.get();
172   }
173 };
174 
175 } // end namespace llvm
176 
177 #endif // LLVM_IR_TRACKINGMDREF_H
178