Cache ReadsWrites instances for alias analysis

Persist ReadsWrites instances in DoSimplifyExpressions and RemoveAliases
instead of recreating them on every mayAlias() call. This reuses the
internal lookup cache across multiple checks.

Also cache GetWrittenExpressions results to avoid recomputing them for
the same MethodCallExpression.

Signed-off-by: Attaullah Ansari <mdattaullahansari152@gmail.com>

Author: atta-ullah01

frontends/p4/alias.h

@@ -242,6 +242,10 @@ class ReadsWrites : public Inspector, public ResolutionContext {
     }
 
     const SetOfLocations *get(const IR::Expression *expression, const Visitor::Context *ctxt) {
+        if (auto it = rw.find(expression); it != rw.end()) {
+            LOG3("SetOfLocations(" << expression << ")=" << it->second << " [cached]");
+            return it->second;
+        }
         expression->apply(*this, ctxt);
         auto result = ::P4::get(rw, expression);
         CHECK_NULL(result);

frontends/p4/sideEffects.cpp

@@ -320,9 +320,7 @@ const IR::Node *DoSimplifyExpressions::preorder(IR::LOr *expression) {
 
 bool DoSimplifyExpressions::mayAlias(const IR::Expression *left, const IR::Expression *right,
                                      const Visitor::Context *ctxt) const {
-    // FIXME: This recreates ReadWrites() over and over again, loosing all
-    // declaration lookup caching
-    return ReadsWrites().mayAlias(left, right, ctxt);
+    return readsWrites.mayAlias(left, right, ctxt);
 }
 
 /// Returns true if type is a header or a struct containing a header.
@@ -406,24 +404,27 @@ const IR::Node *DoSimplifyExpressions::preorder(IR::MethodCallExpression *mce) {
     // large structs.  We want to avoid copying these large
     // structs if possible.
     std::set<const IR::Parameter *> useTemporary;
-    // Set of expressions modified while evaluating this method call.
     ordered_set<const IR::Expression *> modifies;
-    // FIXME: We need to be able to cache results here and not to recompute over
-    // and over again
-    GetWrittenExpressions gwe(typeMap);
-    gwe.setCalledBy(this);
-    mce->apply(gwe, getContext());
+    auto cacheIt = writtenExpressionsCache.find(orig);
+    if (cacheIt != writtenExpressionsCache.end()) {
+        modifies = cacheIt->second;
+    } else {
+        GetWrittenExpressions gwe(typeMap);
+        gwe.setCalledBy(this);
+        mce->apply(gwe, getContext());
+        writtenExpressionsCache[orig] = gwe.written;
+        modifies = gwe.written;
+    }
 
     for (auto p : *mi->substitution.getParametersInArgumentOrder()) {
         if (p->direction == IR::Direction::None) continue;
         auto arg = mi->substitution.lookup(p);
-        if (gwe.written.find(GetWrittenExpressions::everything) != gwe.written.end()) {
+        if (modifies.find(GetWrittenExpressions::everything) != modifies.end()) {
             // just copy everything.
             LOG3("Detected table application, using temporaries for all parameters " << arg);
             for (auto p : *mi->substitution.getParametersInArgumentOrder()) useTemporary.emplace(p);
             break;
         }
-        modifies.insert(gwe.written.begin(), gwe.written.end());
 
         // If an argument evaluation has side-effects then
         // always use a temporary to hold the argument value.

frontends/p4/sideEffects.h

@@ -21,6 +21,7 @@ limitations under the License.
 
 #include "frontends/common/resolveReferences/referenceMap.h"
 #include "frontends/common/resolveReferences/resolveReferences.h"
+#include "frontends/p4/alias.h"
 #include "frontends/p4/methodInstance.h"
 #include "frontends/p4/typeChecking/typeChecker.h"
 #include "ir/ir.h"
@@ -149,6 +150,9 @@ class DoSimplifyExpressions : public Transform, P4WriteContext, public Resolutio
     TypeMap *typeMap;
     // Expressions holding temporaries that are already added.
     std::set<const IR::Expression *> *added;
+    mutable ReadsWrites readsWrites;
+    std::map<const IR::MethodCallExpression *, ordered_set<const IR::Expression *>>
+        writtenExpressionsCache;
 
     IR::IndexedVector<IR::Declaration> toInsert;  // temporaries
     IR::IndexedVector<IR::StatOrDecl> statements;

midend/copyStructures.cpp

@@ -27,10 +27,8 @@ const IR::Node *RemoveAliases::postorder(IR::AssignmentStatement *statement) {
         return statement;
     }
 
-    // FIXME: This recreates ReadWrites() over and over again, loosing all
-    // declaration lookup caching
-    ReadsWrites rw;
-    if (!rw.mayAlias(statement->left, statement->right, getContext())) {
+
+    if (!readsWrites.mayAlias(statement->left, statement->right, getContext())) {
         return statement;
     }
     auto tmp = nameGen.newName("tmp");

midend/copyStructures.h

@@ -17,6 +17,7 @@ limitations under the License.
 #ifndef MIDEND_COPYSTRUCTURES_H_
 #define MIDEND_COPYSTRUCTURES_H_
 
+#include "frontends/p4/alias.h"
 #include "frontends/p4/typeChecking/typeChecker.h"
 #include "ir/ir.h"
 
@@ -104,6 +105,7 @@ class DoCopyStructures : public Transform {
 class RemoveAliases : public Transform {
     MinimalNameGenerator nameGen;
     TypeMap *typeMap;
+    mutable ReadsWrites readsWrites;
 
     IR::IndexedVector<IR::Declaration> declarations;