Preliminary Yul block outliner implementation.

test/libyul/YulOptimizerTest.cpp

@@ -20,6 +20,7 @@
 #include <test/Options.h>
 
 #include <libyul/optimiser/BlockFlattener.h>
+#include <libyul/optimiser/BlockOutliner.h>
 #include <libyul/optimiser/VarDeclInitializer.h>
 #include <libyul/optimiser/VarNameCleaner.h>
 #include <libyul/optimiser/ControlFlowSimplifier.h>
@@ -116,6 +117,13 @@ TestCase::TestResult YulOptimizerTest::run(ostream& _stream, string const& _line
 		disambiguate();
 		BlockFlattener{}(*m_ast);
 	}
+	else if (m_optimizerStep == "blockOutliner")
+	{
+		disambiguate();
+		(FunctionHoister{})(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
+		BlockOutliner::run(*m_ast, nameDispenser);
+	}
 	else if (m_optimizerStep == "varDeclInitializer")
 		VarDeclInitializer{}(*m_ast);
 	else if (m_optimizerStep == "varNameCleaner")

test/libyul/yulOptimizerTests/blockOutliner/basic.yul

@@ -0,0 +1,91 @@
+{
+	{
+		let a let b let c let d
+		{
+			a := mul(c,b)
+			if lt(a,c) {
+				a := add(a,c)
+			}
+		}
+		{
+			if eq(1,2) {
+				d := mul(a,b)
+				if lt(d,a) {
+					d := add(d,a)
+				}
+			}
+			{
+				d := add(d,a)
+			}
+		}
+		{
+			c := mul(a,b)
+			if lt(c,a) {
+				c := add(c,a)
+			}
+		}
+	}
+	function f(a, b) -> r {
+	    {
+			r := mul(a,b)
+			if lt(r, a) {
+			    r := add(r,a)
+			}
+		}
+		function g(x, y) -> z {
+		    z := mul(x,y)
+			if lt(z,x) {
+			    z := add(z,x)
+			}
+		}
+		r := g(b,a)
+	}
+	function h(a) -> r {
+		{
+		    r := add(r,a)
+		}
+		{
+		    r := add(r,a)
+		}
+	}
+}
+// ====
+// step: blockOutliner
+// ----
+// {
+//     {
+//         let a
+//         let b
+//         let c
+//         let d
+//         { a := g_1(a, c, b) }
+//         {
+//             if eq(1, 2) { d := g_1(d, a, b) }
+//             { d := outlined$66$(d, a) }
+//         }
+//         { c := g_1(c, a, b) }
+//     }
+//     function g(x, y) -> z
+//     { z := g_1(z, x, y) }
+//     function f(a_1, b_2) -> r
+//     {
+//         { r := g_1(r, a_1, b_2) }
+//         r := g(b_2, a_1)
+//     }
+//     function h(a_3) -> r_4
+//     {
+//         { r_4 := outlined$66$(r_4, a_3) }
+//         { r_4 := outlined$66$(r_4, a_3) }
+//     }
+//     function outlined$66$(a, c) -> a_2
+//     {
+//         a := add(a, c)
+//         a_2 := a
+//     }
+//     function g_1(a, c, b) -> a_4
+//     {
+//         a := mul(c, b)
+//         if lt(a, c) { a := outlined$66$(a, c) }
+//         a_4 := a
+//     }
+// }

test/libyul/yulOptimizerTests/blockOutliner/break_continue.yul

@@ -0,0 +1,75 @@
+{
+    let a := 1
+    let b := 2
+    let c := 3
+	{
+		for {} 1 {} {
+			{ a := mul(b,c) }
+			if gt(a,b) { break }
+		}
+	}
+	{
+		for {} 1 {} {
+			{ a := mul(b,c) }
+			if gt(a,b) { break }
+		}
+	}
+	{
+		for {} 1 {} {
+			{ a := mul(b,c) }
+			if gt(a,b) { break }
+		}
+	}
+	{
+		for {} 1 {} {
+			{ a := mul(b,c) }
+			if gt(a,b) { continue }
+		}
+	}
+	{
+		for {} 1 {} {
+			{ a := mul(b,c) }
+			if gt(a,b) { continue }
+		}
+	}
+	{
+		for {} 1 {} {
+			{ a := mul(b,c) }
+			if gt(a,b) { continue }
+		}
+	}
+}
+// ====
+// step: blockOutliner
+// ----
+// {
+//     let a := 1
+//     let b := 2
+//     let c := 3
+//     { a := outlined$48$(a, b, c) }
+//     { a := outlined$48$(a, b, c) }
+//     { a := outlined$48$(a, b, c) }
+//     { a := outlined$261$(a, b, c) }
+//     { a := outlined$261$(a, b, c) }
+//     { a := outlined$261$(a, b, c) }
+//     function outlined$69$(b, c) -> a
+//     { a := mul(b, c) }
+//     function outlined$48$(a, b, c) -> a_1
+//     {
+//         for { } 1 { }
+//         {
+//             { a := outlined$69$(b, c) }
+//             if gt(a, b) { break }
+//         }
+//         a_1 := a
+//     }
+//     function outlined$261$(a, b, c) -> a_2
+//     {
+//         for { } 1 { }
+//         {
+//             { a := outlined$69$(b, c) }
+//             if gt(a, b) { continue }
+//         }
+//         a_2 := a
+//     }
+// }

test/libyul/yulOptimizerTests/blockOutliner/nested.yul

@@ -0,0 +1,20 @@
+{
+  {
+    function f() -> x { x := 1 }
+    { mstore(f(), 2) }
+    { mstore(f(), 2) }
+  }
+}
+// ====
+// step: blockOutliner
+// ----
+// {
+//     {
+//         { outlined$43$() }
+//         { outlined$43$() }
+//     }
+//     function f() -> x
+//     { x := 1 }
+//     function outlined$43$()
+//     { mstore(f(), 2) }
+// }

test/libyul/yulOptimizerTests/blockOutliner/nested_inner.yul

@@ -0,0 +1,22 @@
+{
+  {
+    function f() -> x { x := 1 }
+    { { mstore(f(), 2) } }
+    { { mstore(f(), 2) } }
+  }
+}
+// ====
+// step: blockOutliner
+// ----
+// {
+//     {
+//         { outlined$43$() }
+//         { outlined$43$() }
+//     }
+//     function f() -> x
+//     { x := 1 }
+//     function outlined$45$()
+//     { mstore(f(), 2) }
+//     function outlined$43$()
+//     { { outlined$45$() } }
+// }

test/libyul/yulOptimizerTests/blockOutliner/only_assign.yul

@@ -0,0 +1,27 @@
+{
+    let a
+    let b
+    let c
+    {
+        a := mul(b,c)
+    }
+    {
+        b := mul(c,a)
+    }
+    {
+        c := mul(a,b)
+    }
+}
+// ====
+// step: blockOutliner
+// ----
+// {
+//     let a
+//     let b
+//     let c
+//     { a := outlined$36$(b, c) }
+//     { b := outlined$36$(c, a) }
+//     { c := outlined$36$(a, b) }
+//     function outlined$36$(b, c) -> a
+//     { a := mul(b, c) }
+// }