Tune Rematerializer

test/libyul/yulOptimizerTests/fullSuite/clear_after_if_continue.yul

@@ -12,7 +12,8 @@
 // {
 //     {
 //         let y := mload(0x20)
-//         for { } and(y, 8) { if y { revert(0, 0) } }
+//         let _1 := iszero(and(y, 8))
+//         for { } iszero(_1) { if y { revert(0, 0) } }
 //         {
 //             if y { continue }
 //             sstore(1, 0)

test/libyul/yulOptimizerTests/fullSuite/devcon_example.yul

@@ -21,8 +21,9 @@
 //     {
 //         let _1 := calldataload(0)
 //         let sum := 0
+//         let length := calldataload(_1)
 //         let i := sum
-//         for { } lt(i, calldataload(_1)) { i := add(i, 1) }
+//         for { } lt(i, length) { i := add(i, 1) }
 //         {
 //             sum := add(sum, calldataload(add(add(_1, mul(i, 0x20)), 0x20)))
 //         }

test/libyul/yulOptimizerTests/fullSuite/loopInvariantCodeMotion.yul

@@ -24,10 +24,12 @@
 //     {
 //         let _1 := calldataload(0)
 //         let sum := 0
+//         let length := calldataload(_1)
 //         let i := sum
-//         for { } lt(i, calldataload(_1)) { i := add(i, 1) }
+//         let _2 := calldataload(7)
+//         for { } lt(i, length) { i := add(i, 1) }
 //         {
-//             sum := add(sum, add(calldataload(add(add(_1, mul(i, 0x20)), 0x20)), calldataload(7)))
+//             sum := add(sum, add(calldataload(add(add(_1, mul(i, 0x20)), 0x20)), _2))
 //         }
 //         sstore(0, sum)
 //     }

test/libyul/yulOptimizerTests/fullSuite/no_move_loop_orig.yul

@@ -12,10 +12,11 @@
 // ----
 // {
 //     {
+//         let _1 := iszero(caller())
 //         for { }
 //         1
 //         {
-//             for { } caller() { }
+//             for { } iszero(_1) { }
 //             { }
 //             mstore(192, 0)
 //         }

test/libyul/yulOptimizerTests/rematerialiser/many_refs_small_cost_loop.yul

@@ -0,0 +1,28 @@
+{
+	// Cost of rematerializating x is 1
+	let x := 0xff
+	// Although x has low cost, it is not considered for
+	// rematerialization because it is referenced more than 5 times
+	for {} lt(x, 0x100) {}
+	{
+		let y := add(x, 1)
+		let z := mul(x, 1)
+		let a := div(x, 2)
+		let b := mod(x, 3)
+		let c := sdiv(x, 4)
+	}
+}
+// ====
+// step: rematerialiser
+// ----
+// {
+//     let x := 0xff
+//     for { } lt(x, 0x100) { }
+//     {
+//         let y := add(x, 1)
+//         let z := mul(x, 1)
+//         let a := div(x, 2)
+//         let b := mod(x, 3)
+//         let c := sdiv(x, 4)
+//     }
+// }

test/libyul/yulOptimizerTests/rematerialiser/no_remat_in_loop.yul

@@ -0,0 +1,37 @@
+{
+	// origin has zero cost and thus will be rematerialised,
+	// calldataload(0) has low cost and will not be rematerialised
+	let a := origin()
+	let b := calldataload(0)
+	let i := 0
+	let z := calldataload(9)
+	for {} lt(i, 10) {i := add(a, b)} {
+		// This will be rematerialised, because it stays inside
+		// the loop.
+		let x := calldataload(1)
+		mstore(9, x)
+		// No, because again one loop further down.
+		let y := calldataload(2)
+		for {} y {} {
+			// Again no.
+			mstore(12, z)
+		}
+	}
+}
+// ====
+// step: rematerialiser
+// ----
+// {
+//     let a := origin()
+//     let b := calldataload(0)
+//     let i := 0
+//     let z := calldataload(9)
+//     for { } lt(i, 10) { i := add(origin(), b) }
+//     {
+//         let x := calldataload(1)
+//         mstore(9, calldataload(1))
+//         let y := calldataload(2)
+//         for { } y { }
+//         { mstore(12, z) }
+//     }
+// }

test/libyul/yulOptimizerTests/rematerialiser/some_refs_small_cost_loop.yul

@@ -0,0 +1,17 @@
+{
+	// Cost of rematerializating x is 1
+	let x := 0xff
+	// Reference to x is not rematerialized because the reference is in a loop
+	for {} lt(x, 0x100) {}
+	{
+		let y := add(x, 1)
+	}
+}
+// ====
+// step: rematerialiser
+// ----
+// {
+//     let x := 0xff
+//     for { } lt(0xff, 0x100) { }
+//     { let y := add(0xff, 1) }
+// }

test/libyul/yulOptimizerTests/rematerialiser/some_refs_small_cost_nested_loop.yul

@@ -0,0 +1,26 @@
+{
+	// Cost of rematerializating x is 1
+	let x := 0xff
+	// Although x has a low cost and fewer than 6 references,
+	// its references in a loop are not rematerialized
+	for {} lt(x, 0x100) {}
+	{
+		let y := add(x, 1)
+		for {} lt(x, 0x200) {}
+		{
+			let z := mul(x, 2)
+		}
+	}
+}
+// ====
+// step: rematerialiser
+// ----
+// {
+//     let x := 0xff
+//     for { } lt(0xff, 0x100) { }
+//     {
+//         let y := add(0xff, 1)
+//         for { } lt(0xff, 0x200) { }
+//         { let z := mul(0xff, 2) }
+//     }
+// }