1//===--- ModRef.h - Memory effect modelling ---------------------*- 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// Definitions of ModRefInfo and MemoryEffects, which are used to
10// describe the memory effects of instructions.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_SUPPORT_MODREF_H
15#define LLVM_SUPPORT_MODREF_H
16
17#include "llvm/ADT/BitmaskEnum.h"
18#include "llvm/ADT/Sequence.h"
19#include "llvm/Support/raw_ostream.h"
20
21namespace llvm {
22
23/// Flags indicating whether a memory access modifies or references memory.
24///
25/// This is no access at all, a modification, a reference, or both
26/// a modification and a reference.
27enum class ModRefInfo : uint8_t {
28 /// The access neither references nor modifies the value stored in memory.
29 NoModRef = 0,
30 /// The access may reference the value stored in memory.
31 Ref = 1,
32 /// The access may modify the value stored in memory.
33 Mod = 2,
34 /// The access may reference and may modify the value stored in memory.
35 ModRef = Ref | Mod,
36 LLVM_MARK_AS_BITMASK_ENUM(ModRef),
37};
38
39[[nodiscard]] inline bool isNoModRef(const ModRefInfo MRI) {
40 return MRI == ModRefInfo::NoModRef;
41}
42[[nodiscard]] inline bool isModOrRefSet(const ModRefInfo MRI) {
43 return MRI != ModRefInfo::NoModRef;
44}
45[[nodiscard]] inline bool isModAndRefSet(const ModRefInfo MRI) {
46 return MRI == ModRefInfo::ModRef;
47}
48[[nodiscard]] inline bool isModSet(const ModRefInfo MRI) {
49 return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod);
50}
51[[nodiscard]] inline bool isRefSet(const ModRefInfo MRI) {
52 return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref);
53}
54
55/// Debug print ModRefInfo.
56raw_ostream &operator<<(raw_ostream &OS, ModRefInfo MR);
57
58/// The locations at which a function might access memory.
59enum class IRMemLocation {
60 /// Access to memory via argument pointers.
61 ArgMem = 0,
62 /// Memory that is inaccessible via LLVM IR.
63 InaccessibleMem = 1,
64 /// Any other memory.
65 Other = 2,
66
67 /// Helpers to iterate all locations in the MemoryEffectsBase class.
68 First = ArgMem,
69 Last = Other,
70};
71
72template <typename LocationEnum> class MemoryEffectsBase {
73public:
74 using Location = LocationEnum;
75
76private:
77 uint32_t Data = 0;
78
79 static constexpr uint32_t BitsPerLoc = 2;
80 static constexpr uint32_t LocMask = (1 << BitsPerLoc) - 1;
81
82 static uint32_t getLocationPos(Location Loc) {
83 return (uint32_t)Loc * BitsPerLoc;
84 }
85
86 MemoryEffectsBase(uint32_t Data) : Data(Data) {}
87
88 void setModRef(Location Loc, ModRefInfo MR) {
89 Data &= ~(LocMask << getLocationPos(Loc));
90 Data |= static_cast<uint32_t>(MR) << getLocationPos(Loc);
91 }
92
93public:
94 /// Returns iterator over all supported location kinds.
95 static auto locations() {
96 return enum_seq_inclusive(Location::First, Location::Last,
97 force_iteration_on_noniterable_enum);
98 }
99
100 /// Create MemoryEffectsBase that can access only the given location with the
101 /// given ModRefInfo.
102 MemoryEffectsBase(Location Loc, ModRefInfo MR) { setModRef(Loc, MR); }
103
104 /// Create MemoryEffectsBase that can access any location with the given
105 /// ModRefInfo.
106 explicit MemoryEffectsBase(ModRefInfo MR) {
107 for (Location Loc : locations())
108 setModRef(Loc, MR);
109 }
110
111 /// Create MemoryEffectsBase that can read and write any memory.
112 static MemoryEffectsBase unknown() {
113 return MemoryEffectsBase(ModRefInfo::ModRef);
114 }
115
116 /// Create MemoryEffectsBase that cannot read or write any memory.
117 static MemoryEffectsBase none() {
118 return MemoryEffectsBase(ModRefInfo::NoModRef);
119 }
120
121 /// Create MemoryEffectsBase that can read any memory.
122 static MemoryEffectsBase readOnly() {
123 return MemoryEffectsBase(ModRefInfo::Ref);
124 }
125
126 /// Create MemoryEffectsBase that can write any memory.
127 static MemoryEffectsBase writeOnly() {
128 return MemoryEffectsBase(ModRefInfo::Mod);
129 }
130
131 /// Create MemoryEffectsBase that can only access argument memory.
132 static MemoryEffectsBase argMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
133 return MemoryEffectsBase(Location::ArgMem, MR);
134 }
135
136 /// Create MemoryEffectsBase that can only access inaccessible memory.
137 static MemoryEffectsBase
138 inaccessibleMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
139 return MemoryEffectsBase(Location::InaccessibleMem, MR);
140 }
141
142 /// Create MemoryEffectsBase that can only access inaccessible or argument
143 /// memory.
144 static MemoryEffectsBase
145 inaccessibleOrArgMemOnly(ModRefInfo MR = ModRefInfo::ModRef) {
146 MemoryEffectsBase FRMB = none();
147 FRMB.setModRef(Location::ArgMem, MR);
148 FRMB.setModRef(Location::InaccessibleMem, MR);
149 return FRMB;
150 }
151
152 /// Create MemoryEffectsBase from an encoded integer value (used by memory
153 /// attribute).
154 static MemoryEffectsBase createFromIntValue(uint32_t Data) {
155 return MemoryEffectsBase(Data);
156 }
157
158 /// Convert MemoryEffectsBase into an encoded integer value (used by memory
159 /// attribute).
160 uint32_t toIntValue() const {
161 return Data;
162 }
163
164 /// Get ModRefInfo for the given Location.
165 ModRefInfo getModRef(Location Loc) const {
166 return ModRefInfo((Data >> getLocationPos(Loc)) & LocMask);
167 }
168
169 /// Get new MemoryEffectsBase with modified ModRefInfo for Loc.
170 MemoryEffectsBase getWithModRef(Location Loc, ModRefInfo MR) const {
171 MemoryEffectsBase ME = *this;
172 ME.setModRef(Loc, MR);
173 return ME;
174 }
175
176 /// Get new MemoryEffectsBase with NoModRef on the given Loc.
177 MemoryEffectsBase getWithoutLoc(Location Loc) const {
178 MemoryEffectsBase ME = *this;
179 ME.setModRef(Loc, ModRefInfo::NoModRef);
180 return ME;
181 }
182
183 /// Get ModRefInfo for any location.
184 ModRefInfo getModRef() const {
185 ModRefInfo MR = ModRefInfo::NoModRef;
186 for (Location Loc : locations())
187 MR |= getModRef(Loc);
188 return MR;
189 }
190
191 /// Whether this function accesses no memory.
192 bool doesNotAccessMemory() const { return Data == 0; }
193
194 /// Whether this function only (at most) reads memory.
195 bool onlyReadsMemory() const { return !isModSet(getModRef()); }
196
197 /// Whether this function only (at most) writes memory.
198 bool onlyWritesMemory() const { return !isRefSet(getModRef()); }
199
200 /// Whether this function only (at most) accesses argument memory.
201 bool onlyAccessesArgPointees() const {
202 return getWithoutLoc(Loc: Location::ArgMem).doesNotAccessMemory();
203 }
204
205 /// Whether this function may access argument memory.
206 bool doesAccessArgPointees() const {
207 return isModOrRefSet(getModRef(Location::ArgMem));
208 }
209
210 /// Whether this function only (at most) accesses inaccessible memory.
211 bool onlyAccessesInaccessibleMem() const {
212 return getWithoutLoc(Loc: Location::InaccessibleMem).doesNotAccessMemory();
213 }
214
215 /// Whether this function only (at most) accesses argument and inaccessible
216 /// memory.
217 bool onlyAccessesInaccessibleOrArgMem() const {
218 return getWithoutLoc(Loc: Location::InaccessibleMem)
219 .getWithoutLoc(Location::ArgMem)
220 .doesNotAccessMemory();
221 }
222
223 /// Intersect with other MemoryEffectsBase.
224 MemoryEffectsBase operator&(MemoryEffectsBase Other) const {
225 return MemoryEffectsBase(Data & Other.Data);
226 }
227
228 /// Intersect (in-place) with other MemoryEffectsBase.
229 MemoryEffectsBase &operator&=(MemoryEffectsBase Other) {
230 Data &= Other.Data;
231 return *this;
232 }
233
234 /// Union with other MemoryEffectsBase.
235 MemoryEffectsBase operator|(MemoryEffectsBase Other) const {
236 return MemoryEffectsBase(Data | Other.Data);
237 }
238
239 /// Union (in-place) with other MemoryEffectsBase.
240 MemoryEffectsBase &operator|=(MemoryEffectsBase Other) {
241 Data |= Other.Data;
242 return *this;
243 }
244
245 /// Subtract other MemoryEffectsBase.
246 MemoryEffectsBase operator-(MemoryEffectsBase Other) const {
247 return MemoryEffectsBase(Data & ~Other.Data);
248 }
249
250 /// Subtract (in-place) with other MemoryEffectsBase.
251 MemoryEffectsBase &operator-=(MemoryEffectsBase Other) {
252 Data &= ~Other.Data;
253 return *this;
254 }
255
256 /// Check whether this is the same as other MemoryEffectsBase.
257 bool operator==(MemoryEffectsBase Other) const { return Data == Other.Data; }
258
259 /// Check whether this is different from other MemoryEffectsBase.
260 bool operator!=(MemoryEffectsBase Other) const { return !operator==(Other); }
261};
262
263/// Summary of how a function affects memory in the program.
264///
265/// Loads from constant globals are not considered memory accesses for this
266/// interface. Also, functions may freely modify stack space local to their
267/// invocation without having to report it through these interfaces.
268using MemoryEffects = MemoryEffectsBase<IRMemLocation>;
269
270/// Debug print MemoryEffects.
271raw_ostream &operator<<(raw_ostream &OS, MemoryEffects RMRB);
272
273// Legacy alias.
274using FunctionModRefBehavior = MemoryEffects;
275
276} // namespace llvm
277
278#endif
279

source code of llvm/include/llvm/Support/ModRef.h