Split structural simplifier.

libyul/CMakeLists.txt

@@ -56,6 +56,8 @@ add_library(yul
 	optimiser/BlockFlattener.h
 	optimiser/CommonSubexpressionEliminator.cpp
 	optimiser/CommonSubexpressionEliminator.h
+	optimiser/ControlFlowSimplifier.cpp
+	optimiser/ControlFlowSimplifier.h
 	optimiser/DataFlowAnalyzer.cpp
 	optimiser/DataFlowAnalyzer.h
 	optimiser/DeadCodeEliminator.cpp

libyul/optimiser/ControlFlowSimplifier.cpp

@@ -0,0 +1,158 @@
+/*
+	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 <http://www.gnu.org/licenses/>.
+*/
+#include <libyul/optimiser/ControlFlowSimplifier.h>
+#include <libyul/optimiser/Semantics.h>
+#include <libyul/AsmData.h>
+#include <libyul/Utilities.h>
+#include <libdevcore/CommonData.h>
+#include <libdevcore/Visitor.h>
+
+#include <boost/range/algorithm_ext/erase.hpp>
+#include <boost/algorithm/cxx11/any_of.hpp>
+
+using namespace std;
+using namespace dev;
+using namespace yul;
+
+using OptionalStatements = boost::optional<vector<Statement>>;
+
+namespace
+{
+
+ExpressionStatement makePopExpressionStatement(langutil::SourceLocation const& _location, Expression&& _expression)
+{
+	return {_location, FunctionalInstruction{
+		_location,
+		dev::eth::Instruction::POP,
+		{std::move(_expression)}
+	}};
+}
+
+void removeEmptyDefaultFromSwitch(Switch& _switchStmt)
+{
+	boost::remove_erase_if(
+		_switchStmt.cases,
+		[](Case const& _case) { return !_case.value && _case.body.statements.empty(); }
+	);
+}
+
+void removeEmptyCasesFromSwitch(Switch& _switchStmt)
+{
+	bool hasDefault = boost::algorithm::any_of(
+		_switchStmt.cases,
+		[](Case const& _case) { return !_case.value; }
+	);
+
+	if (hasDefault)
+		return;
+
+	boost::remove_erase_if(
+		_switchStmt.cases,
+		[](Case const& _case) { return _case.body.statements.empty(); }
+	);
+}
+
+OptionalStatements reduceNoCaseSwitch(Switch& _switchStmt)
+{
+	yulAssert(_switchStmt.cases.empty(), "Expected no case!");
+
+	auto loc = locationOf(*_switchStmt.expression);
+
+	OptionalStatements s = vector<Statement>{};
+
+	s->emplace_back(makePopExpressionStatement(loc, std::move(*_switchStmt.expression)));
+
+	return s;
+}
+
+OptionalStatements reduceSingleCaseSwitch(Switch& _switchStmt)
+{
+	yulAssert(_switchStmt.cases.size() == 1, "Expected only one case!");
+
+	auto& switchCase = _switchStmt.cases.front();
+	auto loc = locationOf(*_switchStmt.expression);
+	if (switchCase.value)
+	{
+		OptionalStatements s = vector<Statement>{};
+		s->emplace_back(If{
+				std::move(_switchStmt.location),
+				make_unique<Expression>(FunctionalInstruction{
+					std::move(loc),
+					dev::eth::Instruction::EQ,
+					{std::move(*switchCase.value), std::move(*_switchStmt.expression)}
+				}),
+				std::move(switchCase.body)
+		});
+		return s;
+	}
+	else
+	{
+		OptionalStatements s = vector<Statement>{};
+		s->emplace_back(makePopExpressionStatement(loc, std::move(*_switchStmt.expression)));
+		s->emplace_back(std::move(switchCase.body));
+		return s;
+	}
+}
+
+}
+
+void ControlFlowSimplifier::operator()(Block& _block)
+{
+	simplify(_block.statements);
+}
+
+void ControlFlowSimplifier::simplify(std::vector<yul::Statement>& _statements)
+{
+	GenericFallbackReturnsVisitor<OptionalStatements, If, Switch, ForLoop> const visitor(
+		[&](If& _ifStmt) -> OptionalStatements {
+			if (_ifStmt.body.statements.empty())
+			{
+				OptionalStatements s = vector<Statement>{};
+				s->emplace_back(makePopExpressionStatement(_ifStmt.location, std::move(*_ifStmt.condition)));
+				return s;
+			}
+			return {};
+		},
+		[&](Switch& _switchStmt) -> OptionalStatements {
+			removeEmptyDefaultFromSwitch(_switchStmt);
+			removeEmptyCasesFromSwitch(_switchStmt);
+
+			if (_switchStmt.cases.empty())
+				return reduceNoCaseSwitch(_switchStmt);
+			else if (_switchStmt.cases.size() == 1)
+				return reduceSingleCaseSwitch(_switchStmt);
+
+			return {};
+		},
+		[&](ForLoop&) -> OptionalStatements {
+			return {};
+		}
+	);
+
+	iterateReplacing(
+		_statements,
+		[&](Statement& _stmt) -> OptionalStatements
+		{
+			OptionalStatements result = boost::apply_visitor(visitor, _stmt);
+			if (result)
+				simplify(*result);
+			else
+				visit(_stmt);
+			return result;
+		}
+	);
+}

libyul/optimiser/ControlFlowSimplifier.h

@@ -0,0 +1,54 @@
+/*
+	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 <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include <libyul/optimiser/ASTWalker.h>
+
+namespace yul
+{
+
+/**
+ * Simplifies several control-flow structures:
+ * - replace if with empty body with pop(condition)
+ * - remove empty default switch case
+ * - remove empty switch case if no default case exists
+ * - replace switch with no cases with pop(expression)
+ * - turn switch with single case into if
+ * - replace switch with only default case with pop(expression) and body
+ * - replace switch with const expr with matching case body
+ * - replace ``for`` with terminating control flow and without other break/continue by ``if``
+ *
+ * None of these operations depend on the data flow. The StructuralSimplifier
+ * performs similar tasks that do depend on data flow.
+ *
+ * The ControlFlowSimplifier does record the presence or absence of ``break``
+ * and ``continue`` statements during its traversal.
+ *
+ * Prerequisite: Disambiguator, ForLoopInitRewriter.
+ *
+ * Important: Introduces EVM opcodes and thus can only be used on EVM code for now.
+ */
+class ControlFlowSimplifier: public ASTModifier
+{
+public:
+	using ASTModifier::operator();
+	void operator()(Block& _block) override;
+private:
+	void simplify(std::vector<Statement>& _statements);
+};
+
+}

libyul/optimiser/StructuralSimplifier.cpp

@@ -32,39 +32,6 @@ using OptionalStatements = boost::optional<vector<Statement>>;
 
 namespace {
 
-ExpressionStatement makePopExpressionStatement(langutil::SourceLocation const& _location, Expression&& _expression)
-{
-	return {_location, FunctionalInstruction{
-		_location,
-		dev::eth::Instruction::POP,
-		{std::move(_expression)}
-	}};
-}
-
-void removeEmptyDefaultFromSwitch(Switch& _switchStmt)
-{
-	boost::remove_erase_if(
-		_switchStmt.cases,
-		[](Case const& _case) { return !_case.value && _case.body.statements.empty(); }
-	);
-}
-
-void removeEmptyCasesFromSwitch(Switch& _switchStmt)
-{
-	bool hasDefault = boost::algorithm::any_of(
-		_switchStmt.cases,
-		[](Case const& _case) { return !_case.value; }
-	);
-
-	if (hasDefault)
-		return;
-
-	boost::remove_erase_if(
-		_switchStmt.cases,
-		[](Case const& _case) { return _case.body.statements.empty(); }
-	);
-}
-
 OptionalStatements replaceConstArgSwitch(Switch& _switchStmt, u256 const& _constExprVal)
 {
 	Block* matchingCaseBlock = nullptr;
@@ -92,35 +59,6 @@ OptionalStatements replaceConstArgSwitch(Switch& _switchStmt, u256 const& _const
 	return s;
 }
 
-OptionalStatements reduceSingleCaseSwitch(Switch& _switchStmt)
-{
-	yulAssert(_switchStmt.cases.size() == 1, "Expected only one case!");
-
-	auto& switchCase = _switchStmt.cases.front();
-	auto loc = locationOf(*_switchStmt.expression);
-	if (switchCase.value)
-	{
-		OptionalStatements s = vector<Statement>{};
-		s->emplace_back(If{
-				std::move(_switchStmt.location),
-				make_unique<Expression>(FunctionalInstruction{
-					std::move(loc),
-					dev::eth::Instruction::EQ,
-					{std::move(*switchCase.value), std::move(*_switchStmt.expression)}
-				}),
-				std::move(switchCase.body)
-		});
-		return s;
-	}
-	else
-	{
-		OptionalStatements s = vector<Statement>{};
-		s->emplace_back(makePopExpressionStatement(loc, std::move(*_switchStmt.expression)));
-		s->emplace_back(std::move(switchCase.body));
-		return s;
-	}
-}
-
 }
 
 void StructuralSimplifier::operator()(Block& _block)
@@ -130,19 +68,6 @@ void StructuralSimplifier::operator()(Block& _block)
 	popScope();
 }
 
-OptionalStatements StructuralSimplifier::reduceNoCaseSwitch(Switch& _switchStmt) const
-{
-	yulAssert(_switchStmt.cases.empty(), "Expected no case!");
-
-	auto loc = locationOf(*_switchStmt.expression);
-
-	OptionalStatements s = vector<Statement>{};
-
-	s->emplace_back(makePopExpressionStatement(loc, std::move(*_switchStmt.expression)));
-
-	return s;
-}
-
 boost::optional<dev::u256> StructuralSimplifier::hasLiteralValue(Expression const& _expression) const
 {
 	Expression const* expr = &_expression;
@@ -167,12 +92,6 @@ void StructuralSimplifier::simplify(std::vector<yul::Statement>& _statements)
 {
 	GenericFallbackReturnsVisitor<OptionalStatements, If, Switch, ForLoop> const visitor(
 		[&](If& _ifStmt) -> OptionalStatements {
-			if (_ifStmt.body.statements.empty())
-			{
-				OptionalStatements s = vector<Statement>{};
-				s->emplace_back(makePopExpressionStatement(_ifStmt.location, std::move(*_ifStmt.condition)));
-				return s;
-			}
 			if (expressionAlwaysTrue(*_ifStmt.condition))
 				return {std::move(_ifStmt.body.statements)};
 			else if (expressionAlwaysFalse(*_ifStmt.condition))
@@ -182,22 +101,12 @@ void StructuralSimplifier::simplify(std::vector<yul::Statement>& _statements)
 		[&](Switch& _switchStmt) -> OptionalStatements {
 			if (boost::optional<u256> const constExprVal = hasLiteralValue(*_switchStmt.expression))
 				return replaceConstArgSwitch(_switchStmt, constExprVal.get());
-
-			removeEmptyDefaultFromSwitch(_switchStmt);
-			removeEmptyCasesFromSwitch(_switchStmt);
-
-			if (_switchStmt.cases.empty())
-				return reduceNoCaseSwitch(_switchStmt);
-			else if (_switchStmt.cases.size() == 1)
-				return reduceSingleCaseSwitch(_switchStmt);
-
 			return {};
 		},
 		[&](ForLoop& _forLoop) -> OptionalStatements {
 			if (expressionAlwaysFalse(*_forLoop.condition))
 				return {std::move(_forLoop.pre.statements)};
-			else
-				return {};
+			return {};
 		}
 	);
 

libyul/optimiser/StructuralSimplifier.h

@@ -25,14 +25,8 @@ namespace yul
 
 /**
  * Structural simplifier. Performs the following simplification steps:
- * - replace if with empty body with pop(condition)
  * - replace if with true condition with its body
  * - remove if with false condition
- * - remove empty default switch case
- * - remove empty switch case if no default case exists
- * - replace switch with no cases with pop(expression)
- * - turn switch with single case into if
- * - replace switch with only default case with pop(expression) and body
  * - replace switch with const expr with matching case body
  * - replace for with false condition by its initialization part
  *
@@ -52,7 +46,6 @@ private:
 	bool expressionAlwaysTrue(Expression const& _expression);
 	bool expressionAlwaysFalse(Expression const& _expression);
 	boost::optional<dev::u256> hasLiteralValue(Expression const& _expression) const;
-	boost::optional<std::vector<Statement>> reduceNoCaseSwitch(Switch& _switchStmt) const;
 };
 
 }

libyul/optimiser/Suite.cpp

@@ -23,6 +23,7 @@
 #include <libyul/optimiser/Disambiguator.h>
 #include <libyul/optimiser/VarDeclInitializer.h>
 #include <libyul/optimiser/BlockFlattener.h>
+#include <libyul/optimiser/ControlFlowSimplifier.h>
 #include <libyul/optimiser/DeadCodeEliminator.h>
 #include <libyul/optimiser/FunctionGrouper.h>
 #include <libyul/optimiser/FunctionHoister.h>
@@ -77,7 +78,9 @@ void OptimiserSuite::run(
 	EquivalentFunctionCombiner::run(ast);
 	UnusedPruner::runUntilStabilised(*_dialect, ast, reservedIdentifiers);
 	BlockFlattener{}(ast);
+	ControlFlowSimplifier{}(ast);
 	StructuralSimplifier{*_dialect}(ast);
+	ControlFlowSimplifier{}(ast);
 	BlockFlattener{}(ast);
 
 	// None of the above can make stack problems worse.
@@ -107,7 +110,9 @@ void OptimiserSuite::run(
 
 		{
 			// still in SSA, perform structural simplification
+			ControlFlowSimplifier{}(ast);
 			StructuralSimplifier{*_dialect}(ast);
+			ControlFlowSimplifier{}(ast);
 			BlockFlattener{}(ast);
 			DeadCodeEliminator{}(ast);
 			UnusedPruner::runUntilStabilised(*_dialect, ast, reservedIdentifiers);
@@ -162,6 +167,7 @@ void OptimiserSuite::run(
 			StructuralSimplifier{*_dialect}(ast);
 			BlockFlattener{}(ast);
 			DeadCodeEliminator{}(ast);
+			ControlFlowSimplifier{}(ast);
 			CommonSubexpressionEliminator{*_dialect}(ast);
 			SSATransform::run(ast, dispenser);
 			RedundantAssignEliminator::run(*_dialect, ast);
@@ -197,6 +203,7 @@ void OptimiserSuite::run(
 	StackCompressor::run(_dialect, ast, _optimizeStackAllocation, stackCompressorMaxIterations);
 	BlockFlattener{}(ast);
 	DeadCodeEliminator{}(ast);
+	ControlFlowSimplifier{}(ast);
 
 	FunctionGrouper{}(ast);
 	VarNameCleaner{ast, *_dialect, reservedIdentifiers}(ast);

test/libyul/YulOptimizerTest.cpp

@@ -22,6 +22,7 @@
 #include <libyul/optimiser/BlockFlattener.h>
 #include <libyul/optimiser/VarDeclInitializer.h>
 #include <libyul/optimiser/VarNameCleaner.h>
+#include <libyul/optimiser/ControlFlowSimplifier.h>
 #include <libyul/optimiser/DeadCodeEliminator.h>
 #include <libyul/optimiser/Disambiguator.h>
 #include <libyul/optimiser/CommonSubexpressionEliminator.h>
@@ -233,6 +234,7 @@ TestCase::TestResult YulOptimizerTest::run(ostream& _stream, string const& _line
 	else if (m_optimizerStep == "structuralSimplifier")
 	{
 		disambiguate();
+		ControlFlowSimplifier{}(*m_ast);
 		StructuralSimplifier{*m_dialect}(*m_ast);
 	}
 	else if (m_optimizerStep == "equivalentFunctionCombiner")