diff --git a/Changelog.md b/Changelog.md index b3af54d04..cd7abfc2f 100644 --- a/Changelog.md +++ b/Changelog.md @@ -4,6 +4,7 @@ Language Features: Compiler Features: + * Yul Optimizer: Remove redundant calls to ``mstore`` and ``sstore``. Bugfixes: diff --git a/libsolidity/interface/OptimiserSettings.h b/libsolidity/interface/OptimiserSettings.h index 5317acee4..37c6562bd 100644 --- a/libsolidity/interface/OptimiserSettings.h +++ b/libsolidity/interface/OptimiserSettings.h @@ -55,7 +55,7 @@ struct OptimiserSettings "xa[rul]" // Prune a bit more in SSA "xa[r]cL" // Turn into SSA again and simplify "gvif" // Run full inliner - "CTUca[r]LsTFOtfDnca[r]Iulc" // SSA plus simplify + "CTUca[r]LsSTFOtfDnca[r]Iulc" // SSA plus simplify "]" "jmul[jul] VcTOcul jmul"; // Make source short and pretty diff --git a/libyul/CMakeLists.txt b/libyul/CMakeLists.txt index 16b68535a..5974ee2b5 100644 --- a/libyul/CMakeLists.txt +++ b/libyul/CMakeLists.txt @@ -177,6 +177,8 @@ add_library(yul optimiser/UnusedAssignEliminator.h optimiser/UnusedStoreBase.cpp optimiser/UnusedStoreBase.h + optimiser/UnusedStoreEliminator.cpp + optimiser/UnusedStoreEliminator.h optimiser/Rematerialiser.cpp optimiser/Rematerialiser.h optimiser/SMTSolver.cpp diff --git a/libyul/optimiser/Suite.cpp b/libyul/optimiser/Suite.cpp index 4012fa970..bc97885a3 100644 --- a/libyul/optimiser/Suite.cpp +++ b/libyul/optimiser/Suite.cpp @@ -56,6 +56,7 @@ #include #include #include +#include #include #include #include @@ -220,6 +221,7 @@ map> const& OptimiserSuite::allSteps() LoadResolver, LoopInvariantCodeMotion, UnusedAssignEliminator, + UnusedStoreEliminator, ReasoningBasedSimplifier, Rematerialiser, SSAReverser, @@ -261,6 +263,7 @@ map const& OptimiserSuite::stepNameToAbbreviationMap() {LoopInvariantCodeMotion::name, 'M'}, {ReasoningBasedSimplifier::name, 'R'}, {UnusedAssignEliminator::name, 'r'}, + {UnusedStoreEliminator::name, 'S'}, {Rematerialiser::name, 'm'}, {SSAReverser::name, 'V'}, {SSATransform::name, 'a'}, diff --git a/libyul/optimiser/UnusedStoreEliminator.cpp b/libyul/optimiser/UnusedStoreEliminator.cpp new file mode 100644 index 000000000..9e9cb5c64 --- /dev/null +++ b/libyul/optimiser/UnusedStoreEliminator.cpp @@ -0,0 +1,452 @@ +/* + This file is part of solidity. + + solidity is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + solidity is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with solidity. If not, see . +*/ +// SPDX-License-Identifier: GPL-3.0 +/** + * Optimiser component that removes stores to memory and storage slots that are not used + * or overwritten later on. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include + +using namespace std; +using namespace solidity; +using namespace solidity::yul; + +/// Variable names for special constants that can never appear in actual Yul code. +static string const zero{"@ 0"}; +static string const one{"@ 1"}; +static string const thirtyTwo{"@ 32"}; + + +void UnusedStoreEliminator::run(OptimiserStepContext& _context, Block& _ast) +{ + map functionSideEffects = SideEffectsPropagator::sideEffects( + _context.dialect, + CallGraphGenerator::callGraph(_ast) + ); + + SSAValueTracker ssaValues; + ssaValues(_ast); + map values; + for (auto const& [name, expression]: ssaValues.values()) + values[name] = AssignedValue{expression, {}}; + Expression const zeroLiteral{Literal{{}, LiteralKind::Number, YulString{"0"}, {}}}; + Expression const oneLiteral{Literal{{}, LiteralKind::Number, YulString{"1"}, {}}}; + Expression const thirtyTwoLiteral{Literal{{}, LiteralKind::Number, YulString{"32"}, {}}}; + values[YulString{zero}] = AssignedValue{&zeroLiteral, {}}; + values[YulString{one}] = AssignedValue{&oneLiteral, {}}; + values[YulString{thirtyTwo}] = AssignedValue{&thirtyTwoLiteral, {}}; + + bool const ignoreMemory = MSizeFinder::containsMSize(_context.dialect, _ast); + UnusedStoreEliminator rse{ + _context.dialect, + functionSideEffects, + ControlFlowSideEffectsCollector{_context.dialect, _ast}.functionSideEffectsNamed(), + values, + ignoreMemory + }; + rse(_ast); + rse.changeUndecidedTo(State::Unused, Location::Memory); + rse.changeUndecidedTo(State::Used, Location::Storage); + rse.scheduleUnusedForDeletion(); + + StatementRemover remover(rse.m_pendingRemovals); + remover(_ast); +} + +void UnusedStoreEliminator::operator()(FunctionCall const& _functionCall) +{ + UnusedStoreBase::operator()(_functionCall); + + for (Operation const& op: operationsFromFunctionCall(_functionCall)) + applyOperation(op); + + ControlFlowSideEffects sideEffects; + if (auto builtin = m_dialect.builtin(_functionCall.functionName.name)) + sideEffects = builtin->controlFlowSideEffects; + else + sideEffects = m_controlFlowSideEffects.at(_functionCall.functionName.name); + + if (!sideEffects.canContinue) + { + changeUndecidedTo(State::Unused, Location::Memory); + changeUndecidedTo(sideEffects.canTerminate ? State::Used : State::Unused, Location::Storage); + } +} + +void UnusedStoreEliminator::operator()(FunctionDefinition const& _functionDefinition) +{ + ScopedSaveAndRestore storeOperations(m_storeOperations, {}); + UnusedStoreBase::operator()(_functionDefinition); +} + + +void UnusedStoreEliminator::operator()(Leave const&) +{ + changeUndecidedTo(State::Used); +} + +void UnusedStoreEliminator::visit(Statement const& _statement) +{ + using evmasm::Instruction; + + UnusedStoreBase::visit(_statement); + + auto const* exprStatement = get_if(&_statement); + if (!exprStatement) + return; + + FunctionCall const* funCall = get_if(&exprStatement->expression); + if (!funCall) + return; + optional instruction = toEVMInstruction(m_dialect, funCall->functionName.name); + if (!instruction) + return; + + if (!ranges::all_of(funCall->arguments, [](Expression const& _expr) -> bool { + return get_if(&_expr) || get_if(&_expr); + })) + return; + + if ( + *instruction == Instruction::SSTORE || + (!m_ignoreMemory && ( + *instruction == Instruction::EXTCODECOPY || + *instruction == Instruction::CODECOPY || + *instruction == Instruction::CALLDATACOPY || + *instruction == Instruction::RETURNDATACOPY || + *instruction == Instruction::MSTORE || + *instruction == Instruction::MSTORE8 + )) + ) + { + m_stores[YulString{}].insert({&_statement, State::Undecided}); + vector operations = operationsFromFunctionCall(*funCall); + yulAssert(operations.size() == 1, ""); + m_storeOperations[&_statement] = move(operations.front()); + } +} + +void UnusedStoreEliminator::finalizeFunctionDefinition(FunctionDefinition const&) +{ + changeUndecidedTo(State::Used); + scheduleUnusedForDeletion(); +} + +vector UnusedStoreEliminator::operationsFromFunctionCall( + FunctionCall const& _functionCall +) const +{ + using evmasm::Instruction; + + YulString functionName = _functionCall.functionName.name; + SideEffects sideEffects; + if (BuiltinFunction const* f = m_dialect.builtin(functionName)) + sideEffects = f->sideEffects; + else + sideEffects = m_functionSideEffects.at(functionName); + + optional instruction = toEVMInstruction(m_dialect, functionName); + if (!instruction) + { + vector result; + // Unknown read is worse than unknown write. + if (sideEffects.memory != SideEffects::Effect::None) + result.emplace_back(Operation{Location::Memory, Effect::Read, {}, {}}); + if (sideEffects.storage != SideEffects::Effect::None) + result.emplace_back(Operation{Location::Storage, Effect::Read, {}, {}}); + return result; + } + + switch (*instruction) + { + case Instruction::SSTORE: + case Instruction::SLOAD: + case Instruction::MSTORE: + case Instruction::MSTORE8: + case Instruction::MLOAD: + case Instruction::REVERT: + case Instruction::RETURN: + case Instruction::EXTCODECOPY: + case Instruction::CODECOPY: + case Instruction::CALLDATACOPY: + case Instruction::RETURNDATACOPY: + case Instruction::KECCAK256: + case Instruction::LOG0: + case Instruction::LOG1: + case Instruction::LOG2: + case Instruction::LOG3: + case Instruction::LOG4: + { + Operation op; + if (sideEffects.memory == SideEffects::Write || sideEffects.storage == SideEffects::Write) + op.effect = Effect::Write; + else + op.effect = Effect::Read; + + op.location = + (instruction == Instruction::SSTORE || instruction == Instruction::SLOAD) ? + Location::Storage : + Location::Memory; + + if (*instruction == Instruction::EXTCODECOPY) + op.start = identifierNameIfSSA(_functionCall.arguments.at(1)); + else + op.start = identifierNameIfSSA(_functionCall.arguments.at(0)); + + if (instruction == Instruction::MSTORE || instruction == Instruction::MLOAD) + op.length = YulString(thirtyTwo); + else if (instruction == Instruction::MSTORE8) + op.length = YulString(one); + else if ( + instruction == Instruction::REVERT || + instruction == Instruction::RETURN || + instruction == Instruction::KECCAK256 || + instruction == Instruction::LOG0 || + instruction == Instruction::LOG1 || + instruction == Instruction::LOG2 || + instruction == Instruction::LOG3 || + instruction == Instruction::LOG4 + ) + op.length = identifierNameIfSSA(_functionCall.arguments.at(1)); + else if (*instruction == Instruction::EXTCODECOPY) + op.length = identifierNameIfSSA(_functionCall.arguments.at(3)); + else if ( + instruction == Instruction::CALLDATACOPY || + instruction == Instruction::CODECOPY || + instruction == Instruction::RETURNDATACOPY + ) + op.length = identifierNameIfSSA(_functionCall.arguments.at(2)); + else if (instruction == Instruction::SSTORE || instruction == Instruction::SLOAD) + // Storage operations, length is unused / non-sensical + op.length = {}; + else + yulAssert(false); + + return {op}; + } + case Instruction::STATICCALL: + case Instruction::CALL: + case Instruction::CALLCODE: + case Instruction::DELEGATECALL: + { + size_t arguments = _functionCall.arguments.size(); + return vector{ + Operation{ + Location::Memory, + Effect::Read, + identifierNameIfSSA(_functionCall.arguments.at(arguments - 4)), + identifierNameIfSSA(_functionCall.arguments.at(arguments - 3)) + }, + // Unknown read includes unknown write. + Operation{Location::Storage, Effect::Read, {}, {}}, + Operation{ + Location::Memory, + Effect::Write, + identifierNameIfSSA(_functionCall.arguments.at(arguments - 2)), + identifierNameIfSSA(_functionCall.arguments.at(arguments - 1)) + } + }; + } + case Instruction::CREATE: + case Instruction::CREATE2: + return vector{ + Operation{ + Location::Memory, + Effect::Read, + identifierNameIfSSA(_functionCall.arguments.at(1)), + identifierNameIfSSA(_functionCall.arguments.at(2)) + }, + // Unknown read includes unknown write. + Operation{Location::Storage, Effect::Read, {}, {}}, + }; + case Instruction::MSIZE: + // This is just to satisfy the assert below. + return vector{}; + default: + break; + } + + yulAssert( + evmasm::SemanticInformation::storage(*instruction) == + evmasm::SemanticInformation::None, + "" + ); + yulAssert( + evmasm::SemanticInformation::memory(*instruction) == + evmasm::SemanticInformation::None, + "" + ); + yulAssert( + sideEffects.memory == SideEffects::Effect::None && + sideEffects.storage == SideEffects::Effect::None, + "" + ); + return {}; +} + +void UnusedStoreEliminator::applyOperation(UnusedStoreEliminator::Operation const& _operation) +{ + for (auto& [statement, state]: m_stores[YulString{}]) + if (state == State::Undecided) + { + Operation const& storeOperation = m_storeOperations.at(statement); + if (_operation.effect == Effect::Read && !knownUnrelated(storeOperation, _operation)) + state = State::Used; + else if (_operation.effect == Effect::Write && knownCovered(storeOperation, _operation)) + state = State::Unused; + } +} + +bool UnusedStoreEliminator::knownUnrelated( + UnusedStoreEliminator::Operation const& _op1, + UnusedStoreEliminator::Operation const& _op2 +) const +{ + KnowledgeBase knowledge(m_dialect, m_ssaValues); + + if (_op1.location != _op2.location) + return true; + if (_op1.location == Location::Storage) + { + if (_op1.start && _op2.start) + return knowledge.knownToBeDifferent(*_op1.start, *_op2.start); + } + else + { + u256 largestPositive = (u256(1) << 128) - 1; + + yulAssert(_op1.location == Location::Memory, ""); + if (_op1.length && knowledge.knownToBeZero(*_op1.length)) + return true; + if (_op2.length && knowledge.knownToBeZero(*_op2.length)) + return true; + + // 1.start + 1.length <= 2.start + if (_op1.length && _op2.start && _op1.start) + { + optional length1 = knowledge.valueIfKnownConstant(*_op1.length); + optional diff = knowledge.differenceIfKnownConstant(*_op2.start, *_op1.start); + // diff = 2.start - 1.start + if (length1 && diff) + if ( + *length1 <= *diff && + *length1 <= largestPositive && + *diff <= largestPositive + ) + return true; + } + // 2.start + 2.length <= 1.start + if (_op2.length && _op1.start && _op2.start) + { + optional length2 = knowledge.valueIfKnownConstant(*_op2.length); + optional diff = knowledge.differenceIfKnownConstant(*_op1.start, *_op2.start); + // diff = 1.start - 2.start + if (length2 && diff) + if (*length2 <= *diff && *length2 <= largestPositive && *diff <= largestPositive) + return true; + } + } + + return false; +} + +bool UnusedStoreEliminator::knownCovered( + UnusedStoreEliminator::Operation const& _covered, + UnusedStoreEliminator::Operation const& _covering +) const +{ + if (_covered.location != _covering.location) + return false; + if ( + (_covered.start && _covered.start == _covering.start) && + // length is unused for storage + (_covered.location == Location::Storage || (_covered.length && _covered.length == _covering.length)) + ) + return true; + if (_covered.location == Location::Memory) + { + KnowledgeBase knowledge(m_dialect, m_ssaValues); + u256 largestPositive = (u256(1) << 128) - 1; + + if (_covered.length && knowledge.knownToBeZero(*_covered.length)) + return true; + // Condition (i = cover_i_ng, e = cover_e_d): + // i.start <= e.start && e.start + e.length <= i.start + i.length + if (!_covered.start || !_covering.start || !_covered.length || !_covering.length) + return false; + optional startDiff = knowledge.differenceIfKnownConstant(*_covered.start, *_covering.start); + optional coveredLength = knowledge.valueIfKnownConstant(*_covered.length); + optional lengthDiff = knowledge.differenceIfKnownConstant(*_covering.length, *_covered.length); + if ( + (startDiff && coveredLength && lengthDiff) && + // i.start <= e.start + *startDiff <= largestPositive && + // e.length <= i.length + *lengthDiff <= largestPositive && + // e.start - i.start <= i.length - e.length <=> e.start + e.length <= i.start + i.length + *startDiff <= *lengthDiff && + // Just a safety measure against overflow. + *coveredLength <= largestPositive + ) + return true; + } + return false; +} + +void UnusedStoreEliminator::changeUndecidedTo( + State _newState, + optional _onlyLocation) +{ + for (auto& [statement, state]: m_stores[YulString{}]) + if ( + state == State::Undecided && + (_onlyLocation == nullopt || *_onlyLocation == m_storeOperations.at(statement).location) + ) + state = _newState; +} + +optional UnusedStoreEliminator::identifierNameIfSSA(Expression const& _expression) const +{ + if (Identifier const* identifier = get_if(&_expression)) + if (m_ssaValues.count(identifier->name)) + return {identifier->name}; + return nullopt; +} + +void UnusedStoreEliminator::scheduleUnusedForDeletion() +{ + for (auto const& [statement, state]: m_stores[YulString{}]) + if (state == State::Unused) + m_pendingRemovals.insert(statement); +} diff --git a/libyul/optimiser/UnusedStoreEliminator.h b/libyul/optimiser/UnusedStoreEliminator.h new file mode 100644 index 000000000..f79701732 --- /dev/null +++ b/libyul/optimiser/UnusedStoreEliminator.h @@ -0,0 +1,117 @@ +/* + This file is part of solidity. + + solidity is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + solidity is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with solidity. If not, see . +*/ +// SPDX-License-Identifier: GPL-3.0 +/** + * Optimiser component that removes stores to memory and storage slots that are not used + * or overwritten later on. + */ + +#pragma once + +#include +#include +#include +#include +#include + +#include +#include + +namespace solidity::yul +{ +struct Dialect; +struct AssignedValue; + +/** + * Optimizer component that removes mstore, sstore and similar statements if they + * are overwritten in all code paths or never read from. + * + * The m_store member of UnusedStoreBase is only used with the empty yul string + * as key in the first dimension. + * + * Best run in SSA form. + * + * Prerequisite: Disambiguator, ForLoopInitRewriter. + */ +class UnusedStoreEliminator: public UnusedStoreBase +{ +public: + static constexpr char const* name{"UnusedStoreEliminator"}; + static void run(OptimiserStepContext& _context, Block& _ast); + + explicit UnusedStoreEliminator( + Dialect const& _dialect, + std::map const& _functionSideEffects, + std::map _controlFlowSideEffects, + std::map const& _ssaValues, + bool _ignoreMemory + ): + UnusedStoreBase(_dialect), + m_ignoreMemory(_ignoreMemory), + m_functionSideEffects(_functionSideEffects), + m_controlFlowSideEffects(_controlFlowSideEffects), + m_ssaValues(_ssaValues) + {} + + using UnusedStoreBase::operator(); + void operator()(FunctionCall const& _functionCall) override; + void operator()(FunctionDefinition const&) override; + void operator()(Leave const&) override; + + using UnusedStoreBase::visit; + void visit(Statement const& _statement) override; + + enum class Location { Storage, Memory }; + enum class Effect { Read, Write }; + struct Operation + { + Location location; + Effect effect; + /// Start of affected area. Unknown if not provided. + std::optional start; + /// Length of affected area, unknown if not provided. + /// Unused for storage. + std::optional length; + }; + +private: + void shortcutNestedLoop(TrackedStores const&) override + { + // We might only need to do this for newly introduced stores in the loop. + changeUndecidedTo(State::Used); + } + void finalizeFunctionDefinition(FunctionDefinition const&) override { scheduleUnusedForDeletion(); } + + std::vector operationsFromFunctionCall(FunctionCall const& _functionCall) const; + void applyOperation(Operation const& _operation); + bool knownUnrelated(Operation const& _op1, Operation const& _op2) const; + bool knownCovered(Operation const& _covered, Operation const& _covering) const; + + void changeUndecidedTo(State _newState, std::optional _onlyLocation = std::nullopt); + void scheduleUnusedForDeletion(); + + std::optional identifierNameIfSSA(Expression const& _expression) const; + + bool const m_ignoreMemory; + std::map const& m_functionSideEffects; + std::map m_controlFlowSideEffects; + std::map const& m_ssaValues; + + std::map m_storeOperations; +}; + +} diff --git a/test/cmdlineTests/constant_optimizer_yul/output b/test/cmdlineTests/constant_optimizer_yul/output index 328ac2544..57045aee4 100644 --- a/test/cmdlineTests/constant_optimizer_yul/output +++ b/test/cmdlineTests/constant_optimizer_yul/output @@ -11,7 +11,6 @@ object "C_12" { code { { /// @src 0:61:418 "contract C {..." - mstore(64, 128) if callvalue() { revert(0, 0) } /// @src 0:103:238 "assembly {..." sstore(0, shl(180, 1)) @@ -26,7 +25,6 @@ object "C_12" { code { { /// @src 0:61:418 "contract C {..." - mstore(64, 128) if callvalue() { revert(0, 0) } /// @src 0:279:410 "assembly {..." sstore(0, 0x1000000000000000000000000000000000000000000000) diff --git a/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all/output b/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all/output index 1b90e94a3..ea9f92a94 100644 --- a/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all/output +++ b/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all/output @@ -195,16 +195,14 @@ object "C_6" { code { { /// @src 0:60:101 "contract C {..." - let _1 := memoryguard(0x80) - mstore(64, _1) if iszero(lt(calldatasize(), 4)) { - let _2 := 0 - if eq(0x26121ff0, shr(224, calldataload(_2))) + let _1 := 0 + if eq(0x26121ff0, shr(224, calldataload(_1))) { - if callvalue() { revert(_2, _2) } - if slt(add(calldatasize(), not(3)), _2) { revert(_2, _2) } - return(_1, _2) + if callvalue() { revert(_1, _1) } + if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) } + return(memoryguard(0x80), _1) } } revert(0, 0) diff --git a/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_location_only/output b/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_location_only/output index 86968e71b..b6179ff20 100644 --- a/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_location_only/output +++ b/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_location_only/output @@ -194,16 +194,14 @@ object "C_6" { code { { /// @src 0:60:101 - let _1 := memoryguard(0x80) - mstore(64, _1) if iszero(lt(calldatasize(), 4)) { - let _2 := 0 - if eq(0x26121ff0, shr(224, calldataload(_2))) + let _1 := 0 + if eq(0x26121ff0, shr(224, calldataload(_1))) { - if callvalue() { revert(_2, _2) } - if slt(add(calldatasize(), not(3)), _2) { revert(_2, _2) } - return(_1, _2) + if callvalue() { revert(_1, _1) } + if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) } + return(memoryguard(0x80), _1) } } revert(0, 0) diff --git a/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_none/output b/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_none/output index 6a87b0b46..dd09860e8 100644 --- a/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_none/output +++ b/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_none/output @@ -183,16 +183,14 @@ object "C_6" { object "C_6_deployed" { code { { - let _1 := memoryguard(0x80) - mstore(64, _1) if iszero(lt(calldatasize(), 4)) { - let _2 := 0 - if eq(0x26121ff0, shr(224, calldataload(_2))) + let _1 := 0 + if eq(0x26121ff0, shr(224, calldataload(_1))) { - if callvalue() { revert(_2, _2) } - if slt(add(calldatasize(), not(3)), _2) { revert(_2, _2) } - return(_1, _2) + if callvalue() { revert(_1, _1) } + if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) } + return(memoryguard(0x80), _1) } } revert(0, 0) diff --git a/test/cmdlineTests/debug_info_in_yul_snippet_escaping/output b/test/cmdlineTests/debug_info_in_yul_snippet_escaping/output index ae3ee1735..b1aa9ff4c 100644 --- a/test/cmdlineTests/debug_info_in_yul_snippet_escaping/output +++ b/test/cmdlineTests/debug_info_in_yul_snippet_escaping/output @@ -95,7 +95,6 @@ object "C_2" { code { { /// @src 0:265:278 "contract C {}" - mstore(64, memoryguard(0x80)) revert(0, 0) } } @@ -553,7 +552,6 @@ object "D_27" { code { { /// @src 0:265:278 "contract C {}" - mstore(64, memoryguard(0x80)) revert(0, 0) } } diff --git a/test/cmdlineTests/ir_compiler_inheritance_nosubobjects/output b/test/cmdlineTests/ir_compiler_inheritance_nosubobjects/output index 330e208f4..5246a50ee 100644 --- a/test/cmdlineTests/ir_compiler_inheritance_nosubobjects/output +++ b/test/cmdlineTests/ir_compiler_inheritance_nosubobjects/output @@ -24,7 +24,6 @@ object "C_7" { code { { /// @src 0:82:117 "contract C {..." - mstore(64, memoryguard(0x80)) revert(0, 0) } } @@ -58,7 +57,6 @@ object "D_10" { code { { /// @src 0:118:137 "contract D is C {..." - mstore(64, memoryguard(0x80)) revert(0, 0) } } diff --git a/test/cmdlineTests/ir_compiler_subobjects/output b/test/cmdlineTests/ir_compiler_subobjects/output index fbedf38db..80d90aac5 100644 --- a/test/cmdlineTests/ir_compiler_subobjects/output +++ b/test/cmdlineTests/ir_compiler_subobjects/output @@ -24,7 +24,6 @@ object "C_3" { code { { /// @src 0:82:95 "contract C {}" - mstore(64, memoryguard(0x80)) revert(0, 0) } } @@ -110,7 +109,6 @@ object "D_16" { code { { /// @src 0:82:95 "contract C {}" - mstore(64, memoryguard(0x80)) revert(0, 0) } } diff --git a/test/cmdlineTests/ir_with_assembly_no_memoryguard_creation/output b/test/cmdlineTests/ir_with_assembly_no_memoryguard_creation/output index 34b72f8b8..5b768273e 100644 --- a/test/cmdlineTests/ir_with_assembly_no_memoryguard_creation/output +++ b/test/cmdlineTests/ir_with_assembly_no_memoryguard_creation/output @@ -11,7 +11,6 @@ object "D_12" { code { { /// @src 0:82:161 "contract D {..." - mstore(64, 128) if callvalue() { revert(0, 0) } let _1 := datasize("D_12_deployed") codecopy(128, dataoffset("D_12_deployed"), _1) @@ -23,16 +22,14 @@ object "D_12" { code { { /// @src 0:82:161 "contract D {..." - let _1 := memoryguard(0x80) - mstore(64, _1) if iszero(lt(calldatasize(), 4)) { - let _2 := 0 - if eq(0x26121ff0, shr(224, calldataload(_2))) + let _1 := 0 + if eq(0x26121ff0, shr(224, calldataload(_1))) { - if callvalue() { revert(_2, _2) } - if slt(add(calldatasize(), not(3)), _2) { revert(_2, _2) } - return(_1, _2) + if callvalue() { revert(_1, _1) } + if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) } + return(memoryguard(0x80), _1) } } revert(0, 0) diff --git a/test/cmdlineTests/ir_with_assembly_no_memoryguard_runtime/output b/test/cmdlineTests/ir_with_assembly_no_memoryguard_runtime/output index cc95451e6..fde9d41f9 100644 --- a/test/cmdlineTests/ir_with_assembly_no_memoryguard_runtime/output +++ b/test/cmdlineTests/ir_with_assembly_no_memoryguard_runtime/output @@ -24,7 +24,6 @@ object "D_8" { code { { /// @src 0:82:153 "contract D {..." - mstore(64, 128) if iszero(lt(calldatasize(), 4)) { let _1 := 0 diff --git a/test/cmdlineTests/keccak_optimization_deploy_code/output b/test/cmdlineTests/keccak_optimization_deploy_code/output index 4abb046f6..b70a029fc 100644 --- a/test/cmdlineTests/keccak_optimization_deploy_code/output +++ b/test/cmdlineTests/keccak_optimization_deploy_code/output @@ -11,7 +11,6 @@ object "C_12" { code { { /// @src 0:62:463 "contract C {..." - mstore(64, 128) if callvalue() { revert(0, 0) } /// @src 0:103:275 "assembly {..." mstore(0, 100) @@ -27,10 +26,8 @@ object "C_12" { code { { /// @src 0:62:463 "contract C {..." - mstore(64, 128) if callvalue() { revert(0, 0) } /// @src 0:317:454 "assembly {..." - mstore(0, 100) sstore(0, 17385872270140913825666367956517731270094621555228275961425792378517567244498) /// @src 0:62:463 "contract C {..." stop() diff --git a/test/cmdlineTests/keccak_optimization_low_runs/output b/test/cmdlineTests/keccak_optimization_low_runs/output index f5df14027..691e37145 100644 --- a/test/cmdlineTests/keccak_optimization_low_runs/output +++ b/test/cmdlineTests/keccak_optimization_low_runs/output @@ -24,7 +24,6 @@ object "C_7" { code { { /// @src 0:62:285 "contract C {..." - mstore(64, 128) if callvalue() { revert(0, 0) } /// @src 0:109:277 "assembly {..." mstore(0, 100) diff --git a/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json b/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json index 1c3999afc..c08b40734 100644 --- a/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json +++ b/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json @@ -1,8 +1,5 @@ {"contracts":{"C":{"C":{"evm":{"assembly":" /* \"C\":79:428 contract C... */ 0xa0 - dup1 - 0x40 - mstore jumpi(tag_6, callvalue) 0x1f bytecodeSize @@ -452,9 +449,6 @@ sub_0: assembly { } "}}},"D":{"D":{"evm":{"assembly":" /* \"D\":91:166 contract D is C(3)... */ 0xa0 - dup1 - 0x40 - mstore jumpi(tag_6, callvalue) 0x1f bytecodeSize @@ -528,13 +522,8 @@ tag_4: tag_1: /* \"C\":147:149 42 */ mstore(0x80, 0x2a) - /* \"D\":107:108 3 */ - 0x03 - /* \"C\":203:219 stateVar = _init */ - 0x00 - /* \"D\":91:166 contract D is C(3)... */ - sstore sub(shl(0xff, 0x01), 0x04) + /* \"D\":91:166 contract D is C(3)... */ dup2 sgt 0x01 @@ -545,9 +534,7 @@ tag_1: 0x03 /* \"D\":91:166 contract D is C(3)... */ add - /* \"C\":203:219 stateVar = _init */ 0x00 - /* \"D\":91:166 contract D is C(3)... */ sstore /* \"D\":113:164 constructor(int _init2)... */ jump\t// out @@ -555,17 +542,9 @@ tag_1: tag_9: pop pop - shl(0xe0, 0x4e487b71) - /* \"C\":203:219 stateVar = _init */ - 0x00 - /* \"D\":91:166 contract D is C(3)... */ - mstore + mstore(0x00, shl(0xe0, 0x4e487b71)) mstore(0x04, 0x11) - 0x24 - /* \"C\":203:219 stateVar = _init */ - 0x00 - /* \"D\":91:166 contract D is C(3)... */ - revert + revert(0x00, 0x24) stop sub_0: assembly { diff --git a/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/output.json b/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/output.json index 1fa8928e1..f9651b25b 100644 --- a/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/output.json +++ b/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/output.json @@ -200,16 +200,14 @@ object \"C_6\" { code { { /// @src 0:60:101 \"contract C {...\" - let _1 := memoryguard(0x80) - mstore(64, _1) if iszero(lt(calldatasize(), 4)) { - let _2 := 0 - if eq(0x26121ff0, shr(224, calldataload(_2))) + let _1 := 0 + if eq(0x26121ff0, shr(224, calldataload(_1))) { - if callvalue() { revert(_2, _2) } - if slt(add(calldatasize(), not(3)), _2) { revert(_2, _2) } - return(_1, _2) + if callvalue() { revert(_1, _1) } + if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) } + return(memoryguard(0x80), _1) } } revert(0, 0) diff --git a/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/output.json b/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/output.json index e427b7fe1..e3e249d30 100644 --- a/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/output.json +++ b/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/output.json @@ -199,16 +199,14 @@ object \"C_6\" { code { { /// @src 0:60:101 - let _1 := memoryguard(0x80) - mstore(64, _1) if iszero(lt(calldatasize(), 4)) { - let _2 := 0 - if eq(0x26121ff0, shr(224, calldataload(_2))) + let _1 := 0 + if eq(0x26121ff0, shr(224, calldataload(_1))) { - if callvalue() { revert(_2, _2) } - if slt(add(calldatasize(), not(3)), _2) { revert(_2, _2) } - return(_1, _2) + if callvalue() { revert(_1, _1) } + if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) } + return(memoryguard(0x80), _1) } } revert(0, 0) diff --git a/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/output.json b/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/output.json index e81f461d2..f32a18eef 100644 --- a/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/output.json +++ b/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/output.json @@ -188,16 +188,14 @@ object \"C_6\" { object \"C_6_deployed\" { code { { - let _1 := memoryguard(0x80) - mstore(64, _1) if iszero(lt(calldatasize(), 4)) { - let _2 := 0 - if eq(0x26121ff0, shr(224, calldataload(_2))) + let _1 := 0 + if eq(0x26121ff0, shr(224, calldataload(_1))) { - if callvalue() { revert(_2, _2) } - if slt(add(calldatasize(), not(3)), _2) { revert(_2, _2) } - return(_1, _2) + if callvalue() { revert(_1, _1) } + if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) } + return(memoryguard(0x80), _1) } } revert(0, 0) diff --git a/test/cmdlineTests/standard_debug_info_in_yul_location/output.json b/test/cmdlineTests/standard_debug_info_in_yul_location/output.json index 2acd68ff7..26663f326 100644 --- a/test/cmdlineTests/standard_debug_info_in_yul_location/output.json +++ b/test/cmdlineTests/standard_debug_info_in_yul_location/output.json @@ -592,7 +592,6 @@ object \"C_54\" { { /// @src 0:79:435 \"contract C...\" let _1 := memoryguard(0xa0) - mstore(64, _1) if callvalue() { revert(0, 0) } let programSize := datasize(\"C_54\") let argSize := sub(codesize(), programSize) @@ -1417,7 +1416,6 @@ object \"D_72\" { { /// @src 1:91:166 \"contract D is C(3)...\" let _1 := memoryguard(0xa0) - mstore(64, _1) if callvalue() { revert(0, 0) } let programSize := datasize(\"D_72\") let argSize := sub(codesize(), programSize) @@ -1448,15 +1446,13 @@ object \"D_72\" { /// @src 0:154:156 \"42\" mstore(128, 0x2a) /// @src 1:91:166 \"contract D is C(3)...\" - sstore(/** @src 0:210:226 \"stateVar = _init\" */ 0x00, /** @src 1:107:108 \"3\" */ 0x03) - /// @src 1:91:166 \"contract D is C(3)...\" if and(1, sgt(var_init2, sub(shl(255, 1), 4))) { - mstore(/** @src 0:210:226 \"stateVar = _init\" */ 0x00, /** @src 1:91:166 \"contract D is C(3)...\" */ shl(224, 0x4e487b71)) + mstore(0, shl(224, 0x4e487b71)) mstore(4, 0x11) - revert(/** @src 0:210:226 \"stateVar = _init\" */ 0x00, /** @src 1:91:166 \"contract D is C(3)...\" */ 0x24) + revert(0, 0x24) } - sstore(/** @src 0:210:226 \"stateVar = _init\" */ 0x00, /** @src 1:91:166 \"contract D is C(3)...\" */ add(/** @src 1:107:108 \"3\" */ 0x03, /** @src 1:91:166 \"contract D is C(3)...\" */ var_init2)) + sstore(/** @src -1:-1:-1 */ 0, /** @src 1:91:166 \"contract D is C(3)...\" */ add(/** @src 1:107:108 \"3\" */ 0x03, /** @src 1:91:166 \"contract D is C(3)...\" */ var_init2)) } } /// @use-src 0:\"C\", 1:\"D\" diff --git a/test/cmdlineTests/viair_subobjects/output b/test/cmdlineTests/viair_subobjects/output index 4b388665c..aea2013ec 100644 --- a/test/cmdlineTests/viair_subobjects/output +++ b/test/cmdlineTests/viair_subobjects/output @@ -30,7 +30,6 @@ object "C_3" { code { { /// @src 0:82:95 "contract C {}" - mstore(64, memoryguard(0x80)) revert(0, 0) } } @@ -122,7 +121,6 @@ object "D_16" { code { { /// @src 0:82:95 "contract C {}" - mstore(64, memoryguard(0x80)) revert(0, 0) } } diff --git a/test/libsolidity/semanticTests/array/copying/copy_byte_array_to_storage.sol b/test/libsolidity/semanticTests/array/copying/copy_byte_array_to_storage.sol index b73f3dc44..8f9df3c7e 100644 --- a/test/libsolidity/semanticTests/array/copying/copy_byte_array_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/copy_byte_array_to_storage.sol @@ -48,6 +48,6 @@ contract C { // compileViaYul: also // ---- // f() -> 0xff -// gas irOptimized: 121145 +// gas irOptimized: 121125 // gas legacy: 128035 // gas legacyOptimized: 123476 diff --git a/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol b/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol index 82c8d6b6c..8d0f6358e 100644 --- a/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol +++ b/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol @@ -16,4 +16,4 @@ contract C { // compileViaYul: also // ---- // f() -> 0, 0, 0 -// gas irOptimized: 91098 +// gas irOptimized: 90992 diff --git a/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty_garbage_ref.sol b/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty_garbage_ref.sol index 38c0c84d6..158f3d5e8 100644 --- a/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty_garbage_ref.sol +++ b/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty_garbage_ref.sol @@ -19,5 +19,5 @@ contract c { // test() -> // gas irOptimized: 142640 // gas legacy: 165363 -// gas legacyOptimized: 159446 +// gas legacyOptimized: 158831 // storageEmpty -> 1 diff --git a/test/libsolidity/semanticTests/array/reusing_memory.sol b/test/libsolidity/semanticTests/array/reusing_memory.sol index ee1a57b1e..8112a8e11 100644 --- a/test/libsolidity/semanticTests/array/reusing_memory.sol +++ b/test/libsolidity/semanticTests/array/reusing_memory.sol @@ -26,6 +26,6 @@ contract Main { // compileViaYul: also // ---- // f(uint256): 0x34 -> 0x46bddb1178e94d7f2892ff5f366840eb658911794f2c3a44c450aa2c505186c1 -// gas irOptimized: 113581 +// gas irOptimized: 113572 // gas legacy: 126596 // gas legacyOptimized: 113823 diff --git a/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol b/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol index 3fdbb0785..9908b2386 100644 --- a/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol +++ b/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol @@ -19,6 +19,6 @@ contract C { // compileViaYul: also // ---- // f(), 2000 ether -> true -// gas irOptimized: 123037 +// gas irOptimized: 120037 // gas legacy: 123226 // gas legacyOptimized: 123092 diff --git a/test/libsolidity/semanticTests/salted_create/salted_create.sol b/test/libsolidity/semanticTests/salted_create/salted_create.sol index 5374d2352..51b987c2c 100644 --- a/test/libsolidity/semanticTests/salted_create/salted_create.sol +++ b/test/libsolidity/semanticTests/salted_create/salted_create.sol @@ -22,6 +22,6 @@ contract A { // ---- // different_salt() -> true // same_salt() -> true -// gas irOptimized: 98438914 +// gas irOptimized: 98438898 // gas legacy: 98439116 // gas legacyOptimized: 98438970 diff --git a/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol b/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol index e8fe01687..231645a10 100644 --- a/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol +++ b/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol @@ -22,6 +22,6 @@ contract A { // compileViaYul: also // ---- // f(), 10 ether -> 3007, 3008, 3009 -// gas irOptimized: 272947 +// gas irOptimized: 272920 // gas legacy: 422501 // gas legacyOptimized: 287472 diff --git a/test/libsolidity/semanticTests/structs/struct_copy_via_local.sol b/test/libsolidity/semanticTests/structs/struct_copy_via_local.sol index 21757ea40..4305687b7 100644 --- a/test/libsolidity/semanticTests/structs/struct_copy_via_local.sol +++ b/test/libsolidity/semanticTests/structs/struct_copy_via_local.sol @@ -21,6 +21,6 @@ contract c { // compileViaYul: also // ---- // test() -> true -// gas irOptimized: 110186 +// gas irOptimized: 110177 // gas legacy: 110627 // gas legacyOptimized: 109706 diff --git a/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol b/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol index bc18d3192..1af67bd52 100644 --- a/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol +++ b/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol @@ -33,4 +33,4 @@ contract C { // compileViaYul: true // ---- // f() -> 0, 0, 0 -// gas irOptimized: 117289 +// gas irOptimized: 117277 diff --git a/test/libsolidity/semanticTests/structs/struct_delete_storage_with_arrays_small.sol b/test/libsolidity/semanticTests/structs/struct_delete_storage_with_arrays_small.sol index 6f88df394..abc10d8aa 100644 --- a/test/libsolidity/semanticTests/structs/struct_delete_storage_with_arrays_small.sol +++ b/test/libsolidity/semanticTests/structs/struct_delete_storage_with_arrays_small.sol @@ -27,4 +27,4 @@ contract C { // compileViaYul: true // ---- // f() -> 0 -// gas irOptimized: 111896 +// gas irOptimized: 112129 diff --git a/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol b/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol index fe791a68d..936039f5e 100644 --- a/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol +++ b/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol @@ -32,6 +32,6 @@ contract C { // compileViaYul: also // ---- // f() -> 42, 23, 34, 42, 42 -// gas irOptimized: 110966 +// gas irOptimized: 110845 // gas legacy: 112021 // gas legacyOptimized: 110548 diff --git a/test/libsolidity/semanticTests/structs/structs.sol b/test/libsolidity/semanticTests/structs/structs.sol index b56a2ec22..57b7d28f8 100644 --- a/test/libsolidity/semanticTests/structs/structs.sol +++ b/test/libsolidity/semanticTests/structs/structs.sol @@ -32,7 +32,7 @@ contract test { // ---- // check() -> false // set() -> -// gas irOptimized: 134335 +// gas irOptimized: 134314 // gas legacy: 135277 // gas legacyOptimized: 134064 // check() -> true diff --git a/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol b/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol index 433d1969c..0305fd473 100644 --- a/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol @@ -25,7 +25,7 @@ contract C { // ---- // s() -> 0, 0, 0x00, 0 // f((uint8,uint16,bytes2,uint8)): 1, 0xff, "ab", 15 -> -// gas irOptimized: 44786 +// gas irOptimized: 44405 // gas legacy: 47200 // gas legacyOptimized: 44923 // s() -> 1, 0xff, 0x6162000000000000000000000000000000000000000000000000000000000000, 15 diff --git a/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol b/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol index 04e993682..b250bea87 100644 --- a/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol +++ b/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol @@ -25,7 +25,7 @@ contract C { // ---- // s() -> 0, 0, 0x00, 0 // f((uint8,uint16,bytes2,uint8)): 1, 0xff, "ab", 15 -> -// gas irOptimized: 44536 +// gas irOptimized: 44473 // gas legacy: 46213 // gas legacyOptimized: 44671 // s() -> 1, 0xff, 0x6162000000000000000000000000000000000000000000000000000000000000, 15 diff --git a/test/libyul/YulOptimizerTestCommon.cpp b/test/libyul/YulOptimizerTestCommon.cpp index cc315c4b9..9ac268425 100644 --- a/test/libyul/YulOptimizerTestCommon.cpp +++ b/test/libyul/YulOptimizerTestCommon.cpp @@ -53,6 +53,7 @@ #include #include #include +#include #include #include #include @@ -236,6 +237,15 @@ YulOptimizerTestCommon::YulOptimizerTestCommon( ForLoopInitRewriter::run(*m_context, *m_ast); UnusedAssignEliminator::run(*m_context, *m_ast); }}, + {"unusedStoreEliminator", [&]() { + disambiguate(); + ForLoopInitRewriter::run(*m_context, *m_ast); + ExpressionSplitter::run(*m_context, *m_ast); + SSATransform::run(*m_context, *m_ast); + UnusedStoreEliminator::run(*m_context, *m_ast); + SSAReverser::run(*m_context, *m_ast); + ExpressionJoiner::run(*m_context, *m_ast); + }}, {"ssaPlusCleanup", [&]() { disambiguate(); ForLoopInitRewriter::run(*m_context, *m_ast); diff --git a/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul b/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul new file mode 100644 index 000000000..1278091f3 --- /dev/null +++ b/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul @@ -0,0 +1,37 @@ +{ + let _1 := 0 + let value := calldataload(4) + if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(_1, _1) } + let length := extcodesize(value) + let _2 := 0xffffffffffffffff + if gt(length, _2) { revert(0, 0) } + let _3 := not(31) + let memPtr := mload(64) + let newFreePtr := add(memPtr, and(add(and(add(length, 31), _3), 63), _3)) + if or(gt(newFreePtr, _2), lt(newFreePtr, memPtr)) { revert(0, 0) } + mstore(64, newFreePtr) + mstore(memPtr, length) + + // We aim to optimize this out. + extcodecopy(value, add(memPtr, 32), _1, length) + sstore(_1, mload(memPtr)) +} +// ==== +// EVMVersion: >byzantium +// ---- +// step: fullSuite +// +// { +// { +// let value := calldataload(4) +// if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) } +// let length := extcodesize(value) +// let _1 := 0xffffffffffffffff +// if gt(length, _1) { revert(0, 0) } +// let memPtr := mload(64) +// let _2 := not(31) +// let newFreePtr := add(memPtr, and(add(and(add(length, 31), _2), 63), _2)) +// if or(gt(newFreePtr, _1), lt(newFreePtr, memPtr)) { revert(0, 0) } +// sstore(0, length) +// } +// } diff --git a/test/libyul/yulOptimizerTests/fullSuite/medium.yul b/test/libyul/yulOptimizerTests/fullSuite/medium.yul index 41b77c115..9a6381d79 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/medium.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/medium.yul @@ -23,13 +23,7 @@ // // { // { -// let p := mload(0x40) -// mstore(0x40, add(p, 0x20)) -// mstore(0x40, add(p, 96)) -// let p_1 := add(p, 128) -// mstore(p_1, 2) -// mstore(0x40, 0x20) -// sstore(0, p_1) +// sstore(0, add(mload(0x40), 128)) // sstore(1, 0x20) // } // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/remove_redundant_assignments_in_switch.yul b/test/libyul/yulOptimizerTests/fullSuite/remove_redundant_assignments_in_switch.yul index a0ac5c36d..317661325 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/remove_redundant_assignments_in_switch.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/remove_redundant_assignments_in_switch.yul @@ -15,6 +15,5 @@ // case 0 { } // case 1 { } // default { invalid() } -// mstore(1, 1) // } // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul b/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul index d670f002f..75e2ff4c2 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul @@ -52,7 +52,6 @@ // pop(keccak256(gcd(_3, _2), or(gt(not(gcd(_3, _2)), _1), _1))) // mstore(lt(or(gt(_1, or(or(gt(or(or(or(gt(or(gt(_6, _9), _1), _8), _7), _5), _1), _1), _4), _1)), _1), _1), _1) // sstore(not(gcd(_3, _2)), _1) -// sstore(0, 0) // sstore(2, _1) // extcodecopy(_1, msize(), _1, _1) // sstore(0, 0) diff --git a/test/libyul/yulOptimizerTests/fullSuite/static_array_slot_computation.yul b/test/libyul/yulOptimizerTests/fullSuite/static_array_slot_computation.yul index c5f4aa466..72c09d3dc 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/static_array_slot_computation.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/static_array_slot_computation.yul @@ -39,7 +39,6 @@ // mstore(4, 0x32) // revert(_1, 0x24) // } -// mstore(_1, _1) // sstore(0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e56d, 0x05) // } // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/storage.yul b/test/libyul/yulOptimizerTests/fullSuite/storage.yul index 7b3360847..a60b3d348 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/storage.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/storage.yul @@ -8,7 +8,6 @@ // // { // { -// sstore(4, 5) // sstore(4, 3) // sstore(8, 3) // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul index b7f0b4afb..6f82ab27a 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul @@ -20,7 +20,6 @@ // { // { // let out1, out2 := foo(sload(32)) -// sstore(0, out1) // sstore(0, out2) // let out1_1, out2_1 := foo(sload(8)) // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_loop.yul b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_loop.yul index b531842db..7955ee12e 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_loop.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_loop.yul @@ -18,9 +18,7 @@ // { // { // f() -// sstore(0, 1) // f() -// sstore(0, 1) // f() // sstore(0, 1) // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_recursion.yul b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_recursion.yul index c3b75e84e..92d251cab 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_recursion.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_recursion.yul @@ -18,7 +18,6 @@ // { // let x, y, z := f() // sstore(0, x) -// sstore(1, y) // sstore(1, z) // } // function f() -> x, y, z diff --git a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul index 14f0137cb..b066d998b 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul @@ -22,8 +22,6 @@ // { // { // let out1, out2 := foo(sload(32)) -// sstore(0, out1) -// sstore(0, out2) // sstore(0, 0) // let out1_1, out2_1 := foo(sload(8)) // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_simple.yul b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_simple.yul index 531b1a6ce..785840baa 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_simple.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_simple.yul @@ -16,9 +16,7 @@ // { // { // f() -// sstore(0, 1) // f() -// sstore(0, 1) // f() // sstore(0, 1) // } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/covering_calldatacopy.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/covering_calldatacopy.yul new file mode 100644 index 000000000..b986f99ec --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/covering_calldatacopy.yul @@ -0,0 +1,59 @@ +{ + let start := calldataload(0x10) + if calldataload(0) { + // not covered + mstore(add(start, 2), 7) + calldatacopy(start, 0, 0x20) + } + if calldataload(1) { + // covered + mstore(add(start, 2), 9) + calldatacopy(add(start, 1), 0, 0x21) + } + if calldataload(2) { + // covered + mstore8(add(start, 2), 7) + calldatacopy(start, 0, 3) + } + if calldataload(3) { + // not covered + mstore8(add(start, 3), 7) + calldatacopy(start, 0, 3) + } + sstore(0, keccak256(start, 0x40)) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let start := calldataload(0x10) +// if calldataload(0) +// { +// let _4 := 7 +// mstore(add(start, 2), _4) +// calldatacopy(start, 0, 0x20) +// } +// if calldataload(1) +// { +// let _11 := 9 +// let _13 := add(start, 2) +// let _14 := 0x21 +// let _15 := 0 +// calldatacopy(add(start, 1), _15, _14) +// } +// if calldataload(2) +// { +// let _20 := 7 +// let _22 := add(start, 2) +// calldatacopy(start, 0, 3) +// } +// if calldataload(3) +// { +// let _27 := 7 +// mstore8(add(start, 3), _27) +// calldatacopy(start, 0, 3) +// } +// sstore(0, keccak256(start, 0x40)) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/create.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/create.yul new file mode 100644 index 000000000..bc1e651ec --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/create.yul @@ -0,0 +1,15 @@ +{ + sstore(5, 10) + pop(create(0, 0, 0)) + sstore(5, 20) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// sstore(5, 10) +// pop(create(0, 0, 0)) +// sstore(5, 20) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_end.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_end.yul new file mode 100644 index 000000000..05a5d118e --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_end.yul @@ -0,0 +1,20 @@ +{ + function f() { + let x := calldataload(2) + sstore(x, 2) + // This cannot be removed because we do not know what happens after the function. + sstore(x, 3) + } +} +// ---- +// step: unusedStoreEliminator +// +// { +// { } +// function f() +// { +// let x := calldataload(2) +// let _2 := 2 +// sstore(x, 3) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_side_effects.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_side_effects.yul new file mode 100644 index 000000000..25f9355b3 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_side_effects.yul @@ -0,0 +1,55 @@ +{ + function justStop() { return(0, 0) } + function justRevert() { revert(0, 0) } + + let x := 0 + let y := 1 + let a := 0x80 + let b := 7 + let c := 9 + switch calldataload(0) + case 0 + { + sstore(x, y) + mstore(a, b) + justStop() + sstore(x, y) + mstore(a, b) + } + case 1 + { + sstore(x, y) + mstore(a, b) + justRevert() + sstore(x, y) + mstore(a, b) + } +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let x := 0 +// let y := 1 +// let a := 0x80 +// let b := 7 +// let c := 9 +// switch calldataload(0) +// case 0 { +// sstore(x, y) +// mstore(a, b) +// justStop() +// sstore(x, y) +// } +// case 1 { +// mstore(a, b) +// justRevert() +// sstore(x, y) +// } +// } +// function justStop() +// { return(0, 0) } +// function justRevert() +// { revert(0, 0) } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_side_effects_2.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_side_effects_2.yul new file mode 100644 index 000000000..843f7f6e9 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/function_side_effects_2.yul @@ -0,0 +1,28 @@ +{ + let x := 0 + let y := 1 + sstore(x, y) + f() + sstore(x, y) + function f() { + // prevent inlining + f() + return(0, 0) + } + } +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let x := 0 +// let y := 1 +// f() +// sstore(x, y) +// } +// function f() +// { +// f() +// return(0, 0) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/if_overwrite_all_branches.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/if_overwrite_all_branches.yul new file mode 100644 index 000000000..7054dc255 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/if_overwrite_all_branches.yul @@ -0,0 +1,20 @@ +{ + let c := calldataload(0) + // This store will be overwritten in all branches and thus can be removed. + sstore(c, 1) + if c { + sstore(c, 2) + } + sstore(c, 3) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let c := calldataload(0) +// let _2 := 1 +// if c { let _3 := 2 } +// sstore(c, 3) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/leave.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/leave.yul new file mode 100644 index 000000000..92a751554 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/leave.yul @@ -0,0 +1,23 @@ +{ + function f() { + mstore(0, 5) + if calldataload(0) { leave } + mstore(0x20, 5) + revert(0, 0) + } + f() +} +// ---- +// step: unusedStoreEliminator +// +// { +// { f() } +// function f() +// { +// mstore(0, 5) +// if calldataload(0) { leave } +// let _5 := 5 +// let _6 := 0x20 +// revert(0, 0) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/memoryguard.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/memoryguard.yul new file mode 100644 index 000000000..e74a966a0 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/memoryguard.yul @@ -0,0 +1,24 @@ +{ + mstore(0x40, memoryguard(100)) + let free_mem_ptr := mload(0x40) + // redundant + mstore(free_mem_ptr, 100) + // redundant + mstore8(add(free_mem_ptr, 31), 200) + mstore(free_mem_ptr, 300) + return(free_mem_ptr, add(free_mem_ptr, 100)) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// mstore(0x40, memoryguard(100)) +// let free_mem_ptr := mload(0x40) +// let _4 := 100 +// let _5 := 200 +// let _7 := add(free_mem_ptr, 31) +// mstore(free_mem_ptr, 300) +// return(free_mem_ptr, add(free_mem_ptr, 100)) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/mload.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/mload.yul new file mode 100644 index 000000000..2dc5392f5 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/mload.yul @@ -0,0 +1,18 @@ +{ + mstore(0, 5) + let x := mload(0) + mstore(0, 8) + let y := mload(0) + sstore(0, y) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// mstore(0, 5) +// let x := mload(0) +// mstore(0, 8) +// sstore(0, mload(0)) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/overflow.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/overflow.yul new file mode 100644 index 000000000..dda59873c --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/overflow.yul @@ -0,0 +1,18 @@ +{ + let x := 0 + + calldatacopy(0, 0, 115792089237316195423570985008687907853269984665640564039457584007913129639935) + mstore(x, 20) + return(0, 32) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let x := 0 +// calldatacopy(0, 0, 115792089237316195423570985008687907853269984665640564039457584007913129639935) +// mstore(x, 20) +// return(0, 32) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/overlapping.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/overlapping.yul new file mode 100644 index 000000000..78179dc3e --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/overlapping.yul @@ -0,0 +1,21 @@ +{ + let _1 := 0 + if callvalue() { revert(_1, _1) } + mstore(_1, shl(224, 0x4e487b71)) + mstore(4, 0x32) + revert(_1, 0x24) +} +// ==== +// EVMVersion: >=constantinople +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let _1 := 0 +// if callvalue() { revert(_1, _1) } +// mstore(_1, shl(224, 0x4e487b71)) +// mstore(4, 0x32) +// revert(_1, 0x24) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/overlapping_small.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/overlapping_small.yul new file mode 100644 index 000000000..2950a04ce --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/overlapping_small.yul @@ -0,0 +1,27 @@ +{ + let _1 := 0 + let _2 := callvalue() + let _3 := 0x4e487b71 + let _4 := 224 + let _5 := 7 + mstore(_1, _5) + let _6 := 0x32 + let _7 := 4 + mstore(_7, _6) + let _8 := 0x24 + revert(_1, _8) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let _1 := 0 +// let _2 := callvalue() +// let _3 := 0x4e487b71 +// let _4 := 224 +// mstore(_1, 7) +// mstore(4, 0x32) +// revert(_1, 0x24) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/remove_before_revert.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/remove_before_revert.yul new file mode 100644 index 000000000..e7777964c --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/remove_before_revert.yul @@ -0,0 +1,21 @@ +{ + let c := calldataload(0) + mstore(c, 4) + if c { + sstore(c, 2) + } + let d := 0 + revert(d, d) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let c := calldataload(0) +// let _2 := 4 +// if c { let _3 := 2 } +// let d := 0 +// revert(d, d) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/unknown_length2.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/unknown_length2.yul new file mode 100644 index 000000000..db5f060a6 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/unknown_length2.yul @@ -0,0 +1,33 @@ +{ + let a + switch calldataload(0) + case 0 { a := calldataload(9) } + case 1 { a := calldataload(10) } + + calldatacopy(0x20, 0, a) + let x := mload(0) + sstore(0, x) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let a_9 +// let a := a_9 +// switch calldataload(0) +// case 0 { +// a := calldataload(9) +// let a_10 := a +// } +// case 1 { +// let a_12 := a +// a := calldataload(10) +// let a_11 := a +// } +// let a_13 := a +// let _5 := 0 +// let _6 := 0x20 +// sstore(0, mload(0)) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/unrelated_relative.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/unrelated_relative.yul new file mode 100644 index 000000000..b0b42060f --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/unrelated_relative.yul @@ -0,0 +1,23 @@ +{ + let c := calldataload(0) + mstore(c, 4) + mstore(add(c, 0x20), 8) + sstore(0, mload(c)) + mstore(c, 9) + mstore(add(c, 0x20), 20) +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let c := calldataload(0) +// mstore(c, 4) +// let _3 := 8 +// let _5 := add(c, 0x20) +// sstore(0, mload(c)) +// let _8 := 9 +// let _9 := 20 +// let _11 := add(c, 0x20) +// } +// } diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/write_before_recursion.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/write_before_recursion.yul new file mode 100644 index 000000000..855ae8325 --- /dev/null +++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/write_before_recursion.yul @@ -0,0 +1,27 @@ +{ + sstore(0, 1) + mstore(0, 2) + f() + function f() { + g() + } + function g() { + f() + } +} +// ---- +// step: unusedStoreEliminator +// +// { +// { +// let _1 := 1 +// let _2 := 0 +// let _3 := 2 +// let _4 := 0 +// f() +// } +// function f() +// { g() } +// function g() +// { f() } +// } diff --git a/test/yulPhaser/Chromosome.cpp b/test/yulPhaser/Chromosome.cpp index 9a396283d..d003ff749 100644 --- a/test/yulPhaser/Chromosome.cpp +++ b/test/yulPhaser/Chromosome.cpp @@ -138,7 +138,7 @@ BOOST_AUTO_TEST_CASE(output_operator_should_create_concise_and_unambiguous_strin BOOST_TEST(chromosome.length() == allSteps.size()); BOOST_TEST(chromosome.optimisationSteps() == allSteps); - BOOST_TEST(toString(chromosome) == "flcCUnDvejsxIOoighFTLMRrmVatpud"); + BOOST_TEST(toString(chromosome) == "flcCUnDvejsxIOoighFTLMRrSmVatpud"); } BOOST_AUTO_TEST_CASE(optimisationSteps_should_translate_chromosomes_genes_to_optimisation_step_names)