Refactor RedundantAssignEliminator.

Author: chriseth

libsolutil/CommonData.h

@@ -295,6 +295,31 @@ decltype(auto) mapTuple(Callable&& _callable)
 	return detail::MapTuple<Callable>{std::forward<Callable>(_callable)};
 }
 
+/// Merges map @a _b into map @a _a. If the same key exists in both maps,
+/// calls @a _conflictSolver to combine the two values.
+template <class K, class V, class F>
+void joinMap(std::map<K, V>& _a, std::map<K, V>&& _b, F _conflictSolver)
+{
+	auto ita = _a.begin();
+	auto aend = _a.end();
+	auto itb = _b.begin();
+	auto bend = _b.end();
+
+	for (; itb != bend; ++ita)
+	{
+		if (ita == aend)
+			ita = _a.insert(ita, std::move(*itb++));
+		else if (ita->first < itb->first)
+			continue;
+		else if (itb->first < ita->first)
+			ita = _a.insert(ita, std::move(*itb++));
+		else
+		{
+			_conflictSolver(ita->second, std::move(itb->second));
+			++itb;
+		}
+	}
+}
 
 // String conversion functions, mainly to/from hex/nibble/byte representations.
 

libyul/CMakeLists.txt

@@ -167,6 +167,8 @@ add_library(yul
 	optimiser/ReasoningBasedSimplifier.h
 	optimiser/RedundantAssignEliminator.cpp
 	optimiser/RedundantAssignEliminator.h
+	optimiser/RedundantStoreBase.cpp
+	optimiser/RedundantStoreBase.h
 	optimiser/Rematerialiser.cpp
 	optimiser/Rematerialiser.h
 	optimiser/SMTSolver.cpp

libyul/optimiser/RedundantAssignEliminator.cpp

@@ -38,7 +38,7 @@ void RedundantAssignEliminator::run(OptimiserStepContext& _context, Block& _ast)
 	RedundantAssignEliminator rae{_context.dialect};
 	rae(_ast);
 
-	AssignmentRemover remover{rae.m_pendingRemovals};
+	StatementRemover remover{rae.m_pendingRemovals};
 	remover(_ast);
 }
 
@@ -49,7 +49,7 @@ void RedundantAssignEliminator::operator()(Identifier const& _identifier)
 
 void RedundantAssignEliminator::operator()(VariableDeclaration const& _variableDeclaration)
 {
-	ASTWalker::operator()(_variableDeclaration);
+	RedundantStoreBase::operator()(_variableDeclaration);
 
 	for (auto const& var: _variableDeclaration.variables)
 		m_declaredVariables.emplace(var.name);
@@ -60,151 +60,17 @@ void RedundantAssignEliminator::operator()(Assignment const& _assignment)
 	visit(*_assignment.value);
 	for (auto const& var: _assignment.variableNames)
 		changeUndecidedTo(var.name, State::Unused);
-
-	if (_assignment.variableNames.size() == 1)
-		// Default-construct it in "Undecided" state if it does not yet exist.
-		m_assignments[_assignment.variableNames.front().name][&_assignment];
-}
-
-void RedundantAssignEliminator::operator()(If const& _if)
-{
-	visit(*_if.condition);
-
-	TrackedAssignments skipBranch{m_assignments};
-	(*this)(_if.body);
-
-	merge(m_assignments, move(skipBranch));
-}
-
-void RedundantAssignEliminator::operator()(Switch const& _switch)
-{
-	visit(*_switch.expression);
-
-	TrackedAssignments const preState{m_assignments};
-
-	bool hasDefault = false;
-	vector<TrackedAssignments> branches;
-	for (auto const& c: _switch.cases)
-	{
-		if (!c.value)
-			hasDefault = true;
-		(*this)(c.body);
-		branches.emplace_back(move(m_assignments));
-		m_assignments = preState;
-	}
-
-	if (hasDefault)
-	{
-		m_assignments = move(branches.back());
-		branches.pop_back();
-	}
-	for (auto& branch: branches)
-		merge(m_assignments, move(branch));
 }
 
 void RedundantAssignEliminator::operator()(FunctionDefinition const& _functionDefinition)
 {
-	std::set<YulString> outerDeclaredVariables;
-	std::set<YulString> outerReturnVariables;
-	TrackedAssignments outerAssignments;
-	ForLoopInfo forLoopInfo;
-	swap(m_declaredVariables, outerDeclaredVariables);
-	swap(m_returnVariables, outerReturnVariables);
-	swap(m_assignments, outerAssignments);
-	swap(m_forLoopInfo, forLoopInfo);
+	ScopedSaveAndRestore outerDeclaredVariables(m_declaredVariables, {});
+	ScopedSaveAndRestore outerReturnVariables(m_returnVariables, {});
 
 	for (auto const& retParam: _functionDefinition.returnVariables)
 		m_returnVariables.insert(retParam.name);
 
-	(*this)(_functionDefinition.body);
-
-	for (auto const& param: _functionDefinition.parameters)
-		finalize(param.name, State::Unused);
-	for (auto const& retParam: _functionDefinition.returnVariables)
-		finalize(retParam.name, State::Used);
-
-	swap(m_declaredVariables, outerDeclaredVariables);
-	swap(m_returnVariables, outerReturnVariables);
-	swap(m_assignments, outerAssignments);
-	swap(m_forLoopInfo, forLoopInfo);
-}
-
-void RedundantAssignEliminator::operator()(ForLoop const& _forLoop)
-{
-	ForLoopInfo outerForLoopInfo;
-	swap(outerForLoopInfo, m_forLoopInfo);
-	++m_forLoopNestingDepth;
-
-	// If the pre block was not empty,
-	// we would have to deal with more complicated scoping rules.
-	assertThrow(_forLoop.pre.statements.empty(), OptimizerException, "");
-
-	// We just run the loop twice to account for the back edge.
-	// There need not be more runs because we only have three different states.
-
-	visit(*_forLoop.condition);
-
-	TrackedAssignments zeroRuns{m_assignments};
-
-	(*this)(_forLoop.body);
-	merge(m_assignments, move(m_forLoopInfo.pendingContinueStmts));
-	m_forLoopInfo.pendingContinueStmts = {};
-	(*this)(_forLoop.post);
-
-	visit(*_forLoop.condition);
-
-	if (m_forLoopNestingDepth < 6)
-	{
-		// Do the second run only for small nesting depths to avoid horrible runtime.
-		TrackedAssignments oneRun{m_assignments};
-
-		(*this)(_forLoop.body);
-
-		merge(m_assignments, move(m_forLoopInfo.pendingContinueStmts));
-		m_forLoopInfo.pendingContinueStmts.clear();
-		(*this)(_forLoop.post);
-
-		visit(*_forLoop.condition);
-		// Order of merging does not matter because "max" is commutative and associative.
-		merge(m_assignments, move(oneRun));
-	}
-	else
-	{
-		// Shortcut to avoid horrible runtime:
-		// Change all assignments that were newly introduced in the for loop to "used".
-		// We do not have to do that with the "break" or "continue" paths, because
-		// they will be joined later anyway.
-		// TODO parallel traversal might be more efficient here.
-		for (auto& var: m_assignments)
-			for (auto& assignment: var.second)
-			{
-				auto zeroIt = zeroRuns.find(var.first);
-				if (zeroIt != zeroRuns.end() && zeroIt->second.count(assignment.first))
-					continue;
-				assignment.second = State::Value::Used;
-			}
-	}
-
-	// Order of merging does not matter because "max" is commutative and associative.
-	merge(m_assignments, move(zeroRuns));
-	merge(m_assignments, move(m_forLoopInfo.pendingBreakStmts));
-	m_forLoopInfo.pendingBreakStmts.clear();
-
-	// Restore potential outer for-loop states.
-	swap(m_forLoopInfo, outerForLoopInfo);
-	--m_forLoopNestingDepth;
-}
-
-void RedundantAssignEliminator::operator()(Break const&)
-{
-	m_forLoopInfo.pendingBreakStmts.emplace_back(move(m_assignments));
-	m_assignments.clear();
-}
-
-void RedundantAssignEliminator::operator()(Continue const&)
-{
-	m_forLoopInfo.pendingContinueStmts.emplace_back(move(m_assignments));
-	m_assignments.clear();
+	RedundantStoreBase::operator()(_functionDefinition);
 }
 
 void RedundantAssignEliminator::operator()(Leave const&)
@@ -215,101 +81,76 @@ void RedundantAssignEliminator::operator()(Leave const&)
 
 void RedundantAssignEliminator::operator()(Block const& _block)
 {
-	set<YulString> outerDeclaredVariables;
-	swap(m_declaredVariables, outerDeclaredVariables);
+	ScopedSaveAndRestore outerDeclaredVariables(m_declaredVariables, {});
 
-	ASTWalker::operator()(_block);
+	RedundantStoreBase::operator()(_block);
 
 	for (auto const& var: m_declaredVariables)
 		finalize(var, State::Unused);
-
-	swap(m_declaredVariables, outerDeclaredVariables);
 }
 
-
-template <class K, class V, class F>
-void joinMap(std::map<K, V>& _a, std::map<K, V>&& _b, F _conflictSolver)
+void RedundantAssignEliminator::visit(Statement const& _statement)
 {
-	// TODO Perhaps it is better to just create a sorted list
-	// and then use insert(begin, end)
+	RedundantStoreBase::visit(_statement);
 
-	auto ita = _a.begin();
-	auto aend = _a.end();
-	auto itb = _b.begin();
-	auto bend = _b.end();
-
-	for (; itb != bend; ++ita)
-	{
-		if (ita == aend)
-			ita = _a.insert(ita, std::move(*itb++));
-		else if (ita->first < itb->first)
-			continue;
-		else if (itb->first < ita->first)
-			ita = _a.insert(ita, std::move(*itb++));
-		else
-		{
-			_conflictSolver(ita->second, std::move(itb->second));
-			++itb;
-		}
-	}
+	if (auto const* assignment = get_if<Assignment>(&_statement))
+		if (assignment->variableNames.size() == 1)
+			// Default-construct it in "Undecided" state if it does not yet exist.
+			m_stores[assignment->variableNames.front().name][&_statement];
 }
 
-void RedundantAssignEliminator::merge(TrackedAssignments& _target, TrackedAssignments&& _other)
+void RedundantAssignEliminator::shortcutNestedLoop(TrackedStores const& _zeroRuns)
 {
-	joinMap(_target, move(_other), [](
-		map<Assignment const*, State>& _assignmentHere,
-		map<Assignment const*, State>&& _assignmentThere
-	)
-	{
-		return joinMap(_assignmentHere, move(_assignmentThere), State::join);
-	});
+	// Shortcut to avoid horrible runtime:
+	// Change all assignments that were newly introduced in the for loop to "used".
+	// We do not have to do that with the "break" or "continue" paths, because
+	// they will be joined later anyway.
+	// TODO parallel traversal might be more efficient here.
+	for (auto& [variable, stores]: m_stores)
+		for (auto& assignment: stores)
+		{
+			auto zeroIt = _zeroRuns.find(variable);
+			if (zeroIt != _zeroRuns.end() && zeroIt->second.count(assignment.first))
+				continue;
+			assignment.second = State::Value::Used;
+		}
 }
 
-void RedundantAssignEliminator::merge(TrackedAssignments& _target, vector<TrackedAssignments>&& _source)
+void RedundantAssignEliminator::finalizeFunctionDefinition(FunctionDefinition const& _functionDefinition)
 {
-	for (TrackedAssignments& ts: _source)
-		merge(_target, move(ts));
-	_source.clear();
+	for (auto const& param: _functionDefinition.parameters)
+		finalize(param.name, State::Unused);
+	for (auto const& retParam: _functionDefinition.returnVariables)
+		finalize(retParam.name, State::Used);
 }
 
 void RedundantAssignEliminator::changeUndecidedTo(YulString _variable, RedundantAssignEliminator::State _newState)
 {
-	for (auto& assignment: m_assignments[_variable])
+	for (auto& assignment: m_stores[_variable])
 		if (assignment.second == State::Undecided)
 			assignment.second = _newState;
 }
 
 void RedundantAssignEliminator::finalize(YulString _variable, RedundantAssignEliminator::State _finalState)
 {
-	std::map<Assignment const*, State> assignments;
-	joinMap(assignments, std::move(m_assignments[_variable]), State::join);
-	m_assignments.erase(_variable);
+	std::map<Statement const*, State> stores = std::move(m_stores[_variable]);
+	m_stores.erase(_variable);
 
 	for (auto& breakAssignments: m_forLoopInfo.pendingBreakStmts)
 	{
-		joinMap(assignments, std::move(breakAssignments[_variable]), State::join);
+		util::joinMap(stores, std::move(breakAssignments[_variable]), State::join);
 		breakAssignments.erase(_variable);
 	}
 	for (auto& continueAssignments: m_forLoopInfo.pendingContinueStmts)
 	{
-		joinMap(assignments, std::move(continueAssignments[_variable]), State::join);
+		util::joinMap(stores, std::move(continueAssignments[_variable]), State::join);
 		continueAssignments.erase(_variable);
 	}
 
-	for (auto const& assignment: assignments)
-	{
-		State const state = assignment.second == State::Undecided ? _finalState : assignment.second;
-
-		if (state == State::Unused && SideEffectsCollector{*m_dialect, *assignment.first->value}.movable())
-			m_pendingRemovals.insert(assignment.first);
-	}
-}
-
-void AssignmentRemover::operator()(Block& _block)
-{
-	ranges::actions::remove_if(_block.statements, [&](Statement const& _statement) -> bool {
-		return holds_alternative<Assignment>(_statement) && m_toRemove.count(&std::get<Assignment>(_statement));
-	});
-
-	ASTModifier::operator()(_block);
+	for (auto&& [statement, state]: stores)
+		if (
+			(state == State::Unused || (state == State::Undecided && _finalState == State::Unused)) &&
+			SideEffectsCollector{m_dialect, *std::get<Assignment>(*statement).value}.movable()
+		)
+			m_pendingRemovals.insert(statement);
 }