Tests and Changelog

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/complex_move.yul

@@ -0,0 +1,23 @@
+{
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := extcodesize(keccak256(mul(mload(inv), 3), 32))
+    a := add(x, 1)
+    sstore(a, inv)
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     let x := extcodesize(keccak256(mul(mload(inv), 3), 32))
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         a := add(x, 1)
+//         sstore(a, inv)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/create_sload.yul

@@ -0,0 +1,30 @@
+{
+  function g() -> x { x := create(100, 0, 32) }
+  function f() -> x { x := mload(0) }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    // cannot be moved because of the create call in g()
+    let q := sload(5)
+    let r := g()
+    // This can be moved
+    let z := f()
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function g() -> x
+//     { x := create(100, 0, 32) }
+//     function f() -> x_1
+//     { x_1 := mload(0) }
+//     let b := 1
+//     let a := 1
+//     let z := f()
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         let q := sload(5)
+//         let r := g()
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/move_memory_function.yul

@@ -0,0 +1,24 @@
+{
+  function g() -> x { x := add(sload(mload(x)), 1) }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := mload(g())
+    let s := keccak256(g(), 32)
+    let q := g()
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function g() -> x
+//     { x := add(sload(mload(x)), 1) }
+//     let b := 1
+//     let a := 1
+//     let t := mload(g())
+//     let s := keccak256(g(), 32)
+//     let q := g()
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     { }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/move_state_function.yul

@@ -0,0 +1,25 @@
+{
+  function f() -> x { x := mload(g()) }
+  function g() -> x { x := add(sload(x), 1) }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := extcodesize(f())
+    let q := g()
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := mload(g()) }
+//     function g() -> x_1
+//     { x_1 := add(sload(x_1), 1) }
+//     let b := 1
+//     let a := 1
+//     let t := extcodesize(f())
+//     let q := g()
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     { }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/move_storage_function.yul

@@ -0,0 +1,25 @@
+{
+  function f() -> x { x := g() }
+  function g() -> x { x := add(x, 1) }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := sload(f())
+    let q := g()
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := g() }
+//     function g() -> x_1
+//     { x_1 := add(x_1, 1) }
+//     let b := 1
+//     let a := 1
+//     let t := sload(f())
+//     let q := g()
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     { }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_immovables.yul

@@ -0,0 +1,29 @@
+{
+  let a := 1
+  function f() -> x {invalid()}
+  function g() -> y {return(0, 0)}
+  for { let i := 1 } iszero(eq(i, 10)) { a := add(i, 1) } {
+    let b := f()
+    let c := gas()
+    let d := g()
+    let e := sload(g())
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let a := 1
+//     function f() -> x
+//     { invalid() }
+//     function g() -> y
+//     { return(0, 0) }
+//     let i := 1
+//     for { } iszero(eq(i, 10)) { a := add(i, 1) }
+//     {
+//         let b := f()
+//         let c := gas()
+//         let d := g()
+//         let e := sload(g())
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory.yul

@@ -0,0 +1,38 @@
+{
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := keccak256(inv, 32)
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    // mload prevents moving of extcodesize
+    let x := extcodesize(mload(mul(inv, 3)))
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         let x := keccak256(inv, 32)
+//         a := add(x, 1)
+//         mstore(a, inv)
+//     }
+//     let a_1 := 1
+//     let inv_2 := add(b, 42)
+//     for { } iszero(eq(a_1, 10)) { a_1 := add(a_1, 1) }
+//     {
+//         let x_3 := extcodesize(mload(mul(inv_2, 3)))
+//         a_1 := add(x_3, 1)
+//         mstore(a_1, inv_2)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory_loop.yul

@@ -0,0 +1,29 @@
+{
+  function f() -> x { x := g() }
+  function g() -> x { for {} 1 {} {} }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := mload(f())
+    let q := g()
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := g() }
+//     function g() -> x_1
+//     {
+//         for { } 1 { }
+//         { }
+//     }
+//     let b := 1
+//     let a := 1
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         let t := mload(f())
+//         let q := g()
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory_msize.yul

@@ -0,0 +1,35 @@
+{
+  let b := 1
+  let c := msize() // prevents moving keccak and mload
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := keccak256(inv, 32)
+    a := add(x, 1)
+  }
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := extcodesize(mload(mul(inv, 3)))
+    a := add(x, 1)
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let c := msize()
+//     let a := 1
+//     let inv := add(b, 42)
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         let x := keccak256(inv, 32)
+//         a := add(x, 1)
+//     }
+//     let a_1 := 1
+//     let inv_2 := add(b, 42)
+//     for { } iszero(eq(a_1, 10)) { a_1 := add(a_1, 1) }
+//     {
+//         let x_3 := extcodesize(mload(mul(inv_2, 3)))
+//         a_1 := add(x_3, 1)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state.yul

@@ -0,0 +1,62 @@
+{
+  let b := 1
+  // invalidates state in post
+  for { let a := 1 } iszero(eq(a, 10)) {pop(call(2, 0x01, 2, 0x00, 32, 0x010, 32))} {
+    let inv := add(b, 42)
+    let x := extcodesize(mul(inv, 3))
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    pop(create(0x08, 0x00, 0x02)) // invalidates state
+    let x := extcodesize(mul(inv, 3))
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+
+  // invalidates state in loop-condition
+  for { let a := 1 } iszero(create(0x08, 0x00, 0x02)) { a := add(a, 1)} {
+    let inv := add(b, 42)
+    let x := extcodesize(mul(inv, 3))
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     for { }
+//     iszero(eq(a, 10))
+//     {
+//         pop(call(2, 0x01, 2, 0x00, 32, 0x010, 32))
+//     }
+//     {
+//         let x := extcodesize(mul(inv, 3))
+//         a := add(x, 1)
+//         mstore(a, inv)
+//     }
+//     let a_1 := 1
+//     let inv_2 := add(b, 42)
+//     for { } iszero(eq(a_1, 10)) { a_1 := add(a_1, 1) }
+//     {
+//         pop(create(0x08, 0x00, 0x02))
+//         let x_3 := extcodesize(mul(inv_2, 3))
+//         a_1 := add(x_3, 1)
+//         mstore(a_1, inv_2)
+//     }
+//     let a_4 := 1
+//     let inv_5 := add(b, 42)
+//     for { } iszero(create(0x08, 0x00, 0x02)) { a_4 := add(a_4, 1) }
+//     {
+//         let x_6 := extcodesize(mul(inv_5, 3))
+//         a_4 := add(x_6, 1)
+//         mstore(a_4, inv_5)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_function.yul

@@ -0,0 +1,32 @@
+{
+  function f() -> x { x := g() }
+  function g() -> x {
+    x := add(x, 1)
+    sstore(0x00, 0x00)
+  }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := extcodesize(f())
+    let q := sload(g())
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := g() }
+//     function g() -> x_1
+//     {
+//         x_1 := add(x_1, 1)
+//         sstore(0x00, 0x00)
+//     }
+//     let b := 1
+//     let a := 1
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         let t := extcodesize(f())
+//         let q := sload(g())
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_loop.yul

@@ -0,0 +1,29 @@
+{
+  function f() -> x { x := g() }
+  function g() -> x { for {} 1 {} {} }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := extcodesize(f())
+    let q := g()
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := g() }
+//     function g() -> x_1
+//     {
+//         for { } 1 { }
+//         { }
+//     }
+//     let b := 1
+//     let a := 1
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         let t := extcodesize(f())
+//         let q := g()
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_recursive_function.yul

@@ -0,0 +1,26 @@
+{
+  function f() -> x { x := g() }
+  function g() -> x { x := g() }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := extcodesize(f())
+    let q := sload(g())
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := g() }
+//     function g() -> x_1
+//     { x_1 := g() }
+//     let b := 1
+//     let a := 1
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         let t := extcodesize(f())
+//         let q := sload(g())
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_staticall_returndatasize.yul

@@ -0,0 +1,32 @@
+{
+  let b := 1
+  // invalidates state in post
+  for { let a := 1 } iszero(eq(a, 10)) {pop(call(2, 0x01, 2, 0x00, 32, 0x010, 32))} {
+    let inv := add(b, 42)
+    let x := returndatasize()
+    a := add(x, 1)
+    pop(staticcall(2, 3, 0, 32, 64, 32)) // prevents moving returndatasize
+    mstore(a, inv)
+  }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     for { }
+//     iszero(eq(a, 10))
+//     {
+//         pop(call(2, 0x01, 2, 0x00, 32, 0x010, 32))
+//     }
+//     {
+//         let x := returndatasize()
+//         a := add(x, 1)
+//         pop(staticcall(2, 3, 0, 32, 64, 32))
+//         mstore(a, inv)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_storage.yul

@@ -0,0 +1,57 @@
+{
+  let b := 1
+  // invalidates storage in post
+  for { let a := 1 } iszero(eq(a, 10)) { sstore(0x00, 0x01)} {
+    let inv := add(b, 42)
+    let x := sload(mul(inv, 3))
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+
+  // invalidates storage in body
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := sload(mul(inv, 3))
+    a := add(x, 1)
+    sstore(a, inv)
+  }
+
+  // invalidates state in body
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    pop(callcode(100, 0x010, 10, 0x00, 32, 0x0100, 32))
+    let x := sload(mul(inv, 3))
+    a := add(x, 1)
+  }
+
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     for { } iszero(eq(a, 10)) { sstore(0x00, 0x01) }
+//     {
+//         let x := sload(mul(inv, 3))
+//         a := add(x, 1)
+//         mstore(a, inv)
+//     }
+//     let a_1 := 1
+//     let inv_2 := add(b, 42)
+//     for { } iszero(eq(a_1, 10)) { a_1 := add(a_1, 1) }
+//     {
+//         let x_3 := sload(mul(inv_2, 3))
+//         a_1 := add(x_3, 1)
+//         sstore(a_1, inv_2)
+//     }
+//     let a_4 := 1
+//     let inv_5 := add(b, 42)
+//     for { } iszero(eq(a_4, 10)) { a_4 := add(a_4, 1) }
+//     {
+//         pop(callcode(100, 0x010, 10, 0x00, 32, 0x0100, 32))
+//         let x_6 := sload(mul(inv_5, 3))
+//         a_4 := add(x_6, 1)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_storage_function.yul

@@ -0,0 +1,28 @@
+{
+  function f() -> x { x := g() }
+  function g() -> x {
+    x := add(x, 1)
+    sstore(0x00, 0x00)
+  }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let q := sload(g())
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := g() }
+//     function g() -> x_1
+//     {
+//         x_1 := add(x_1, 1)
+//         sstore(0x00, 0x00)
+//     }
+//     let b := 1
+//     let a := 1
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     { let q := sload(g()) }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_storage_loop.yul

@@ -0,0 +1,25 @@
+{
+  function f() -> x { x := g() }
+  function g() -> x { for {} 1 {} {} }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let t := sload(f())
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function f() -> x
+//     { x := g() }
+//     function g() -> x_1
+//     {
+//         for { } 1 { }
+//         { }
+//     }
+//     let b := 1
+//     let a := 1
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     { let t := sload(f()) }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/not_first.yul

@@ -0,0 +1,21 @@
+{
+  function g() -> x { x := add(mload(x), 1) }
+
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    sstore(0, a)
+    let q := keccak256(g(), 32)
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     function g() -> x
+//     { x := add(mload(x), 1) }
+//     let b := 1
+//     let a := 1
+//     let q := keccak256(g(), 32)
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     { sstore(0, a) }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/simple_memory.yul

@@ -0,0 +1,25 @@
+{
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := mload(mul(inv, 3))
+    let y := keccak256(mul(b, 13), 32)
+    a := add(x, 1)
+    sstore(a, inv)
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     let x := mload(mul(inv, 3))
+//     let y := keccak256(mul(b, 13), 32)
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         a := add(x, 1)
+//         sstore(a, inv)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/simple_state.yul

@@ -0,0 +1,23 @@
+{
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := extcodesize(mul(inv, 3))
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     let x := extcodesize(mul(inv, 3))
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         a := add(x, 1)
+//         mstore(a, inv)
+//     }
+// }

test/libyul/yulOptimizerTests/loopInvariantCodeMotion/simple_storage.yul

@@ -0,0 +1,23 @@
+{
+  let b := 1
+  for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    let inv := add(b, 42)
+    let x := sload(mul(inv, 3))
+    a := add(x, 1)
+    mstore(a, inv)
+  }
+}
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let b := 1
+//     let a := 1
+//     let inv := add(b, 42)
+//     let x := sload(mul(inv, 3))
+//     for { } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
+//         a := add(x, 1)
+//         mstore(a, inv)
+//     }
+// }