Move function arguments and return values.

test/libyul/YulOptimizerTestCommon.cpp

@@ -338,6 +338,10 @@ YulOptimizerTestCommon::YulOptimizerTestCommon(
 				{
 					YulString originalFunctionName = m_currentFunction;
 					m_currentFunction = _function.name;
+					for (TypedName const& _argument: _function.parameters)
+						visitVariableName(_argument.name);
+					for (TypedName const& _argument: _function.returnVariables)
+						visitVariableName(_argument.name);
 					ASTWalker::operator()(_function);
 					m_currentFunction = originalFunctionName;
 				}

test/libyul/yulOptimizerTests/fakeStackLimitEvader/function_arg.yul

@@ -15,6 +15,9 @@
 //     mstore(0x00, 0)
 //     sstore(0, mload(0x00))
 //     function h($hx) -> y
-//     { y := $hx }
+//     {
+//         mstore(0x20, $hx)
+//         y := mload(0x20)
+//     }
 //     sstore(1, h(32))
 // }

test/libyul/yulOptimizerTests/fakeStackLimitEvader/return_leave.yul

@@ -0,0 +1,48 @@
+{
+    {
+        mstore(0x40, memoryguard(0x80))
+        let a1, a2 := f()
+        sstore(a1, a2)
+    }
+    function g(x) -> a, b { a := x b := 2 }
+    function f() -> $b1, $b2 {
+        if calldataload(0) {
+            $b1, $b2 := g(1)
+            leave
+        }
+        $b1, $b2 := g(2)
+    }
+
+}
+// ----
+// step: fakeStackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0xc0))
+//         f()
+//         let a2 := mload(0x80)
+//         let a1 := mload(0xa0)
+//         sstore(a1, a2)
+//     }
+//     function g(x) -> a, b
+//     {
+//         a := x
+//         b := 2
+//     }
+//     function f()
+//     {
+//         mstore(0xa0, 0)
+//         mstore(0x80, 0)
+//         if calldataload(0)
+//         {
+//             let $b1_1, $b2_2 := g(1)
+//             mstore(0x80, $b2_2)
+//             mstore(0xa0, $b1_1)
+//             leave
+//         }
+//         let $b1_3, $b2_4 := g(2)
+//         mstore(0x80, $b2_4)
+//         mstore(0xa0, $b1_3)
+//     }
+// }

test/libyul/yulOptimizerTests/fakeStackLimitEvader/return_one.yul

@@ -0,0 +1,38 @@
+{
+    {
+        mstore(0x40, memoryguard(0x80))
+        sstore(0, f())
+    }
+    function f() -> $b1 {
+        if calldataload(0) {
+            $b1 := 0
+            leave
+        }
+        $b1 := 1
+    }
+
+}
+// ----
+// step: fakeStackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0xa0))
+//         sstore(0, f())
+//     }
+//     function f() -> $b1
+//     {
+//         mstore(0x80, 0)
+//         f_1()
+//         $b1 := mload(0x80)
+//     }
+//     function f_1()
+//     {
+//         if calldataload(0)
+//         {
+//             mstore(0x80, 0)
+//             leave
+//         }
+//         mstore(0x80, 1)
+//     }
+// }

test/libyul/yulOptimizerTests/stackLimitEvader/function_arg.yul

@@ -50,6 +50,7 @@
 //     }
 //     function f(a1) -> v
 //     {
+//         mstore(0x80, a1)
 //         let a2 := calldataload(mul(2, 4))
 //         let a3 := calldataload(mul(3, 4))
 //         let a4 := calldataload(mul(4, 4))
@@ -66,7 +67,7 @@
 //         let a15 := calldataload(mul(15, 4))
 //         let a16 := calldataload(mul(16, 4))
 //         let a17 := calldataload(mul(17, 4))
-//         sstore(0, a1)
+//         sstore(0, mload(0x80))
 //         sstore(mul(17, 4), a17)
 //         sstore(mul(16, 4), a16)
 //         sstore(mul(15, 4), a15)
@@ -83,6 +84,6 @@
 //         sstore(mul(4, 4), a4)
 //         sstore(mul(3, 4), a3)
 //         sstore(mul(2, 4), a2)
-//         sstore(mul(1, 4), a1)
+//         sstore(mul(1, 4), mload(0x80))
 //     }
 // }

test/libyul/yulOptimizerTests/stackLimitEvader/stub.yul

@@ -1,13 +1,12 @@
 {
     {
         mstore(0x40, memoryguard(128))
-        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16), f())
+        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17), f())
     }
-    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16) -> v {
-        // Should be, but cannot yet be escalated.
-        v := b16
+    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17) -> v {
+        v := add(b16, b17)
     }
-    function f() -> v{
+    function f() -> v {
 	let a1 := calldataload(mul(1,4))
 	let a2 := calldataload(mul(2,4))
 	let a3 := calldataload(mul(3,4))
@@ -52,10 +51,10 @@
 // {
 //     {
 //         mstore(0x40, memoryguard(0xa0))
-//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), f())
+//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17), f())
 //     }
-//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16) -> v
-//     { v := b16 }
+//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17) -> v
+//     { v := add(b16, b17) }
 //     function f() -> v_1
 //     {
 //         mstore(0x80, calldataload(mul(1, 4)))

test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_14.yul

@@ -0,0 +1,55 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29), 0)
+    }
+    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29) -> v {
+	sstore(0, b14)
+	sstore(1, b15)
+	sstore(2, b16)
+	sstore(3, b17)
+	sstore(4, b18)
+	sstore(5, b19)
+	sstore(6, b29)
+        v := add(b1,b29)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x02c0))
+//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29), 0)
+//     }
+//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29) -> v
+//     {
+//         mstore(0x02a0, b1)
+//         mstore(0x0280, b2)
+//         mstore(0x0260, b3)
+//         mstore(0x0240, b4)
+//         mstore(0x0220, b5)
+//         mstore(0x0200, b6)
+//         mstore(0x01e0, b7)
+//         mstore(0x01c0, b8)
+//         mstore(0x01a0, b9)
+//         mstore(0x0180, b10)
+//         mstore(0x0160, b11)
+//         mstore(0x0140, b12)
+//         mstore(0x0120, b13)
+//         mstore(0x0100, b14)
+//         mstore(0xc0, b17)
+//         mstore(0xa0, b18)
+//         mstore(0x80, b19)
+//         mstore(0xe0, b29)
+//         sstore(0, mload(0x0100))
+//         sstore(1, b15)
+//         sstore(2, b16)
+//         sstore(3, mload(0xc0))
+//         sstore(4, mload(0xa0))
+//         sstore(5, mload(0x80))
+//         sstore(6, mload(0xe0))
+//         v := add(mload(0x02a0), mload(0xe0))
+//     }
+// }

test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_15.yul

@@ -0,0 +1,61 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29, 30), 0)
+    }
+    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) -> v {
+	sstore(0, b14)
+	sstore(1, b15)
+	sstore(2, b16)
+	sstore(3, b17)
+	sstore(4, b18)
+	sstore(5, b19)
+	sstore(6, b29)
+	sstore(7, b30)
+        v := b30
+        sstore(b1, b30)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0300))
+//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30), 0)
+//     }
+//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) -> v
+//     {
+//         mstore(0x02e0, b1)
+//         mstore(0x02c0, b2)
+//         mstore(0x02a0, b3)
+//         mstore(0x0280, b4)
+//         mstore(0x0260, b5)
+//         mstore(0x0240, b6)
+//         mstore(0x0220, b7)
+//         mstore(0x0200, b8)
+//         mstore(0x01e0, b9)
+//         mstore(0x01c0, b10)
+//         mstore(0x01a0, b11)
+//         mstore(0x0180, b12)
+//         mstore(0x0160, b13)
+//         mstore(0x0140, b14)
+//         mstore(0x0120, b15)
+//         mstore(0xc0, b17)
+//         mstore(0xa0, b18)
+//         mstore(0x80, b19)
+//         mstore(0xe0, b29)
+//         mstore(0x0100, b30)
+//         sstore(0, mload(0x0140))
+//         sstore(1, mload(0x0120))
+//         sstore(2, b16)
+//         sstore(3, mload(0xc0))
+//         sstore(4, mload(0xa0))
+//         sstore(5, mload(0x80))
+//         sstore(6, mload(0xe0))
+//         sstore(7, mload(0x0100))
+//         v := mload(0x0100)
+//         sstore(mload(0x02e0), mload(0x0100))
+//     }
+// }

test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_16.yul

@@ -0,0 +1,63 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31), 0)
+    }
+    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) -> v {
+	sstore(0, b14)
+	sstore(1, b15)
+	sstore(2, b16)
+	sstore(3, b17)
+	sstore(4, b18)
+	sstore(5, b19)
+	sstore(6, b29)
+	sstore(7, b30)
+	sstore(8, b31)
+        v := add(b1,b31)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0340))
+//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31), 0)
+//     }
+//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) -> v
+//     {
+//         mstore(0x0320, b1)
+//         mstore(0x0300, b2)
+//         mstore(0x02e0, b3)
+//         mstore(0x02c0, b4)
+//         mstore(0x02a0, b5)
+//         mstore(0x0280, b6)
+//         mstore(0x0260, b7)
+//         mstore(0x0240, b8)
+//         mstore(0x0220, b9)
+//         mstore(0x0200, b10)
+//         mstore(0x01e0, b11)
+//         mstore(0x01c0, b12)
+//         mstore(0x01a0, b13)
+//         mstore(0x0180, b14)
+//         mstore(0x0160, b15)
+//         mstore(0x0140, b16)
+//         mstore(0xc0, b17)
+//         mstore(0xa0, b18)
+//         mstore(0x80, b19)
+//         mstore(0xe0, b29)
+//         mstore(0x0120, b30)
+//         mstore(0x0100, b31)
+//         sstore(0, mload(0x0180))
+//         sstore(1, mload(0x0160))
+//         sstore(2, mload(0x0140))
+//         sstore(3, mload(0xc0))
+//         sstore(4, mload(0xa0))
+//         sstore(5, mload(0x80))
+//         sstore(6, mload(0xe0))
+//         sstore(7, mload(0x0120))
+//         sstore(8, mload(0x0100))
+//         v := add(mload(0x0320), mload(0x0100))
+//     }
+// }

test/libyul/yulOptimizerTests/stackLimitEvader/too_many_returns_15.yul

@@ -0,0 +1,48 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+	let a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)
+        sstore(0, 1)
+	a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)
+    }
+    function g(b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) -> b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 {
+	b1 := 1
+	b2 := 2
+	b15 := 15
+	sstore(b16, b30)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0260))
+//         let a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)
+//         sstore(0, 1)
+//         a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)
+//     }
+//     function g(b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) -> b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+//     {
+//         mstore(0x0240, b16)
+//         mstore(0x0220, b17)
+//         mstore(0x0200, b18)
+//         mstore(0x01e0, b19)
+//         mstore(0x01c0, b20)
+//         mstore(0x01a0, b21)
+//         mstore(0x0180, b22)
+//         mstore(0x0160, b23)
+//         mstore(0x0140, b24)
+//         mstore(0x0120, b25)
+//         mstore(0x0100, b26)
+//         mstore(0xe0, b27)
+//         mstore(0xc0, b28)
+//         mstore(0xa0, b29)
+//         mstore(0x80, b30)
+//         b1 := 1
+//         b2 := 2
+//         b15 := 15
+//         sstore(mload(0x0240), mload(0x80))
+//     }
+// }

test/libyul/yulOptimizerTests/stackLimitEvader/too_many_returns_16.yul

@@ -0,0 +1,49 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+	let a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31)
+        sstore(0, 1)
+	a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31)
+    }
+    function g(b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) -> b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 {
+	b1 := 1
+	b2 := 2
+	b15 := 15
+        sstore(b16, b31)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0280))
+//         let a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31)
+//         sstore(0, 1)
+//         a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 := g(16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31)
+//     }
+//     function g(b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) -> b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15
+//     {
+//         mstore(0x0260, b16)
+//         mstore(0x0240, b17)
+//         mstore(0x0220, b18)
+//         mstore(0x0200, b19)
+//         mstore(0x01e0, b20)
+//         mstore(0x01c0, b21)
+//         mstore(0x01a0, b22)
+//         mstore(0x0180, b23)
+//         mstore(0x0160, b24)
+//         mstore(0x0140, b25)
+//         mstore(0x0120, b26)
+//         mstore(0x0100, b27)
+//         mstore(0xe0, b28)
+//         mstore(0xc0, b29)
+//         mstore(0xa0, b30)
+//         mstore(0x80, b31)
+//         b1 := 1
+//         b2 := 2
+//         b15 := 15
+//         sstore(mload(0x0260), mload(0x80))
+//     }
+// }