Yul Optimizer: Remove dead code

libyul/optimiser/DeadCodeEliminator.cpp

@@ -0,0 +1,94 @@
+/*
+	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/>.
+*/
+/**
+ * Optimisation stage that removes unreachable code.
+ */
+
+#include <libyul/optimiser/DeadCodeEliminator.h>
+#include <libyul/AsmData.h>
+
+#include <libevmasm/SemanticInformation.h>
+#include <libevmasm/AssemblyItem.h>
+
+#include <algorithm>
+
+using namespace std;
+using namespace dev;
+using namespace yul;
+
+namespace
+{
+bool isTerminating(yul::ExpressionStatement const& _exprStmnt)
+{
+	if (_exprStmnt.expression.type() != typeid(FunctionalInstruction))
+		return false;
+
+	auto const& funcInstr = boost::get<FunctionalInstruction>(_exprStmnt.expression);
+
+	return eth::SemanticInformation::terminatesControlFlow(funcInstr.instruction);
+}
+
+/// Returns an iterator to the first terminating statement or
+/// `_block.statements.end()()` when none was found
+auto findFirstTerminatingStatement(Block& _block)
+{
+	return find_if(
+		_block.statements.begin(),
+		_block.statements.end(),
+		[](Statement const& _stmnt)
+		{
+			if (
+				_stmnt.type() == typeid(ExpressionStatement) &&
+				isTerminating(boost::get<ExpressionStatement>(_stmnt))
+			)
+				return true;
+			else if (_stmnt.type() == typeid(Break))
+				return true;
+			else if (_stmnt.type() == typeid(Continue))
+				return true;
+
+			return false;
+		}
+	);
+}
+}
+
+void DeadCodeEliminator::operator()(Block& _block)
+{
+	auto& statements = _block.statements;
+
+	auto firstTerminatingStatment = findFirstTerminatingStatement(_block);
+
+	if (
+		firstTerminatingStatment != statements.end() &&
+		firstTerminatingStatment + 1 != statements.end()
+	)
+		statements.erase(
+			std::remove_if(
+				firstTerminatingStatment + 1,
+				statements.end(),
+				[] (Statement const& _s)
+				{
+					return _s.type() != typeid(yul::FunctionDefinition);
+				}
+			),
+			statements.end()
+		);
+
+	ASTModifier::operator()(_block);
+}
+

libyul/optimiser/DeadCodeEliminator.h

@@ -0,0 +1,49 @@
+/*
+	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/>.
+*/
+/**
+ * Optimisation stage that removes unused variables and functions.
+ */
+
+#pragma once
+
+#include <libyul/optimiser/ASTWalker.h>
+#include <libyul/YulString.h>
+
+#include <map>
+#include <set>
+
+namespace yul
+{
+
+/**
+ * Optimisation stage that removes unreachable code
+ *
+ * Unreachable code is any code within a block which is preceded by a
+ * return, invalid, break, continue, selfdestruct or revert.
+ *
+ * Function definitions are retained as they might be called by earlier
+ * code and thus are considered reachable.
+ *
+ */
+class DeadCodeEliminator: public ASTModifier
+{
+public:
+	using ASTModifier::operator();
+	void operator()(Block& _block) override;
+};
+
+}

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/DeadCodeEliminator.h>
 #include <libyul/optimiser/FunctionGrouper.h>
 #include <libyul/optimiser/FunctionHoister.h>
 #include <libyul/optimiser/EquivalentFunctionCombiner.h>
@@ -70,6 +71,7 @@ void OptimiserSuite::run(
 	VarDeclInitializer{}(ast);
 	FunctionHoister{}(ast);
 	BlockFlattener{}(ast);
+	DeadCodeEliminator{}(ast);
 	FunctionGrouper{}(ast);
 	EquivalentFunctionCombiner::run(ast);
 	UnusedPruner::runUntilStabilised(*_dialect, ast, reservedIdentifiers);
@@ -107,6 +109,7 @@ void OptimiserSuite::run(
 			// still in SSA, perform structural simplification
 			StructuralSimplifier{*_dialect}(ast);
 			BlockFlattener{}(ast);
+			DeadCodeEliminator{}(ast);
 			UnusedPruner::runUntilStabilised(*_dialect, ast, reservedIdentifiers);
 		}
 		{
@@ -158,6 +161,7 @@ void OptimiserSuite::run(
 			ExpressionSimplifier::run(*_dialect, ast);
 			StructuralSimplifier{*_dialect}(ast);
 			BlockFlattener{}(ast);
+			DeadCodeEliminator{}(ast);
 			CommonSubexpressionEliminator{*_dialect}(ast);
 			SSATransform::run(ast, dispenser);
 			RedundantAssignEliminator::run(*_dialect, ast);
@@ -192,6 +196,7 @@ void OptimiserSuite::run(
 	// message once we perform code generation.
 	StackCompressor::run(_dialect, ast, _optimizeStackAllocation, stackCompressorMaxIterations);
 	BlockFlattener{}(ast);
+	DeadCodeEliminator{}(ast);
 
 	VarNameCleaner{ast, *_dialect, reservedIdentifiers}(ast);
 	yul::AsmAnalyzer::analyzeStrictAssertCorrect(_dialect, ast);