Improve SSAValueTracker. Fix the bug.

Author: rodiazet

libyul/optimiser/SSAValueTracker.cpp

@@ -22,6 +22,8 @@
 
 #include <libyul/optimiser/SSAValueTracker.h>
 
+#include <liblangutil/Exceptions.h>
+
 #include <libyul/AST.h>
 
 using namespace solidity;
@@ -31,10 +33,20 @@ void SSAValueTracker::operator()(Assignment const& _assignment)
 {
 	for (auto const& var: _assignment.variableNames)
 		m_values.erase(var.name);
+
+	for (auto const& var: _assignment.variableNames)
+		m_functionParameters.erase(var.name);
 }
 
 void SSAValueTracker::operator()(FunctionDefinition const& _funDef)
 {
+	solAssert(m_functionParameters.find(_funDef.name) == m_functionParameters.end(),
+		"SSAValueTracker requires Disambiguator to run first"
+	);
+
+	for (auto const& param: _funDef.parameters)
+		m_functionParameters.insert(param.name);
+
 	for (auto const& var: _funDef.returnVariables)
 		setValue(var.name, nullptr);
 	ASTWalker::operator()(_funDef);
@@ -49,6 +61,36 @@ void SSAValueTracker::operator()(VariableDeclaration const& _varDecl)
 		setValue(_varDecl.variables.front().name, _varDecl.value.get());
 }
 
+bool SSAValueTracker::isSSAWithDependencies(Expression const* _expression) const
+{
+	if (_expression == nullptr)
+		return true;
+
+	if (auto const* functionCall = std::get_if<FunctionCall>(_expression))
+	{
+		for (auto const& argument: functionCall->arguments)
+			if (!isSSAWithDependencies(&argument))
+				return false;
+
+		return true;
+	}
+	else if (auto const* identifier = std::get_if<Identifier>(_expression))
+	{
+		if (m_functionParameters.count(identifier->name))
+			return true;
+
+		auto const it = m_values.find(identifier->name);
+		if (it == m_values.end())
+			return false;
+		return isSSAWithDependencies(&(*it->second));
+	}
+	else
+	{
+		solAssert(std::holds_alternative<Literal>(*_expression), "Impossible expression type");
+		return true;
+	}
+}
+
 std::set<YulName> SSAValueTracker::ssaVariables(Block const& _ast)
 {
 	SSAValueTracker t;

libyul/optimiser/SSAValueTracker.h

@@ -52,13 +52,18 @@ class SSAValueTracker: public ASTWalker
 
 	static std::set<YulName> ssaVariables(Block const& _ast);
 
+	/// Determines whether the given expression and all of its identifier
+	/// dependencies are in Static Single Assignment (SSA) form.
+	bool isSSAWithDependencies(Expression const* _expression) const;
+
 private:
 	void setValue(YulName _name, Expression const* _value);
 
 	/// Special expression whose address will be used in m_values.
 	/// YulName does not need to be reset because SSAValueTracker is short-lived.
 	Expression const m_zero{Literal{{}, LiteralKind::Number, LiteralValue(u256{0})}};
 	std::map<YulName, Expression const*> m_values;
+	std::set<YulName> m_functionParameters;
 };
 
 }

libyul/optimiser/UnusedStoreEliminator.cpp

@@ -55,7 +55,8 @@ void UnusedStoreEliminator::run(OptimiserStepContext& _context, Block& _ast)
 	ssaValues(_ast);
 	std::map<YulName, AssignedValue> values;
 	for (auto const& [name, expression]: ssaValues.values())
-		values[name] = AssignedValue{expression, {}};
+		if (ssaValues.isSSAWithDependencies(expression))
+			values[name] = AssignedValue{expression, {}};
 
 	bool const ignoreMemory = MSizeFinder::containsMSize(_context.dialect, _ast);
 	UnusedStoreEliminator rse{