Tests for conditional unsimplifier

test/libyul/YulOptimizerTest.cpp

@@ -27,6 +27,7 @@
 #include <libyul/optimiser/DeadCodeEliminator.h>
 #include <libyul/optimiser/Disambiguator.h>
 #include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/optimiser/ConditionalUnsimplifier.h>
 #include <libyul/optimiser/ConditionalSimplifier.h>
 #include <libyul/optimiser/CommonSubexpressionEliminator.h>
 #include <libyul/optimiser/NameCollector.h>
@@ -158,6 +159,11 @@ TestCase::TestResult YulOptimizerTest::run(ostream& _stream, string const& _line
 		disambiguate();
 		CommonSubexpressionEliminator::run(*m_context, *m_ast);
 	}
+	else if (m_optimizerStep == "conditionalUnsimplifier")
+	{
+		disambiguate();
+		ConditionalUnsimplifier::run(*m_context, *m_ast);
+	}
 	else if (m_optimizerStep == "conditionalSimplifier")
 	{
 		disambiguate();

test/libyul/yulOptimizerTests/conditionalUnsimplifier/clear_after_if_break.yul

@@ -0,0 +1,15 @@
+{
+    let y := mload(0x20)
+    for {} and(y, 8) { pop(y) } {
+        if y { break }
+        y := 0
+    }
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let y := mload(0x20)
+//     for { } and(y, 8) { pop(y) }
+//     { if y { break } }
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/clear_after_if_continue.yul

@@ -0,0 +1,15 @@
+{
+    let y := mload(0x20)
+    for {} and(y, 8) { pop(y) } {
+        if y { continue }
+        y := 0
+    }
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let y := mload(0x20)
+//     for { } and(y, 8) { pop(y) }
+//     { if y { continue } }
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/clear_before_for_condition.yul

@@ -0,0 +1,22 @@
+{
+    let x := mload(0)
+    let y := mload(0)
+    if x { revert(0, 0) }
+    x := 0
+    if y { revert(0, 0) }
+    y := 0
+    for {} and(x, y) {} {
+        x := 2
+    }
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let x := mload(0)
+//     let y := mload(0)
+//     if x { revert(0, 0) }
+//     if y { revert(0, 0) }
+//     for { } and(x, y) { }
+//     { x := 2 }
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/clear_before_for_post.yul

@@ -0,0 +1,21 @@
+{
+    let x
+    for {} x { sstore(1, x) } {
+        if x { continue }
+        x := 0
+        sstore(0, x)
+    }
+    sstore(0, x)
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let x
+//     for { } x { sstore(1, x) }
+//     {
+//         if x { continue }
+//         sstore(0, x)
+//     }
+//     sstore(0, x)
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/no_opt_if_break_is_not_last.yul

@@ -0,0 +1,34 @@
+{
+    let x := mload(0)
+    for {} 1 {} {
+        if x { sstore(7, 8) break sstore(8, 9) }
+        x := 0
+        sstore(1, x)
+        if x { sstore(7, 8) break }
+        x := 0
+        sstore(10, x)
+    }
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let x := mload(0)
+//     for { } 1 { }
+//     {
+//         if x
+//         {
+//             sstore(7, 8)
+//             break
+//             sstore(8, 9)
+//         }
+//         x := 0
+//         sstore(1, x)
+//         if x
+//         {
+//             sstore(7, 8)
+//             break
+//         }
+//         sstore(10, x)
+//     }
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/no_opt_inside_if.yul

@@ -0,0 +1,15 @@
+{
+    let x := mload(0)
+    if x { sstore(0, x) }
+    x := 0
+    sstore(1, x)
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let x := mload(0)
+//     if x { sstore(0, x) }
+//     x := 0
+//     sstore(1, x)
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/opt_after_terminating_if.yul

@@ -0,0 +1,18 @@
+{
+    let x := mload(0)
+    if x { sstore(0, x) revert(0, 0) }
+    x := 0
+    sstore(1, x)
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let x := mload(0)
+//     if x
+//     {
+//         sstore(0, x)
+//         revert(0, 0)
+//     }
+//     sstore(1, x)
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/opt_switch.yul

@@ -0,0 +1,22 @@
+{
+    let x := calldataload(0)
+    switch x
+    case 0 { x := 0 }
+    case 1 { x := 1 }
+    case 2 { x := 8 /* wrong literal */ }
+    default { }
+
+    pop(x)
+}
+// ====
+// step: conditionalUnsimplifier
+// ----
+// {
+//     let x := calldataload(0)
+//     switch x
+//     case 0 { }
+//     case 1 { }
+//     case 2 { x := 8 }
+//     default { }
+//     pop(x)
+// }

test/libyul/yulOptimizerTests/conditionalUnsimplifier/smoke.yul

@@ -0,0 +1,5 @@
+{ }
+// ====
+// step: conditionalUnsimplifier
+// ----
+// { }