107class ReadsWrites :
public Inspector,
public ResolutionContext {
108 std::map<const IR::Expression *, const SetOfLocations *> rw;
111 ReadsWrites() { setName(
"ReadsWrites"); }
113 void postorder(
const IR::Operation_Binary *expression)
override {
114 auto left = ::P4::get(rw, expression->left);
115 auto right = ::P4::get(rw, expression->right);
118 rw.emplace(expression, left->join(right));
121 void postorder(
const IR::PathExpression *expression)
override {
122 auto decl = getDeclaration(expression->path);
125 rw.emplace(expression, locs);
128 void postorder(
const IR::Operation_Unary *expression)
override {
129 auto e = ::P4::get(rw, expression->expr);
131 rw.emplace(expression, e);
134 void postorder(
const IR::Member *expression)
override {
135 auto e = ::P4::get(rw, expression->expr);
137 auto result = e->append(expression->member);
138 rw.emplace(expression, result);
141 void postorder(
const IR::ArrayIndex *expression)
override {
142 auto e = ::P4::get(rw, expression->left);
145 if (expression->right->is<IR::Constant>()) {
146 int index = expression->right->to<IR::Constant>()->asInt();
147 result = e->
append(Util::toString(index));
149 auto index = ::P4::get(rw, expression->right);
150 result = e->
append(
"*"_cs)->join(index);
152 rw.emplace(expression, result);
155 void postorder(
const IR::Literal *expression)
override {
159 void postorder(
const IR::InvalidHeader *expression)
override {
163 void postorder(
const IR::InvalidHeaderUnion *expression)
override {
167 void postorder(
const IR::ArrayExpression *expression)
override {
169 for (
auto e : expression->components) {
170 auto s = ::P4::get(rw, e);
172 result = result->join(s);
174 rw.emplace(expression, result);
177 void postorder(
const IR::TypeNameExpression *expression)
override {
181 void postorder(
const IR::Operation_Ternary *expression)
override {
182 auto e0 = ::P4::get(rw, expression->e0);
183 auto e1 = ::P4::get(rw, expression->e1);
184 auto e2 = ::P4::get(rw, expression->e2);
188 rw.emplace(expression, e0->join(e1)->join(e2));
191 void postorder(
const IR::AbstractSlice *expression)
override {
192 auto e = ::P4::get(rw, expression->e0);
194 rw.emplace(expression, e);
197 void postorder(
const IR::MethodCallExpression *expression)
override {
198 auto e = ::P4::get(rw, expression->method);
199 for (
auto a : *expression->arguments) {
200 auto s = ::P4::get(rw, a->expression);
204 rw.emplace(expression, e);
207 void postorder(
const IR::ConstructorCallExpression *expression)
override {
209 for (
auto e : *expression->arguments) {
210 auto s = ::P4::get(rw, e->expression);
212 result = result->join(s);
214 rw.emplace(expression, result);
217 void postorder(
const IR::StructExpression *expression)
override {
219 for (
auto e : expression->components) {
220 auto s = ::P4::get(rw, e->expression);
222 result = result->join(s);
224 rw.emplace(expression, result);
227 void postorder(
const IR::ListExpression *expression)
override {
229 for (
auto e : expression->components) {
230 auto s = ::P4::get(rw, e);
232 result = result->join(s);
234 rw.emplace(expression, result);
237 void postorder(
const IR::DefaultExpression *expression)
override {
241 const SetOfLocations *get(
const IR::Expression *expression,
const Visitor::Context *ctxt) {
242 expression->apply(*
this, ctxt);
243 auto result = ::P4::get(rw, expression);
245 LOG3(
"SetOfLocations(" << expression <<
")=" << result);
249 bool mayAlias(
const IR::Expression *left,
const IR::Expression *right,
250 const Visitor::Context *ctxt) {
251 auto llocs = get(left, ctxt);
252 auto rlocs = get(right, ctxt);
255 LOG3(
"Checking overlap between " << llocs <<
" and " << rlocs);
256 return llocs->overlaps(rlocs);