Also optimize memory.

test/libyul/YulOptimizerTest.cpp

@@ -35,6 +35,7 @@
 #include <libyul/optimiser/FullInliner.h>
 #include <libyul/optimiser/ForLoopConditionIntoBody.h>
 #include <libyul/optimiser/ForLoopInitRewriter.h>
+#include <libyul/optimiser/LoadResolver.h>
 #include <libyul/optimiser/MainFunction.h>
 #include <libyul/optimiser/NameDisplacer.h>
 #include <libyul/optimiser/Rematerialiser.h>
@@ -43,7 +44,6 @@
 #include <libyul/optimiser/ExpressionJoiner.h>
 #include <libyul/optimiser/SSAReverser.h>
 #include <libyul/optimiser/SSATransform.h>
-#include <libyul/optimiser/SLoadResolver.h>
 #include <libyul/optimiser/RedundantAssignEliminator.h>
 #include <libyul/optimiser/StructuralSimplifier.h>
 #include <libyul/optimiser/StackCompressor.h>
@@ -253,7 +253,7 @@ TestCase::TestResult YulOptimizerTest::run(ostream& _stream, string const& _line
 		SSATransform::run(*m_ast, nameDispenser);
 		RedundantAssignEliminator::run(*m_dialect, *m_ast);
 	}
-	else if (m_optimizerStep == "sloadResolver")
+	else if (m_optimizerStep == "loadResolver")
 	{
 		disambiguate();
 		ForLoopInitRewriter{}(*m_ast);
@@ -262,7 +262,7 @@ TestCase::TestResult YulOptimizerTest::run(ostream& _stream, string const& _line
 		CommonSubexpressionEliminator{*m_dialect}(*m_ast);
 		ExpressionSimplifier::run(*m_dialect, *m_ast);
 
-		SLoadResolver{*m_dialect}(*m_ast);
+		LoadResolver::run(*m_dialect, *m_ast);
 
 		UnusedPruner::runUntilStabilised(*m_dialect, *m_ast);
 		ExpressionJoiner::run(*m_ast);

test/libyul/yulOptimizerTests/loadResolver/memory_with_different_kinds_of_invalidation.yul

@@ -0,0 +1,38 @@
+{
+    mstore(2, 9)
+    sstore(0, mload(2))
+    pop(call(0, 0, 0, 0, 0, 0, 0))
+    sstore(0, mload(2))
+
+    mstore(2, 10)
+    mstore8(calldataload(0), 4)
+    sstore(0, mload(2))
+
+    mstore(2, 10)
+    g()
+    sstore(0, mload(2))
+
+    function g() {}
+}
+// ====
+// step: loadResolver
+// ----
+// {
+//     let _1 := 9
+//     let _2 := 2
+//     mstore(_2, _1)
+//     let _4 := _1
+//     let _5 := 0
+//     sstore(_5, _4)
+//     pop(call(_5, _5, _5, _5, _5, _5, _5))
+//     sstore(_5, mload(_2))
+//     let _17 := 10
+//     mstore(_2, _17)
+//     mstore8(calldataload(_5), 4)
+//     sstore(_5, mload(_2))
+//     mstore(_2, _17)
+//     g()
+//     sstore(_5, mload(_2))
+//     function g()
+//     { }
+// }

test/libyul/yulOptimizerTests/loadResolver/memory_with_msize.yul

@@ -0,0 +1,17 @@
+{
+    // No mload removal because of msize
+    mstore(calldataload(0), msize())
+    let t := mload(calldataload(10))
+    let q := mload(calldataload(0))
+    sstore(t, q)
+}
+// ====
+// step: loadResolver
+// ----
+// {
+//     let _1 := msize()
+//     let _3 := calldataload(0)
+//     mstore(_3, _1)
+//     let t := mload(calldataload(10))
+//     sstore(t, mload(_3))
+// }

test/libyul/yulOptimizerTests/loadResolver/merge_known_write.yul

@@ -0,0 +1,22 @@
+{
+    mstore(calldataload(0), calldataload(10))
+    if calldataload(1) {
+        mstore(calldataload(0), 1)
+    }
+    let t := mload(0)
+    let q := mload(calldataload(0))
+    sstore(t, q)
+}
+// ====
+// step: loadResolver
+// ----
+// {
+//     let _2 := calldataload(10)
+//     let _3 := 0
+//     let _4 := calldataload(_3)
+//     mstore(_4, _2)
+//     let _5 := 1
+//     if calldataload(_5) { mstore(_4, _5) }
+//     let t := mload(_3)
+//     sstore(t, mload(_4))
+// }

test/libyul/yulOptimizerTests/loadResolver/merge_known_write_with_distance.yul

@@ -0,0 +1,20 @@
+{
+    mstore(calldataload(0), calldataload(10))
+    if calldataload(1) {
+        mstore(add(calldataload(0), 0x20), 1)
+    }
+    let t := mload(add(calldataload(0), 0x20))
+    let q := mload(calldataload(0))
+    sstore(t, q)
+}
+// ====
+// step: loadResolver
+// ----
+// {
+//     let _2 := calldataload(10)
+//     let _4 := calldataload(0)
+//     mstore(_4, _2)
+//     let _5 := 1
+//     if calldataload(_5) { mstore(add(_4, 0x20), _5) }
+//     sstore(mload(add(_4, 0x20)), _2)
+// }

test/libyul/yulOptimizerTests/loadResolver/merge_unknown_write.yul

@@ -0,0 +1,22 @@
+{
+    mstore(calldataload(0), calldataload(10))
+    if calldataload(1) {
+        mstore(0, 1)
+    }
+    let t := mload(0)
+    let q := mload(calldataload(0))
+    sstore(t, q)
+}
+// ====
+// step: loadResolver
+// ----
+// {
+//     let _2 := calldataload(10)
+//     let _3 := 0
+//     let _4 := calldataload(_3)
+//     mstore(_4, _2)
+//     let _5 := 1
+//     if calldataload(_5) { mstore(_3, _5) }
+//     let t := mload(_3)
+//     sstore(t, mload(_4))
+// }

test/libyul/yulOptimizerTests/loadResolver/reassign.yul

@@ -5,7 +5,7 @@
     mstore(0, sload(a))
 }
 // ====
-// step: sloadResolver
+// step: loadResolver
 // ----
 // {
 //     let _1 := 0

test/libyul/yulOptimizerTests/loadResolver/reassign_value_expression.yul

@@ -15,7 +15,7 @@
     mstore(sload(a), 11)
 }
 // ====
-// step: sloadResolver
+// step: loadResolver
 // ----
 // {
 //     let x := calldataload(1)

test/libyul/yulOptimizerTests/loadResolver/second_mstore_with_delta.yul

@@ -0,0 +1,24 @@
+{
+    let x := calldataload(1)
+    let a := add(x, 10)
+    let b := add(x, 42)
+    mstore(a, 7)
+    // does not invalidate the first store, because the
+    // difference is larger than 32, even if the absolute
+    // values are unknown
+    mstore(b, 8)
+    sstore(mload(a), mload(b))
+}
+// ====
+// step: loadResolver
+// ----
+// {
+//     let x := calldataload(1)
+//     let a := add(x, 10)
+//     let b := add(x, 42)
+//     let _4 := 7
+//     mstore(a, _4)
+//     let _5 := 8
+//     mstore(b, _5)
+//     sstore(_4, _5)
+// }

test/libyul/yulOptimizerTests/loadResolver/second_store.yul

@@ -7,7 +7,7 @@
     mstore(0, sload(x))
 }
 // ====
-// step: sloadResolver
+// step: loadResolver
 // ----
 // {
 //     let x := calldataload(1)

test/libyul/yulOptimizerTests/loadResolver/second_store_same_value.yul

@@ -7,7 +7,7 @@
     mstore(0, sload(x))
 }
 // ====
-// step: sloadResolver
+// step: loadResolver
 // ----
 // {
 //     let x := calldataload(1)

test/libyul/yulOptimizerTests/loadResolver/second_store_with_delta.yul

@@ -10,7 +10,7 @@
     mstore(sload(a), sload(b))
 }
 // ====
-// step: sloadResolver
+// step: loadResolver
 // ----
 // {
 //     let x := calldataload(1)

test/libyul/yulOptimizerTests/loadResolver/simple.yul

@@ -5,7 +5,7 @@
     mstore(t, q)
 }
 // ====
-// step: sloadResolver
+// step: loadResolver
 // ----
 // {
 //     let _2 := calldataload(10)

test/libyul/yulOptimizerTests/loadResolver/simple_memory.yul

@@ -0,0 +1,14 @@
+{
+    mstore(calldataload(0), calldataload(10))
+    let t := mload(calldataload(10))
+    let q := mload(calldataload(0))
+    sstore(t, q)
+}
+// ====
+// step: loadResolver
+// ----
+// {
+//     let _2 := calldataload(10)
+//     mstore(calldataload(0), _2)
+//     sstore(mload(_2), _2)
+// }