cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #12262 from ethereum/functionGrouper

Browse Source 
Keep canonical form of Yul during optimization.
This commit is contained in:
chriseth 2021-11-10 11:09:15 +01:00 committed by GitHub
commit f42e3c0bae
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
169 changed files with 936 additions and 652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
docs/internals/optimizer.rst
View File

@ -972,10 +972,13 @@ BlockFlattener
^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
This stage eliminates nested blocks by inserting the statement in the This stage eliminates nested blocks by inserting the statement in the
inner block at the appropriate place in the outer block: inner block at the appropriate place in the outer block. It depends on the
FunctionGrouper and does not flatten the outermost block to keep the form
produced by the FunctionGrouper.
.. code-block:: yul .. code-block:: yul
{
{ {
let x := 2 let x := 2
{ {
@ -983,16 +986,19 @@ inner block at the appropriate place in the outer block:
mstore(x, y) mstore(x, y)
} }
} }
}
is transformed to is transformed to
.. code-block:: yul .. code-block:: yul
{
{ {
let x := 2 let x := 2
let y := 3 let y := 3
mstore(x, y) mstore(x, y)
} }
}
As long as the code is disambiguated, this does not cause a problem because As long as the code is disambiguated, this does not cause a problem because
the scopes of variables can only grow. the scopes of variables can only grow.

12
libyul/optimiser/BlockFlattener.cpp
View File

@ -43,3 +43,15 @@ void BlockFlattener::operator()(Block& _block)
} }
); );
} }
void BlockFlattener::run(OptimiserStepContext&, Block& _ast)
{
BlockFlattener flattener;
for (auto& statement: _ast.statements)
if (auto* block = get_if<Block>(&statement))
flattener(*block);
else if (auto* function = get_if<FunctionDefinition>(&statement))
flattener(function->body);
else
yulAssert(false, "BlockFlattener requires the FunctionGrouper.");
}

2
libyul/optimiser/BlockFlattener.h
View File

@ -27,7 +27,7 @@ class BlockFlattener: public ASTModifier
{ {
public: public:
static constexpr char const* name{"BlockFlattener"}; static constexpr char const* name{"BlockFlattener"};
static void run(OptimiserStepContext&, Block& _ast) { BlockFlattener{}(_ast); } static void run(OptimiserStepContext&, Block& _ast);
using ASTModifier::operator(); using ASTModifier::operator();
void operator()(Block& _block) override; void operator()(Block& _block) override;

2
libyul/optimiser/CircularReferencesPruner.cpp
View File

@ -18,6 +18,7 @@
#include <libyul/optimiser/CircularReferencesPruner.h> #include <libyul/optimiser/CircularReferencesPruner.h>
#include <libyul/optimiser/CallGraphGenerator.h> #include <libyul/optimiser/CallGraphGenerator.h>
#include <libyul/optimiser/FunctionGrouper.h>
#include <libyul/optimiser/OptimizerUtilities.h> #include <libyul/optimiser/OptimizerUtilities.h>
#include <libyul/AST.h> #include <libyul/AST.h>
@ -29,6 +30,7 @@ using namespace solidity::yul;
void CircularReferencesPruner::run(OptimiserStepContext& _context, Block& _ast) void CircularReferencesPruner::run(OptimiserStepContext& _context, Block& _ast)
{ {
CircularReferencesPruner{_context.reservedIdentifiers}(_ast); CircularReferencesPruner{_context.reservedIdentifiers}(_ast);
FunctionGrouper::run(_context, _ast);
} }
void CircularReferencesPruner::operator()(Block& _block) void CircularReferencesPruner::operator()(Block& _block)

4
libyul/optimiser/ExpressionJoiner.cpp
View File

@ -22,6 +22,7 @@
#include <libyul/optimiser/ExpressionJoiner.h> #include <libyul/optimiser/ExpressionJoiner.h>
#include <libyul/optimiser/FunctionGrouper.h>
#include <libyul/optimiser/NameCollector.h> #include <libyul/optimiser/NameCollector.h>
#include <libyul/optimiser/OptimizerUtilities.h> #include <libyul/optimiser/OptimizerUtilities.h>
#include <libyul/Exceptions.h> #include <libyul/Exceptions.h>
@ -37,9 +38,10 @@ using namespace std;
using namespace solidity; using namespace solidity;
using namespace solidity::yul; using namespace solidity::yul;
void ExpressionJoiner::run(OptimiserStepContext&, Block& _ast) void ExpressionJoiner::run(OptimiserStepContext& _context, Block& _ast)
{ {
ExpressionJoiner{_ast}(_ast); ExpressionJoiner{_ast}(_ast);
FunctionGrouper::run(_context, _ast);
} }

2
libyul/optimiser/OptimizerUtilities.h
View File

@ -37,6 +37,8 @@ namespace solidity::yul
{ {
/// Removes statements that are just empty blocks (non-recursive). /// Removes statements that are just empty blocks (non-recursive).
/// If this is run on the outermost block, the FunctionGrouper should be run afterwards to keep
/// the canonical form.
void removeEmptyBlocks(Block& _block); void removeEmptyBlocks(Block& _block);
/// Returns true if a given literal can not be used as an identifier. /// Returns true if a given literal can not be used as an identifier.

2
libyul/optimiser/Suite.cpp
View File

@ -118,7 +118,7 @@ void OptimiserSuite::run(
// Some steps depend on properties ensured by FunctionHoister, BlockFlattener, FunctionGrouper and // Some steps depend on properties ensured by FunctionHoister, BlockFlattener, FunctionGrouper and
// ForLoopInitRewriter. Run them first to be able to run arbitrary sequences safely. // ForLoopInitRewriter. Run them first to be able to run arbitrary sequences safely.
suite.runSequence("hfgo", ast); suite.runSequence("hgfo", ast);
NameSimplifier::run(suite.m_context, ast); NameSimplifier::run(suite.m_context, ast);
// Now the user-supplied part // Now the user-supplied part

7
libyul/optimiser/UnusedPruner.cpp
View File

@ -21,6 +21,7 @@
#include <libyul/optimiser/UnusedPruner.h> #include <libyul/optimiser/UnusedPruner.h>
#include <libyul/optimiser/CallGraphGenerator.h> #include <libyul/optimiser/CallGraphGenerator.h>
#include <libyul/optimiser/FunctionGrouper.h>
#include <libyul/optimiser/NameCollector.h> #include <libyul/optimiser/NameCollector.h>
#include <libyul/optimiser/Semantics.h> #include <libyul/optimiser/Semantics.h>
#include <libyul/optimiser/OptimizerUtilities.h> #include <libyul/optimiser/OptimizerUtilities.h>
@ -33,6 +34,12 @@ using namespace std;
using namespace solidity; using namespace solidity;
using namespace solidity::yul; using namespace solidity::yul;
void UnusedPruner::run(OptimiserStepContext& _context, Block& _ast)
{
UnusedPruner::runUntilStabilisedOnFullAST(_context.dialect, _ast, _context.reservedIdentifiers);
FunctionGrouper::run(_context, _ast);
}
UnusedPruner::UnusedPruner( UnusedPruner::UnusedPruner(
Dialect const& _dialect, Dialect const& _dialect,
Block& _ast, Block& _ast,

4
libyul/optimiser/UnusedPruner.h
View File

@ -50,9 +50,7 @@ class UnusedPruner: public ASTModifier
{ {
public: public:
static constexpr char const* name{"UnusedPruner"}; static constexpr char const* name{"UnusedPruner"};
static void run(OptimiserStepContext& _context, Block& _ast) { static void run(OptimiserStepContext& _context, Block& _ast);
UnusedPruner::runUntilStabilisedOnFullAST(_context.dialect, _ast, _context.reservedIdentifiers);
}
using ASTModifier::operator(); using ASTModifier::operator();

4
test/libyul/yulOptimizerTests/blockFlattener/basic.yul
View File

@ -1,3 +1,4 @@
{
{ {
let _1 := mload(0) let _1 := mload(0)
let f_a := mload(1) let f_a := mload(1)
@ -8,10 +9,12 @@
} }
let z := mload(2) let z := mload(2)
} }
}
// ---- // ----
// step: blockFlattener // step: blockFlattener
// //
// { // {
// {
// let _1 := mload(0) // let _1 := mload(0)
// let f_a := mload(1) // let f_a := mload(1)
// let f_r // let f_r
@ -19,3 +22,4 @@
// f_r := add(f_a, calldatasize()) // f_r := add(f_a, calldatasize())
// let z := mload(2) // let z := mload(2)
// } // }
// }

4
test/libyul/yulOptimizerTests/blockFlattener/for_stmt.yul
View File

@ -1,12 +1,16 @@
{
{ {
for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } { for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
a := add(a, 1) a := add(a, 1)
} }
} }
}
// ---- // ----
// step: blockFlattener // step: blockFlattener
// //
// { // {
// {
// for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } // for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) }
// { a := add(a, 1) } // { a := add(a, 1) }
// } // }
// }

4
test/libyul/yulOptimizerTests/blockFlattener/if_stmt.yul
View File

@ -1,3 +1,4 @@
{
{ {
if add(mload(7), sload(mload(3))) if add(mload(7), sload(mload(3)))
{ {
@ -8,10 +9,12 @@
} }
let t := add(3, 9) let t := add(3, 9)
} }
}
// ---- // ----
// step: blockFlattener // step: blockFlattener
// //
// { // {
// {
// if add(mload(7), sload(mload(3))) // if add(mload(7), sload(mload(3)))
// { // {
// let y := add(mload(3), 3) // let y := add(mload(3), 3)
@ -19,3 +22,4 @@
// } // }
// let t := add(3, 9) // let t := add(3, 9)
// } // }
// }

4
test/libyul/yulOptimizerTests/blockFlattener/many_nested_blocks.yul
View File

@ -1,3 +1,4 @@
{
{ {
let a := 3 let a := 3
let b := 4 let b := 4
@ -14,10 +15,12 @@
a := add(a, c) a := add(a, c)
} }
} }
}
// ---- // ----
// step: blockFlattener // step: blockFlattener
// //
// { // {
// {
// let a := 3 // let a := 3
// let b := 4 // let b := 4
// a := add(b, 3) // a := add(b, 3)
@ -27,3 +30,4 @@
// b := add(a, b) // b := add(a, b)
// a := add(a, c) // a := add(a, c)
// } // }
// }

4
test/libyul/yulOptimizerTests/blockFlattener/switch_stmt.yul
View File

@ -1,3 +1,4 @@
{
{ {
let a := 1 let a := 1
switch calldataload(0) switch calldataload(0)
@ -5,10 +6,12 @@
default { a := 3 { a := 4 } } default { a := 3 { a := 4 } }
a := 5 a := 5
} }
}
// ---- // ----
// step: blockFlattener // step: blockFlattener
// //
// { // {
// {
// let a := 1 // let a := 1
// switch calldataload(0) // switch calldataload(0)
// case 0 { // case 0 {
@ -21,3 +24,4 @@
// } // }
// a := 5 // a := 5
// } // }
// }

2
test/libyul/yulOptimizerTests/circularReferencesPruner/called_from_non_function.yul
View File

@ -9,8 +9,10 @@
// step: circularReferencesPruner // step: circularReferencesPruner
// //
// { // {
// {
// let a // let a
// a := h() // a := h()
// }
// function f() -> x // function f() -> x
// { x := g() } // { x := g() }
// function g() -> y // function g() -> y

2
test/libyul/yulOptimizerTests/circularReferencesPruner/nested_different_names.yul
View File

@ -11,4 +11,4 @@
// ---- // ----
// step: circularReferencesPruner // step: circularReferencesPruner
// //
// { } // { { } }

2
test/libyul/yulOptimizerTests/circularReferencesPruner/nested_same_name.yul
View File

@ -11,4 +11,4 @@
// ---- // ----
// step: circularReferencesPruner // step: circularReferencesPruner
// //
// { } // { { } }

2
test/libyul/yulOptimizerTests/circularReferencesPruner/trivial.yul
View File

@ -5,4 +5,4 @@
// ---- // ----
// step: circularReferencesPruner // step: circularReferencesPruner
// //
// { } // { { } }

2
test/libyul/yulOptimizerTests/expressionJoiner/if_condition.yul
View File

@ -14,6 +14,8 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// if add(mload(7), sload(mload(3))) { let y := add(mload(3), 3) } // if add(mload(7), sload(mload(3))) { let y := add(mload(3), 3) }
// let t := add(3, 9) // let t := add(3, 9)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/muli_wrong_order3.yul
View File

@ -8,7 +8,9 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let a := mload(3) // let a := mload(3)
// let b := mload(6) // let b := mload(6)
// sstore(mul(add(b, a), mload(2)), 3) // sstore(mul(add(b, a), mload(2)), 3)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/multi.yul
View File

@ -8,5 +8,7 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// sstore(mul(add(mload(6), mload(2)), 2), 3) // sstore(mul(add(mload(6), mload(2)), 2), 3)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/multi_reference.yul
View File

@ -7,6 +7,8 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let a := mload(2) // let a := mload(2)
// let b := add(a, a) // let b := add(a, a)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/multi_wrong_order.yul
View File

@ -11,6 +11,8 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let a := mload(2) // let a := mload(2)
// sstore(mul(a, add(2, mload(6))), 3) // sstore(mul(a, add(2, mload(6))), 3)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/multi_wrong_order2.yul
View File

@ -8,6 +8,8 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let a := mload(2) // let a := mload(2)
// sstore(mul(add(a, mload(6)), 2), 3) // sstore(mul(add(a, mload(6)), 2), 3)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_across_blocks.yul
View File

@ -15,6 +15,8 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let x := calldataload(mload(2)) // let x := calldataload(mload(2))
// sstore(x, 3) // sstore(x, 3)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_in_loop_condition1.yul
View File

@ -5,6 +5,8 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// for { let b := mload(1) } b { } // for { let b := mload(1) } b { }
// { } // { }
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_in_loop_condition2.yul
View File

@ -6,7 +6,9 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let a := mload(0) // let a := mload(0)
// for { } a { } // for { } a { }
// { } // { }
// } // }
// }

1
test/libyul/yulOptimizerTests/expressionJoiner/only_assignment.yul
View File

@ -9,6 +9,7 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// { }
// function f(a) -> x // function f(a) -> x
// { // {
// a := mload(2) // a := mload(2)

2
test/libyul/yulOptimizerTests/expressionJoiner/reassignment.yul
View File

@ -8,7 +8,9 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let a := mload(2) // let a := mload(2)
// let b := mload(a) // let b := mload(a)
// a := 4 // a := 4
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/simple.yul
View File

@ -7,5 +7,7 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// sstore(calldataload(mload(2)), 3) // sstore(calldataload(mload(2)), 3)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/single_wrong_order.yul
View File

@ -9,6 +9,8 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// let b := sload(mload(3)) // let b := sload(mload(3))
// sstore(add(b, mload(7)), 0) // sstore(add(b, mload(7)), 0)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/smoke.yul
View File

@ -2,4 +2,4 @@
// ---- // ----
// step: expressionJoiner // step: expressionJoiner
// //
// { } // { { } }

2
test/libyul/yulOptimizerTests/expressionJoiner/switch_expression.yul
View File

@ -18,8 +18,10 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// switch add(mload(7), sload(mload(3))) // switch add(mload(7), sload(mload(3)))
// case 3 { let y := add(mload(3), 3) } // case 3 { let y := add(mload(3), 3) }
// default { sstore(1, 0) } // default { sstore(1, 0) }
// let t := add(3, 9) // let t := add(3, 9)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionJoiner/triple.yul
View File

@ -9,5 +9,7 @@
// step: expressionJoiner // step: expressionJoiner
// //
// { // {
// {
// sstore(mul(add(mload(7), mload(6)), mload(2)), 3) // sstore(mul(add(mload(7), mload(6)), mload(2)), 3)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/assigned_vars_multi.yul
View File

@ -8,8 +8,10 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let c, d := f() // let c, d := f()
// sstore(add(add(d, c), 7), 20) // sstore(add(add(d, c), 7), 20)
// }
// function f() -> x, z // function f() -> x, z
// { } // { }
// } // }

2
test/libyul/yulOptimizerTests/expressionSimplifier/byte_after_shr_non_mul_of_8.yul
View File

@ -6,4 +6,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(0, 0) } // { { sstore(0, 0) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and.yul
View File

@ -13,7 +13,9 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let x := calldataload(0) // let x := calldataload(0)
// let a := and(0xff, and(shr(248, x), 255)) // let a := and(0xff, and(shr(248, x), 255))
// sstore(a, shr(12, and(shl(8, x), 15790080))) // sstore(a, shr(12, and(shl(8, x), 15790080)))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and_2.yul
View File

@ -24,6 +24,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let x := calldataload(0) // let x := calldataload(0)
// let _2 := 0xf // let _2 := 0xf
// let _5 := and(shr(248, x), 0) // let _5 := and(shr(248, x), 0)
@ -46,3 +47,4 @@
// sstore(_2, f) // sstore(_2, f)
// sstore(16, g) // sstore(16, g)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and_3.yul
View File

@ -21,6 +21,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let x := calldataload(0) // let x := calldataload(0)
// let a := and(shl(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000) // let a := and(shl(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000)
// let b := and(shr(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0) // let b := and(shr(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0)
@ -35,3 +36,4 @@
// sstore(19, d) // sstore(19, d)
// sstore(20, e) // sstore(20, e)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/constant_propagation.yul
View File

@ -5,4 +5,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { mstore(20, mload(0)) } // { { mstore(20, mload(0)) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/constants.yul
View File

@ -5,4 +5,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(7, 13) } // { { sstore(7, 13) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/create2_and_mask.yul
View File

@ -12,9 +12,11 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0xffffffffffffffffffffffffffffffffffffffff // let _1 := 0xffffffffffffffffffffffffffffffffffffffff
// let _2 := 0 // let _2 := 0
// let _3 := 0x20 // let _3 := 0x20
// let a := and(create2(_2, _2, _3, _2), _1) // let a := and(create2(_2, _2, _3, _2), _1)
// sstore(a, and(_1, create2(_2, _2, _3, _2))) // sstore(a, and(_1, create2(_2, _2, _3, _2)))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/create_and_mask.yul
View File

@ -11,6 +11,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0x20 // let _1 := 0x20
// let _2 := 0 // let _2 := 0
// let c := create(_2, _2, _1) // let c := create(_2, _2, _1)
@ -18,3 +19,4 @@
// let a := and(c, _4) // let a := and(c, _4)
// sstore(a, and(_4, create(_2, _2, _1))) // sstore(a, and(_4, create(_2, _2, _1)))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/exp_simplifications.yul
View File

@ -13,6 +13,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// let t := calldataload(_1) // let t := calldataload(_1)
// sstore(_1, iszero(t)) // sstore(_1, iszero(t))
@ -22,3 +23,4 @@
// sstore(3, exp(8, t)) // sstore(3, exp(8, t))
// sstore(4, sub(iszero(and(t, 1)), and(t, 1))) // sstore(4, sub(iszero(and(t, 1)), and(t, 1)))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/idempotency.yul
View File

@ -9,8 +9,10 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let x := calldataload(0) // let x := calldataload(0)
// let z := calldataload(1) // let z := calldataload(1)
// let t := and(x, z) // let t := and(x, z)
// sstore(t, or(x, z)) // sstore(t, or(x, z))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_complex.yul
View File

@ -5,4 +5,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(0, 0) } // { { sstore(0, 0) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_negative.yul
View File

@ -6,6 +6,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// sstore(_1, sub(calldataload(1), calldataload(_1))) // sstore(_1, sub(calldataload(1), calldataload(_1)))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_simple.yul
View File

@ -6,4 +6,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(0, 0) } // { { sstore(0, 0) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/including_function_calls.yul
View File

@ -7,7 +7,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// sstore(0, f()) // { sstore(0, f()) }
// function f() -> a // function f() -> a
// { } // { }
// } // }

2
test/libyul/yulOptimizerTests/expressionSimplifier/inside_for.yul
View File

@ -6,7 +6,9 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let a := 10 // let a := 10
// for { } iszero(iszero(a)) { a := add(a, 1) } // for { } iszero(iszero(a)) { a := add(a, 1) }
// { } // { }
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/invariant.yul
View File

@ -6,4 +6,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(0, mload(0)) } // { { sstore(0, mload(0)) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/iszero_sub_to_eq.yul
View File

@ -10,7 +10,9 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// let a := calldataload(_1) // let a := calldataload(_1)
// if eq(a, calldataload(0x20)) { sstore(_1, 1) } // if eq(a, calldataload(0x20)) { sstore(_1, 1) }
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/large_byte_access.yul
View File

@ -13,6 +13,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// let a := calldataload(_1) // let a := calldataload(_1)
// let b := 0 // let b := 0
@ -24,3 +25,4 @@
// sstore(9, c) // sstore(9, c)
// sstore(10, d) // sstore(10, d)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_1.yul
View File

@ -5,6 +5,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _4 := 0 // let _4 := 0
// mstore(_4, and(calldataload(_4), 255)) // mstore(_4, and(calldataload(_4), 255))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_2.yul
View File

@ -5,6 +5,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _4 := 0 // let _4 := 0
// mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) // mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_arguments.yul
View File

@ -7,9 +7,11 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _2 := f(1) // let _2 := f(1)
// let _3 := 0 // let _3 := 0
// sstore(_3, sub(f(_3), _2)) // sstore(_3, sub(f(_3), _2))
// }
// function f(a) -> b // function f(a) -> b
// { } // { }
// } // }

2
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_names.yul
View File

@ -8,7 +8,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// sstore(0, sub(f1(), f2())) // { sstore(0, sub(f1(), f2())) }
// function f1() -> a // function f1() -> a
// { } // { }
// function f2() -> b // function f2() -> b

2
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_equality_not_movable.yul
View File

@ -8,7 +8,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// sstore(sub(f(), f()), 8) // { sstore(sub(f(), f()), 8) }
// function f() -> a // function f() -> a
// { mstore(0, 1) } // { mstore(0, 1) }
// } // }

2
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_removes_non_constant_and_not_movable.yul
View File

@ -9,9 +9,11 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := msize() // let _1 := msize()
// let _2 := 0 // let _2 := 0
// sstore(_2, _1) // sstore(_2, _1)
// pop(keccak256(_2, _2)) // pop(keccak256(_2, _2))
// sstore(20, 0) // sstore(20, 0)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_call.yul
View File

@ -7,7 +7,9 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// pop(call(_1, _1, _1, _1, _1, _1, _1)) // pop(call(_1, _1, _1, _1, _1, _1, _1))
// sstore(_1, 0) // sstore(_1, 0)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_func.yul
View File

@ -8,8 +8,10 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// pop(f()) // pop(f())
// mstore(0, 0) // mstore(0, 0)
// }
// function f() -> x // function f() -> x
// { mstore(0, 1337) } // { mstore(0, 1337) }
// } // }

2
test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_func_trivial.yul
View File

@ -7,4 +7,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(0, 0) } // { { sstore(0, 0) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/reassign.yul
View File

@ -7,8 +7,10 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// let x := mload(_1) // let x := mload(_1)
// x := _1 // x := _1
// mstore(_1, 7) // mstore(_1, 7)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/remove_redundant_shift_masking.yul
View File

@ -12,6 +12,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _2 := calldataload(0) // let _2 := calldataload(0)
// let _5 := 0xff // let _5 := 0xff
// let a := shr(248, _2) // let a := shr(248, _2)
@ -21,3 +22,4 @@
// sstore(a, b) // sstore(a, b)
// sstore(c, d) // sstore(c, d)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/replace_too_large_shift.yul
View File

@ -12,6 +12,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let a := 0 // let a := 0
// let b := 0 // let b := 0
// let _8 := calldataload(2) // let _8 := calldataload(2)
@ -21,3 +22,4 @@
// sstore(a, b) // sstore(a, b)
// sstore(c, d) // sstore(c, d)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/return_vars_zero.yul
View File

@ -10,7 +10,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let t, v := f() // { let t, v := f() }
// function f() -> c, d // function f() -> c, d
// { sstore(0, 7) } // { sstore(0, 7) }
// } // }

2
test/libyul/yulOptimizerTests/expressionSimplifier/reversed.yul
View File

@ -6,6 +6,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// sstore(_1, mload(_1)) // sstore(_1, mload(_1))
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_not_supported.yul
View File

@ -6,4 +6,6 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// {
// { sstore(0, balance(address())) } // { sstore(0, balance(address())) }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_split.yul
View File

@ -9,6 +9,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let a := address() // let a := address()
// sstore(a, selfbalance()) // sstore(a, selfbalance())
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_supported.yul
View File

@ -6,4 +6,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(0, selfbalance()) } // { { sstore(0, selfbalance()) } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/side_effects_in_for_condition.yul
View File

@ -9,6 +9,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// for { } div(create(0, 1, 0), shl(msize(), 1)) { } // for { } div(create(0, 1, 0), shl(msize(), 1)) { }
// { } // { }
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/smoke.yul
View File

@ -2,4 +2,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { } // { { } }

2
test/libyul/yulOptimizerTests/expressionSimplifier/unassigend_vars_multi.yul
View File

@ -8,6 +8,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// {
// let c, d // let c, d
// sstore(d, 7) // sstore(d, 7)
// } // }
// }

2
test/libyul/yulOptimizerTests/expressionSimplifier/unassigned_vars.yul
View File

@ -8,4 +8,4 @@
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { sstore(8, 7) } // { { sstore(8, 7) } }

1
test/libyul/yulOptimizerTests/fullInliner/no_inline_into_big_function.yul
View File

@ -13,6 +13,7 @@
// step: fullInliner // step: fullInliner
// //
// { // {
// { }
// function f(a) -> b // function f(a) -> b
// { b := sload(mload(a)) } // { b := sload(mload(a)) }
// function g() -> x_1 // function g() -> x_1

2
test/libyul/yulOptimizerTests/fullSimplify/constant_propagation.yul
View File

@ -6,6 +6,8 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let _2 := 0 // let _2 := 0
// mstore(mload(_2), _2) // mstore(mload(_2), _2)
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/constants.yul
View File

@ -5,4 +5,4 @@
// ---- // ----
// step: fullSimplify // step: fullSimplify
// //
// { mstore(0, 13) } // { { mstore(0, 13) } }

2
test/libyul/yulOptimizerTests/fullSimplify/identity_rules_complex.yul
View File

@ -5,4 +5,4 @@
// ---- // ----
// step: fullSimplify // step: fullSimplify
// //
// { mstore(0, 0) } // { { mstore(0, 0) } }

2
test/libyul/yulOptimizerTests/fullSimplify/identity_rules_negative.yul
View File

@ -6,6 +6,8 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// mstore(_1, sub(calldataload(1), calldataload(_1))) // mstore(_1, sub(calldataload(1), calldataload(_1)))
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/identity_rules_simple.yul
View File

@ -5,4 +5,4 @@
// ---- // ----
// step: fullSimplify // step: fullSimplify
// //
// { mstore(0, 0) } // { { mstore(0, 0) } }

2
test/libyul/yulOptimizerTests/fullSimplify/including_function_calls.yul
View File

@ -7,7 +7,7 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// mstore(f(), 0) // { mstore(f(), 0) }
// function f() -> a // function f() -> a
// { } // { }
// } // }

2
test/libyul/yulOptimizerTests/fullSimplify/inside_for.yul
View File

@ -7,7 +7,9 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let a := 10 // let a := 10
// for { } iszero(iszero(a)) { a := add(a, 1) } // for { } iszero(iszero(a)) { a := add(a, 1) }
// { } // { }
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/invariant.yul
View File

@ -11,8 +11,10 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let a := calldataload(0) // let a := calldataload(0)
// let _4 := 0 // let _4 := 0
// let b := a // let b := a
// mstore(b, eq(calldataload(_4), a)) // mstore(b, eq(calldataload(_4), a))
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/mod_and_1.yul
View File

@ -5,6 +5,8 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let _4 := 0 // let _4 := 0
// mstore(_4, and(calldataload(_4), 255)) // mstore(_4, and(calldataload(_4), 255))
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/mod_and_2.yul
View File

@ -5,6 +5,8 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let _4 := 0 // let _4 := 0
// mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) // mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/not_applied_function_call_different_arguments.yul
View File

@ -6,9 +6,11 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let _2 := f(1) // let _2 := f(1)
// let _3 := 0 // let _3 := 0
// mstore(_3, sub(f(_3), _2)) // mstore(_3, sub(f(_3), _2))
// }
// function f(a) -> b // function f(a) -> b
// { } // { }
// } // }

2
test/libyul/yulOptimizerTests/fullSimplify/not_applied_function_call_different_names.yul
View File

@ -8,7 +8,7 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// mstore(0, sub(f1(), f2())) // { mstore(0, sub(f1(), f2())) }
// function f1() -> a // function f1() -> a
// { } // { }
// function f2() -> b // function f2() -> b

2
test/libyul/yulOptimizerTests/fullSimplify/not_applied_function_call_equality_not_movable.yul
View File

@ -8,7 +8,7 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// mstore(0, sub(f(), f())) // { mstore(0, sub(f(), f())) }
// function f() -> a // function f() -> a
// { mstore(1, 2) } // { mstore(1, 2) }
// } // }

2
test/libyul/yulOptimizerTests/fullSimplify/not_applied_removes_non_constant_and_not_movable.yul
View File

@ -7,7 +7,9 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// pop(create(_1, _1, _1)) // pop(create(_1, _1, _1))
// mstore(_1, 0) // mstore(_1, 0)
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/operations.yul
View File

@ -23,6 +23,7 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// mstore(1, 0) // mstore(1, 0)
// mstore(2, 0) // mstore(2, 0)
// mstore(3, 0) // mstore(3, 0)
@ -42,3 +43,4 @@
// mstore(17, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // mstore(17, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
// mstore(18, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // mstore(18, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/reversed.yul
View File

@ -6,6 +6,8 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// let _1 := 0 // let _1 := 0
// mstore(_1, mload(_1)) // mstore(_1, mload(_1))
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/signextend.yul
View File

@ -8,6 +8,8 @@
// step: fullSimplify // step: fullSimplify
// //
// { // {
// {
// mstore(0, 7) // mstore(0, 7)
// mstore(1, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // mstore(1, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
// } // }
// }

2
test/libyul/yulOptimizerTests/fullSimplify/smoke.yul
View File

@ -2,4 +2,4 @@
// ---- // ----
// step: fullSimplify // step: fullSimplify
// //
// { } // { { } }

2
test/libyul/yulOptimizerTests/loadResolver/double_mload.yul
View File

@ -8,6 +8,8 @@
// step: loadResolver // step: loadResolver
// //
// { // {
// {
// let a := mload(calldataload(0)) // let a := mload(calldataload(0))
// sstore(a, a) // sstore(a, a)
// } // }
// }

2
test/libyul/yulOptimizerTests/loadResolver/double_mload_with_other_reassignment.yul
View File

@ -9,8 +9,10 @@
// step: loadResolver // step: loadResolver
// //
// { // {
// {
// let x := calldataload(0) // let x := calldataload(0)
// let a := mload(x) // let a := mload(x)
// x := 7 // x := 7
// sstore(a, mload(x)) // sstore(a, mload(x))
// } // }
// }

2
test/libyul/yulOptimizerTests/loadResolver/double_mload_with_reassignment.yul
View File

@ -9,8 +9,10 @@
// step: loadResolver // step: loadResolver
// //
// { // {
// {
// let x := calldataload(0) // let x := calldataload(0)
// let a := mload(x) // let a := mload(x)
// a := 7 // a := 7
// sstore(a, mload(x)) // sstore(a, mload(x))
// } // }
// }

2
test/libyul/yulOptimizerTests/loadResolver/keccak.yul
View File

@ -9,8 +9,10 @@
// step: loadResolver // step: loadResolver
// //
// { // {
// {
// let _1 := 10 // let _1 := 10
// let _2 := 0 // let _2 := 0
// mstore(_2, _1) // mstore(_2, _1)
// sstore(_2, 89717814153306320011181716697424560163256864414616650038987186496166826726056) // sstore(_2, 89717814153306320011181716697424560163256864414616650038987186496166826726056)
// } // }
// }

2
test/libyul/yulOptimizerTests/loadResolver/keccak_crash.yul
View File

@ -6,8 +6,10 @@
// step: loadResolver // step: loadResolver
// //
// { // {
// {
// for { } // for { }
// addmod(keccak256(0x0, create(0x0, 0x0, 0x0)), 0x0, 0x0) // addmod(keccak256(0x0, create(0x0, 0x0, 0x0)), 0x0, 0x0)
// { } // { }
// { } // { }
// } // }
// }

2
test/libyul/yulOptimizerTests/loadResolver/keccak_fail1.yul
View File

@ -10,9 +10,11 @@
// step: loadResolver // step: loadResolver
// //
// { // {
// {
// let _1 := 30 // let _1 := 30
// let _2 := 0 // let _2 := 0
// mstore(_2, _1) // mstore(_2, _1)
// if calldataload(_2) { mstore(_2, 20) } // if calldataload(_2) { mstore(_2, 20) }
// sstore(_2, keccak256(_2, 32)) // sstore(_2, keccak256(_2, 32))
// } // }
// }

2
test/libyul/yulOptimizerTests/loadResolver/keccak_fail2.yul
View File

@ -9,8 +9,10 @@
// step: loadResolver // step: loadResolver
// //
// { // {
// {
// let _1 := 10 // let _1 := 10
// mstore(100, _1) // mstore(100, _1)
// mstore(132, 5) // mstore(132, 5)
// sstore(0, keccak256(_1, 33)) // sstore(0, keccak256(_1, 33))
// } // }
// }

Some files were not shown because too many files have changed in this diff Show More