Merge pull request #8267 from ghallak/prune-unnecessary-funcs

[Yul] Prune functions that call each other but are otherwise unreferenced

libyul/optimiser/CircularReferencesPruner.cpp

@@ -0,0 +1,61 @@
+/*
+	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/CircularReferencesPruner.h>
+
+#include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/optimiser/OptimizerUtilities.h>
+#include <libyul/AsmData.h>
+
+#include <libsolutil/Algorithms.h>
+
+using namespace std;
+using namespace solidity::yul;
+
+void CircularReferencesPruner::run(OptimiserStepContext& _context, Block& _ast)
+{
+	CircularReferencesPruner{_context.reservedIdentifiers}(_ast);
+}
+
+void CircularReferencesPruner::operator()(Block& _block)
+{
+	set<YulString> functionsToKeep =
+		functionsCalledFromOutermostContext(CallGraphGenerator::callGraph(_block));
+
+	for (auto&& statement: _block.statements)
+		if (holds_alternative<FunctionDefinition>(statement))
+		{
+			FunctionDefinition const& funDef = std::get<FunctionDefinition>(statement);
+			if (!functionsToKeep.count(funDef.name))
+				statement = Block{};
+		}
+
+	removeEmptyBlocks(_block);
+}
+
+set<YulString> CircularReferencesPruner::functionsCalledFromOutermostContext(CallGraph const& _callGraph)
+{
+	set<YulString> verticesToTraverse = m_reservedIdentifiers;
+	verticesToTraverse.insert(YulString(""));
+
+	return util::BreadthFirstSearch<YulString>{{verticesToTraverse.begin(), verticesToTraverse.end()}}.run(
+		[&_callGraph](YulString _function, auto&& _addChild) {
+			if (_callGraph.functionCalls.count(_function))
+				for (auto const& callee: _callGraph.functionCalls.at(_function))
+					if (_callGraph.functionCalls.count(callee))
+						_addChild(callee);
+		}).visited;
+}

libyul/optimiser/CircularReferencesPruner.h

@@ -0,0 +1,58 @@
+/*
+	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/>.
+*/
+/**
+ * Optimization stage that removes functions that call each other but are
+ * otherwise unreferenced.
+ *
+ *  Prerequisites: Disambiguator, FunctionHoister.
+ */
+
+#pragma once
+
+#include <libyul/optimiser/ASTWalker.h>
+#include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/optimiser/OptimiserStep.h>
+
+namespace solidity::yul
+{
+
+/**
+ * Optimization stage that removes functions that call each other but are
+ * neither externally referenced nor referenced from the outermost context.
+ */
+class CircularReferencesPruner: public ASTModifier
+{
+public:
+	static constexpr char const* name{"CircularReferencesPruner"};
+	static void run(OptimiserStepContext& _context, Block& _ast);
+
+	using ASTModifier::operator();
+	void operator()(Block& _block) override;
+private:
+	CircularReferencesPruner(std::set<YulString> const& _reservedIdentifiers):
+		m_reservedIdentifiers(_reservedIdentifiers)
+	{}
+
+	/// Run a breadth-first search starting from the outermost context and
+	/// externally referenced functions to find all the functions that are
+	/// called from there either directly or indirectly.
+	std::set<YulString> functionsCalledFromOutermostContext(CallGraph const& _callGraph);
+
+	std::set<YulString> const& m_reservedIdentifiers;
+};
+
+}

libyul/optimiser/Suite.cpp

@@ -24,6 +24,7 @@
 #include <libyul/optimiser/VarDeclInitializer.h>
 #include <libyul/optimiser/BlockFlattener.h>
 #include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/optimiser/CircularReferencesPruner.h>
 #include <libyul/optimiser/ControlFlowSimplifier.h>
 #include <libyul/optimiser/ConditionalSimplifier.h>
 #include <libyul/optimiser/ConditionalUnsimplifier.h>
@@ -99,6 +100,7 @@ void OptimiserSuite::run(
 		FunctionGrouper::name,
 		EquivalentFunctionCombiner::name,
 		UnusedPruner::name,
+		CircularReferencesPruner::name,
 		BlockFlattener::name,
 		ControlFlowSimplifier::name,
 		LiteralRematerialiser::name,
@@ -151,7 +153,8 @@ void OptimiserSuite::run(
 				BlockFlattener::name,
 				DeadCodeEliminator::name,
 				ForLoopConditionIntoBody::name,
-				UnusedPruner::name
+				UnusedPruner::name,
+				CircularReferencesPruner::name
 			}, ast);
 		}
 
@@ -161,6 +164,7 @@ void OptimiserSuite::run(
 				LoadResolver::name,
 				CommonSubexpressionEliminator::name,
 				UnusedPruner::name,
+				CircularReferencesPruner::name,
 			}, ast);
 		}
 
@@ -170,6 +174,7 @@ void OptimiserSuite::run(
 				SSAReverser::name,
 				CommonSubexpressionEliminator::name,
 				UnusedPruner::name,
+				CircularReferencesPruner::name,
 
 				ExpressionJoiner::name,
 				ExpressionJoiner::name,
@@ -183,6 +188,7 @@ void OptimiserSuite::run(
 			suite.runSequence({
 				ExpressionInliner::name,
 				UnusedPruner::name,
+				CircularReferencesPruner::name,
 			}, ast);
 		}
 
@@ -193,8 +199,10 @@ void OptimiserSuite::run(
 				SSATransform::name,
 				RedundantAssignEliminator::name,
 				UnusedPruner::name,
+				CircularReferencesPruner::name,
 				RedundantAssignEliminator::name,
 				UnusedPruner::name,
+				CircularReferencesPruner::name,
 			}, ast);
 		}
 
@@ -244,6 +252,7 @@ void OptimiserSuite::run(
 				RedundantAssignEliminator::name,
 				ForLoopConditionIntoBody::name,
 				UnusedPruner::name,
+				CircularReferencesPruner::name,
 				CommonSubexpressionEliminator::name,
 			}, ast);
 		}
@@ -255,10 +264,13 @@ void OptimiserSuite::run(
 		ExpressionJoiner::name,
 		Rematerialiser::name,
 		UnusedPruner::name,
+		CircularReferencesPruner::name,
 		ExpressionJoiner::name,
 		UnusedPruner::name,
+		CircularReferencesPruner::name,
 		ExpressionJoiner::name,
 		UnusedPruner::name,
+		CircularReferencesPruner::name,
 
 		SSAReverser::name,
 		CommonSubexpressionEliminator::name,
@@ -266,10 +278,12 @@ void OptimiserSuite::run(
 		ForLoopConditionOutOfBody::name,
 		CommonSubexpressionEliminator::name,
 		UnusedPruner::name,
+		CircularReferencesPruner::name,
 
 		ExpressionJoiner::name,
 		Rematerialiser::name,
 		UnusedPruner::name,
+		CircularReferencesPruner::name,
 	}, ast);
 
 	// This is a tuning parameter, but actually just prevents infinite loops.
@@ -339,6 +353,7 @@ map<string, unique_ptr<OptimiserStep>> const& OptimiserSuite::allSteps()
 	if (instance.empty())
 		instance = optimiserStepCollection<
 			BlockFlattener,
+			CircularReferencesPruner,
 			CommonSubexpressionEliminator,
 			ConditionalSimplifier,
 			ConditionalUnsimplifier,
@@ -374,6 +389,7 @@ map<string, char> const& OptimiserSuite::stepNameToAbbreviationMap()
 {
 	static map<string, char> lookupTable{
 		{BlockFlattener::name,                'f'},
+		{CircularReferencesPruner::name,      'l'},
 		{CommonSubexpressionEliminator::name, 'c'},
 		{ConditionalSimplifier::name,         'C'},
 		{ConditionalUnsimplifier::name,       'U'},