Knowledge about storage.

test/libyul/YulOptimizerTest.cpp

@@ -43,6 +43,7 @@
 #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>
@@ -252,6 +253,21 @@ 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")
+	{
+		disambiguate();
+		ForLoopInitRewriter{}(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
+		ExpressionSplitter{*m_dialect, nameDispenser}(*m_ast);
+		CommonSubexpressionEliminator{*m_dialect}(*m_ast);
+		ExpressionSimplifier::run(*m_dialect, *m_ast);
+
+		SLoadResolver{*m_dialect}(*m_ast);
+
+		UnusedPruner::runUntilStabilised(*m_dialect, *m_ast);
+		ExpressionJoiner::run(*m_ast);
+		ExpressionJoiner::run(*m_ast);
+	}
 	else if (m_optimizerStep == "controlFlowSimplifier")
 	{
 		disambiguate();

test/libyul/yulOptimizerTests/fullSuite/storage.yul

@@ -0,0 +1,15 @@
+{
+    sstore(4, 5)
+    sstore(4, 3)
+    sstore(8, sload(4))
+}
+// ====
+// step: fullSuite
+// ----
+// {
+//     {
+//         sstore(4, 5)
+//         sstore(4, 3)
+//         sstore(8, sload(4))
+//     }
+// }

test/libyul/yulOptimizerTests/sloadResolver/reassign.yul

@@ -0,0 +1,16 @@
+{
+    let a := calldataload(0)
+    sstore(a, 6)
+    a := calldataload(2)
+    mstore(0, sload(a))
+}
+// ====
+// step: sloadResolver
+// ----
+// {
+//     let _1 := 0
+//     let a := calldataload(_1)
+//     sstore(a, 6)
+//     a := calldataload(2)
+//     mstore(_1, sload(a))
+// }

test/libyul/yulOptimizerTests/sloadResolver/reassign_value_expression.yul

@@ -0,0 +1,32 @@
+{
+    let x := calldataload(1)
+    let a := add(x, 10)
+    sstore(a, 7)
+    // This clears the expression assigned to ``a`` but
+    // should not clear storage knowledge
+    x := 9
+    mstore(sload(a), 11)
+    // This, on the other hand, actually clears knowledge
+    a := 33
+    mstore(sload(a), 11)
+    // Try again with different expression to avoid
+    // clearing because we cannot know if it is different
+    a := 39
+    mstore(sload(a), 11)
+}
+// ====
+// step: sloadResolver
+// ----
+// {
+//     let x := calldataload(1)
+//     let a := add(x, 10)
+//     let _3 := 7
+//     sstore(a, _3)
+//     x := 9
+//     let _4 := 11
+//     mstore(_3, _4)
+//     a := 33
+//     mstore(sload(a), _4)
+//     a := 39
+//     mstore(sload(a), _4)
+// }

test/libyul/yulOptimizerTests/sloadResolver/second_store.yul

@@ -0,0 +1,19 @@
+{
+    let x := calldataload(1)
+    sstore(x, 7)
+    sstore(calldataload(0), 6)
+    // We cannot replace this because we do not know
+    // if the two slots are different.
+    mstore(0, sload(x))
+}
+// ====
+// step: sloadResolver
+// ----
+// {
+//     let x := calldataload(1)
+//     sstore(x, 7)
+//     let _3 := 6
+//     let _4 := 0
+//     sstore(calldataload(_4), _3)
+//     mstore(_4, sload(x))
+// }

test/libyul/yulOptimizerTests/sloadResolver/second_store_same_value.yul

@@ -0,0 +1,19 @@
+{
+    let x := calldataload(1)
+    sstore(x, 7)
+    sstore(calldataload(0), 7)
+    // We can replace this because both values that were
+    // written are 7.
+    mstore(0, sload(x))
+}
+// ====
+// step: sloadResolver
+// ----
+// {
+//     let x := calldataload(1)
+//     let _2 := 7
+//     sstore(x, _2)
+//     let _4 := 0
+//     sstore(calldataload(_4), _2)
+//     mstore(_4, _2)
+// }

test/libyul/yulOptimizerTests/sloadResolver/simple.yul

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