diff --git a/libjulia/optimiser/UnusedPruner.cpp b/libjulia/optimiser/UnusedPruner.cpp new file mode 100644 index 000000000..e33bef789 --- /dev/null +++ b/libjulia/optimiser/UnusedPruner.cpp @@ -0,0 +1,107 @@ +/*( + 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 . +*/ +/** + * Optimisation stage that removes unused variables and functions. + */ + +#include + +#include +#include +#include + +#include + +#include + +using namespace std; +using namespace dev; +using namespace dev::julia; + +UnusedPruner::UnusedPruner(Block& _ast) +{ + ReferencesCounter counter; + counter(_ast); + + m_references = counter.references(); +} + +void UnusedPruner::operator()(Block& _block) +{ + for (auto&& statement: _block.statements) + if (statement.type() == typeid(FunctionDefinition)) + { + FunctionDefinition& funDef = boost::get(statement); + if (!used(funDef.name)) + { + subtractReferences(ReferencesCounter::countReferences(funDef.body)); + statement = Block{std::move(funDef.location), {}}; + } + } + else if (statement.type() == typeid(VariableDeclaration)) + { + VariableDeclaration& varDecl = boost::get(statement); + if (boost::algorithm::none_of( + varDecl.variables, + [=](TypedName const& _typedName) { return used(_typedName.name); } + )) + { + if (!varDecl.value || MovableChecker(*varDecl.value).movable()) + { + subtractReferences(ReferencesCounter::countReferences(*varDecl.value)); + statement = Block{std::move(varDecl.location), {}}; + } + else if (varDecl.value && varDecl.variables.size() == 1) + statement = ExpressionStatement{varDecl.location, FunctionalInstruction{ + varDecl.location, + solidity::Instruction::POP, + {*std::move(varDecl.value)} + }}; + } + } + + removeEmptyBlocks(_block); + + ASTModifier::operator()(_block); +} + +void UnusedPruner::runUntilStabilised(Block& _ast) +{ + while (true) + { + UnusedPruner pruner(_ast); + pruner(_ast); + if (!pruner.shouldRunAgain()) + return; + } +} + +bool UnusedPruner::used(string const& _name) const +{ + return m_references.count(_name) && m_references.at(_name) > 0; +} + +void UnusedPruner::subtractReferences(map const& _subtrahend) +{ + for (auto const& ref: _subtrahend) + { + solAssert(m_references.count(ref.first), ""); + solAssert(m_references.at(ref.first) >= ref.second, ""); + m_references[ref.first] -= ref.second; + m_shouldRunAgain = true; + } +} diff --git a/libjulia/optimiser/UnusedPruner.h b/libjulia/optimiser/UnusedPruner.h new file mode 100644 index 000000000..8b5212328 --- /dev/null +++ b/libjulia/optimiser/UnusedPruner.h @@ -0,0 +1,65 @@ +/* + 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 . +*/ +/** + * Optimisation stage that removes unused variables and functions. + */ + +#pragma once + +#include + +#include +#include +#include + +namespace dev +{ +namespace julia +{ + +/** + * Optimisation stage that removes unused variables and functions. + * + * TODO: Also remove intermediate variable assignments from movable expressions + * which are not referenced until after the next assignment to the same variable. + * + * Note that this does not remove circular references. + * + * Prerequisite: Disambiguator + */ +class UnusedPruner: public ASTModifier +{ +public: + explicit UnusedPruner(Block& _ast); + + using ASTModifier::operator(); + virtual void operator()(Block& _block) override; + + bool shouldRunAgain() const { return m_shouldRunAgain; } + + static void runUntilStabilised(Block& _ast); + +private: + bool used(std::string const& _name) const; + void subtractReferences(std::map const& _subtrahend); + + bool m_shouldRunAgain = false; + std::map m_references; +}; + +} +} diff --git a/test/libjulia/UnusedPruner.cpp b/test/libjulia/UnusedPruner.cpp new file mode 100644 index 000000000..e646cee6d --- /dev/null +++ b/test/libjulia/UnusedPruner.cpp @@ -0,0 +1,98 @@ +/* + 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 . +*/ +/** + * @date 2017 + * Unit tests for the pruning of unused variables and functions. + */ + +#include + +#include + +#include + +#include + +#include +#include + +using namespace std; +using namespace dev; +using namespace dev::julia; +using namespace dev::julia::test; +using namespace dev::solidity; + + +#define CHECK(_original, _expectation)\ +do\ +{\ + assembly::AsmPrinter p;\ + Block b = disambiguate(_original, false);\ + UnusedPruner::runUntilStabilised(b);\ + string result = p(b);\ + BOOST_CHECK_EQUAL(result, format(_expectation, false));\ +}\ +while(false) + +BOOST_AUTO_TEST_SUITE(IuliaUnusedPruner) + +BOOST_AUTO_TEST_CASE(smoke_test) +{ + CHECK("{ }", "{ }"); +} + +BOOST_AUTO_TEST_CASE(trivial) +{ + CHECK( + "{ let a := 1 let b := 1 mstore(0, 1) }", + "{ mstore(0, 1) }" + ); +} + +BOOST_AUTO_TEST_CASE(functions) +{ + CHECK( + "{ function f() { let a := 1 } function g() { f() } }", + "{ }" + ); +} + +BOOST_AUTO_TEST_CASE(intermediate_assignment) +{ + CHECK( + "{ let a := 1 a := 4 let b := 1 }", + "{ let a := 1 a := 4 }" + ); +} + +BOOST_AUTO_TEST_CASE(multi_declare) +{ + CHECK( + "{ function f() -> x, y { } let a, b := f() }", + "{ function f() -> x, y { } let a, b := f() }" + ); +} + +BOOST_AUTO_TEST_CASE(multi_assign) +{ + CHECK( + "{ let a let b function f() -> x, y { } a, b := f() }", + "{ let a let b function f() -> x, y { } a, b := f() }" + ); +} + +BOOST_AUTO_TEST_SUITE_END()