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: *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(MD&: X.MD, New&: 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(MD: 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 | |