Refactor data flow analyzer state access.

chriseth · chriseth · commit eab4ca906c2b · 2022-03-14T19:32:33.000+01:00
diff --git a/libyul/optimiser/CommonSubexpressionEliminator.cpp b/libyul/optimiser/CommonSubexpressionEliminator.cpp
@@ -95,18 +95,18 @@ void CommonSubexpressionEliminator::visit(Expression& _e)
 	if (Identifier const* identifier = get_if<Identifier>(&_e))
 	{
 		YulString identifierName = identifier->name;
-		if (m_value.count(identifierName))
+		if (AssignedValue const* assignedValue = variableValue(identifierName))
 		{
-			assertThrow(m_value.at(identifierName).value, OptimizerException, "");
-			if (Identifier const* value = get_if<Identifier>(m_value.at(identifierName).value))
+			assertThrow(assignedValue->value, OptimizerException, "");
+			if (Identifier const* value = get_if<Identifier>(assignedValue->value))
 				if (inScope(value->name))
 					_e = Identifier{debugDataOf(_e), value->name};
 		}
 	}
 	else
 	{
 		// TODO this search is rather inefficient.
-		for (auto const& [variable, value]: m_value)
+		for (auto const& [variable, value]: allValues())
 		{
 			assertThrow(value.value, OptimizerException, "");
 			// Prevent using the default value of return variables
diff --git a/libyul/optimiser/DataFlowAnalyzer.cpp b/libyul/optimiser/DataFlowAnalyzer.cpp
@@ -24,6 +24,7 @@
 
 #include <libyul/optimiser/NameCollector.h>
 #include <libyul/optimiser/Semantics.h>
+#include <libyul/optimiser/KnowledgeBase.h>
 #include <libyul/AST.h>
 #include <libyul/Dialect.h>
 #include <libyul/Exceptions.h>
@@ -47,7 +48,7 @@ DataFlowAnalyzer::DataFlowAnalyzer(
 ):
 	m_dialect(_dialect),
 	m_functionSideEffects(std::move(_functionSideEffects)),
-	m_knowledgeBase(_dialect, m_value)
+	m_knowledgeBase(_dialect, [this](YulString _var) { return variableValue(_var); })
 {
 	if (auto const* builtin = _dialect.memoryStoreFunction(YulString{}))
 		m_storeFunctionName[static_cast<unsigned>(StoreLoadLocation::Memory)] = builtin->name;
@@ -218,6 +219,22 @@ void DataFlowAnalyzer::operator()(Block& _block)
 	assertThrow(numScopes == m_variableScopes.size(), OptimizerException, "");
 }
 
+optional<YulString> DataFlowAnalyzer::storageValue(YulString _key) const
+{
+	if (YulString const* value = util::valueOrNullptr(m_storage, _key))
+		return *value;
+	else
+		return nullopt;
+}
+
+optional<YulString> DataFlowAnalyzer::memoryValue(YulString _key) const
+{
+	if (YulString const* value = util::valueOrNullptr(m_memory, _key))
+		return *value;
+	else
+		return nullopt;
+}
+
 void DataFlowAnalyzer::handleAssignment(set<YulString> const& _variables, Expression* _value, bool _isDeclaration)
 {
 	if (!_isDeclaration)
@@ -386,8 +403,8 @@ bool DataFlowAnalyzer::inScope(YulString _variableName) const
 
 optional<u256> DataFlowAnalyzer::valueOfIdentifier(YulString const& _name)
 {
-	if (m_value.count(_name))
-		if (Literal const* literal = get_if<Literal>(m_value.at(_name).value))
+	if (AssignedValue const* value = variableValue(_name))
+		if (Literal const* literal = get_if<Literal>(value->value))
 			return valueOfLiteral(*literal);
 	return nullopt;
 }
@@ -416,3 +433,4 @@ std::optional<YulString> DataFlowAnalyzer::isSimpleLoad(
 				return key->name;
 	return {};
 }
+
diff --git a/libyul/optimiser/DataFlowAnalyzer.h b/libyul/optimiser/DataFlowAnalyzer.h
@@ -29,6 +29,7 @@
 #include <libyul/AST.h> // Needed for m_zero below.
 #include <libyul/SideEffects.h>
 
+#include <libsolutil/Numeric.h>
 #include <libsolutil/Common.h>
 
 #include <map>
@@ -38,6 +39,7 @@ namespace solidity::yul
 {
 struct Dialect;
 struct SideEffects;
+class KnowledgeBase;
 
 /// Value assigned to a variable.
 struct AssignedValue
@@ -98,6 +100,13 @@ class DataFlowAnalyzer: public ASTModifier
 	void operator()(ForLoop&) override;
 	void operator()(Block& _block) override;
 
+	/// @returns the current value of the given variable, if known - always movable.
+	AssignedValue const* variableValue(YulString _variable) const { return util::valueOrNullptr(m_value, _variable); }
+	std::set<YulString> const* references(YulString _variable) const { return util::valueOrNullptr(m_references, _variable); }
+	std::map<YulString, AssignedValue> const& allValues() const { return m_value; }
+	std::optional<YulString> storageValue(YulString _key) const;
+	std::optional<YulString> memoryValue(YulString _key) const;
+
 protected:
 	/// Registers the assignment.
 	void handleAssignment(std::set<YulString> const& _names, Expression* _value, bool _isDeclaration);
diff --git a/libyul/optimiser/EqualStoreEliminator.cpp b/libyul/optimiser/EqualStoreEliminator.cpp
@@ -54,13 +54,13 @@ void EqualStoreEliminator::visit(Statement& _statement)
 	{
 		if (auto vars = isSimpleStore(StoreLoadLocation::Storage, *expression))
 		{
-			if (auto const* currentValue = util::valueOrNullptr(m_storage, vars->first))
+			if (optional<YulString> currentValue = storageValue(vars->first))
 				if (*currentValue == vars->second)
 					m_pendingRemovals.insert(&_statement);
 		}
 		else if (auto vars = isSimpleStore(StoreLoadLocation::Memory, *expression))
 		{
-			if (auto const* currentValue = util::valueOrNullptr(m_memory, vars->first))
+			if (optional<YulString> currentValue = memoryValue(vars->first))
 				if (*currentValue == vars->second)
 					m_pendingRemovals.insert(&_statement);
 		}
diff --git a/libyul/optimiser/ExpressionSimplifier.cpp b/libyul/optimiser/ExpressionSimplifier.cpp
@@ -38,6 +38,10 @@ void ExpressionSimplifier::visit(Expression& _expression)
 {
 	ASTModifier::visit(_expression);
 
-	while (auto const* match = SimplificationRules::findFirstMatch(_expression, m_dialect, m_value))
+	while (auto const* match = SimplificationRules::findFirstMatch(
+		_expression,
+		m_dialect,
+		[this](YulString _var) { return variableValue(_var); }
+	))
 		_expression = match->action().toExpression(debugDataOf(_expression));
 }
diff --git a/libyul/optimiser/KnowledgeBase.cpp b/libyul/optimiser/KnowledgeBase.cpp
@@ -80,8 +80,8 @@ bool KnowledgeBase::knownToBeZero(YulString _a)
 
 optional<u256> KnowledgeBase::valueIfKnownConstant(YulString _a)
 {
-	if (m_variableValues.count(_a))
-		if (Literal const* literal = get_if<Literal>(m_variableValues.at(_a).value))
+	if (AssignedValue const* value = m_variableValues(_a))
+		if (Literal const* literal = get_if<Literal>(value->value))
 			return valueOfLiteral(*literal);
 	return {};
 }
diff --git a/libyul/optimiser/KnowledgeBase.h b/libyul/optimiser/KnowledgeBase.h
@@ -28,6 +28,7 @@
 #include <libsolutil/Numeric.h>
 
 #include <map>
+#include <functional>
 
 namespace solidity::yul
 {
@@ -37,15 +38,16 @@ struct AssignedValue;
 
 /**
  * Class that can answer questions about values of variables and their relations.
- *
- * The reference to the map of values provided at construction is assumed to be updating.
  */
 class KnowledgeBase
 {
 public:
-	KnowledgeBase(Dialect const& _dialect, std::map<YulString, AssignedValue> const& _variableValues):
+	KnowledgeBase(
+		Dialect const& _dialect,
+		std::function<AssignedValue const*(YulString)> _variableValues
+	):
 		m_dialect(_dialect),
-		m_variableValues(_variableValues)
+		m_variableValues(std::move(_variableValues))
 	{}
 
 	bool knownToBeDifferent(YulString _a, YulString _b);
@@ -60,7 +62,7 @@ class KnowledgeBase
 	Expression simplifyRecursively(Expression _expression);
 
 	Dialect const& m_dialect;
-	std::map<YulString, AssignedValue> const& m_variableValues;
+	std::function<AssignedValue const*(YulString)> m_variableValues;
 	size_t m_counter = 0;
 };
 
diff --git a/libyul/optimiser/LoadResolver.cpp b/libyul/optimiser/LoadResolver.cpp
@@ -82,12 +82,12 @@ void LoadResolver::tryResolve(
 	YulString key = std::get<Identifier>(_arguments.at(0)).name;
 	if (_location == StoreLoadLocation::Storage)
 	{
-		if (auto value = util::valueOrNullptr(m_storage, key))
+		if (auto value = storageValue(key))
 			if (inScope(*value))
 				_e = Identifier{debugDataOf(_e), *value};
 	}
 	else if (!m_containsMSize && _location == StoreLoadLocation::Memory)
-		if (auto value = util::valueOrNullptr(m_memory, key))
+		if (auto value = memoryValue(key))
 			if (inScope(*value))
 				_e = Identifier{debugDataOf(_e), *value};
 }
@@ -129,10 +129,10 @@ void LoadResolver::tryEvaluateKeccak(
 	if (costOfLiteral > costOfKeccak)
 		return;
 
-	auto memoryValue = util::valueOrNullptr(m_memory, memoryKey->name);
-	if (memoryValue && inScope(*memoryValue))
+	optional<YulString> value = memoryValue(memoryKey->name);
+	if (value && inScope(*value))
 	{
-		optional<u256> memoryContent = valueOfIdentifier(*memoryValue);
+		optional<u256> memoryContent = valueOfIdentifier(*value);
 		optional<u256> byteLength = valueOfIdentifier(length->name);
 		if (memoryContent && byteLength && *byteLength <= 32)
 		{
diff --git a/libyul/optimiser/Rematerialiser.cpp b/libyul/optimiser/Rematerialiser.cpp
@@ -79,30 +79,30 @@ void Rematerialiser::visit(Expression& _e)
 	{
 		Identifier& identifier = std::get<Identifier>(_e);
 		YulString name = identifier.name;
-		if (m_value.count(name))
+		if (AssignedValue const* value = variableValue(name))
 		{
-			assertThrow(m_value.at(name).value, OptimizerException, "");
-			AssignedValue const& value = m_value.at(name);
+			assertThrow(value->value, OptimizerException, "");
 			size_t refs = m_referenceCounts[name];
-			size_t cost = CodeCost::codeCost(m_dialect, *value.value);
+			size_t cost = CodeCost::codeCost(m_dialect, *value->value);
 			if (
 				(
 					!m_onlySelectedVariables && (
-						(refs <= 1 && value.loopDepth == m_loopDepth) ||
+						(refs <= 1 && value->loopDepth == m_loopDepth) ||
 						cost == 0 ||
 						(refs <= 5 && cost <= 1 && m_loopDepth == 0)
 					)
 				) || m_varsToAlwaysRematerialize.count(name)
 			)
 			{
 				assertThrow(m_referenceCounts[name] > 0, OptimizerException, "");
-				if (ranges::all_of(m_references[name], [&](auto const& ref) { return inScope(ref); }))
+				auto variableReferences = references(name);
+				if (!variableReferences || ranges::all_of(*variableReferences, [&](auto const& ref) { return inScope(ref); }))
 				{
 					// update reference counts
 					m_referenceCounts[name]--;
-					for (auto const& ref: ReferencesCounter::countReferences(*value.value))
+					for (auto const& ref: ReferencesCounter::countReferences(*value->value))
 						m_referenceCounts[ref.first] += ref.second;
-					_e = (ASTCopier{}).translate(*value.value);
+					_e = (ASTCopier{}).translate(*value->value);
 				}
 			}
 		}
@@ -116,12 +116,11 @@ void LiteralRematerialiser::visit(Expression& _e)
 	{
 		Identifier& identifier = std::get<Identifier>(_e);
 		YulString name = identifier.name;
-		if (m_value.count(name))
+		if (AssignedValue const* value = variableValue(name))
 		{
-			Expression const* value = m_value.at(name).value;
-			assertThrow(value, OptimizerException, "");
-			if (holds_alternative<Literal>(*value))
-				_e = *value;
+			assertThrow(value->value, OptimizerException, "");
+			if (holds_alternative<Literal>(*value->value))
+				_e = *value->value;
 		}
 	}
 	DataFlowAnalyzer::visit(_e);
diff --git a/libyul/optimiser/SimplificationRules.cpp b/libyul/optimiser/SimplificationRules.cpp
@@ -41,7 +41,7 @@ using namespace solidity::yul;
 SimplificationRules::Rule const* SimplificationRules::findFirstMatch(
 	Expression const& _expr,
 	Dialect const& _dialect,
-	map<YulString, AssignedValue> const& _ssaValues
+	function<AssignedValue const*(YulString)> const& _ssaValues
 )
 {
 	auto instruction = instructionAndArguments(_dialect, _expr);
@@ -138,7 +138,7 @@ void Pattern::setMatchGroup(unsigned _group, map<unsigned, Expression const*>& _
 bool Pattern::matches(
 	Expression const& _expr,
 	Dialect const& _dialect,
-	map<YulString, AssignedValue> const& _ssaValues
+	function<AssignedValue const*(YulString)> const& _ssaValues
 ) const
 {
 	Expression const* expr = &_expr;
@@ -148,8 +148,8 @@ bool Pattern::matches(
 	if (m_kind != PatternKind::Any && holds_alternative<Identifier>(_expr))
 	{
 		YulString varName = std::get<Identifier>(_expr).name;
-		if (_ssaValues.count(varName))
-			if (Expression const* new_expr = _ssaValues.at(varName).value)
+		if (AssignedValue const* value = _ssaValues(varName))
+			if (Expression const* new_expr = value->value)
 				expr = new_expr;
 	}
 	assertThrow(expr, OptimizerException, "");
diff --git a/libyul/optimiser/SimplificationRules.h b/libyul/optimiser/SimplificationRules.h
@@ -62,7 +62,7 @@ class SimplificationRules
 	static Rule const* findFirstMatch(
 		Expression const& _expr,
 		Dialect const& _dialect,
-		std::map<YulString, AssignedValue> const& _ssaValues
+		std::function<AssignedValue const*(YulString)> const& _ssaValues
 	);
 
 	/// Checks whether the rulelist is non-empty. This is usually enforced
@@ -119,7 +119,7 @@ class Pattern
 	bool matches(
 		Expression const& _expr,
 		Dialect const& _dialect,
-		std::map<YulString, AssignedValue> const& _ssaValues
+		std::function<AssignedValue const*(YulString)> const& _ssaValues
 	) const;
 
 	std::vector<Pattern> arguments() const { return m_arguments; }
diff --git a/libyul/optimiser/StackCompressor.cpp b/libyul/optimiser/StackCompressor.cpp
@@ -67,7 +67,8 @@ class RematCandidateSelector: public DataFlowAnalyzer
 			if (size_t const* cost = util::valueOrNullptr(m_expressionCodeCost, candidate))
 			{
 				size_t numRef = m_numReferences[candidate];
-				cand[*cost * numRef].emplace_back(candidate, m_references[candidate]);
+				set<YulString> const* ref = references(candidate);
+				cand[*cost * numRef].emplace_back(candidate, ref ? move(*ref) : set<YulString>{});
 			}
 		}
 		return cand;
@@ -80,11 +81,11 @@ class RematCandidateSelector: public DataFlowAnalyzer
 		if (_varDecl.variables.size() == 1)
 		{
 			YulString varName = _varDecl.variables.front().name;
-			if (m_value.count(varName))
+			if (AssignedValue const* value = variableValue(varName))
 			{
 				yulAssert(!m_expressionCodeCost.count(varName), "");
 				m_candidates.emplace_back(varName);
-				m_expressionCodeCost[varName] = CodeCost::codeCost(m_dialect, *m_value[varName].value);
+				m_expressionCodeCost[varName] = CodeCost::codeCost(m_dialect, *value->value);
 			}
 		}
 	}
@@ -105,7 +106,7 @@ class RematCandidateSelector: public DataFlowAnalyzer
 			YulString name = std::get<Identifier>(_e).name;
 			if (m_expressionCodeCost.count(name))
 			{
-				if (!m_value.count(name))
+				if (!variableValue(name))
 					rematImpossible(name);
 				else
 					++m_numReferences[name];
diff --git a/libyul/optimiser/UnusedStoreEliminator.cpp b/libyul/optimiser/UnusedStoreEliminator.cpp
@@ -238,7 +238,7 @@ bool UnusedStoreEliminator::knownUnrelated(
 	UnusedStoreEliminator::Operation const& _op2
 ) const
 {
-	KnowledgeBase knowledge(m_dialect, m_ssaValues);
+	KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); });
 
 	if (_op1.location != _op2.location)
 		return true;
@@ -319,7 +319,7 @@ bool UnusedStoreEliminator::knownCovered(
 		return true;
 	if (_covered.location == Location::Memory)
 	{
-		KnowledgeBase knowledge(m_dialect, m_ssaValues);
+		KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); });
 
 		if (_covered.length && knowledge.knownToBeZero(*_covered.length))
 			return true;
diff --git a/test/libyul/KnowledgeBaseTest.cpp b/test/libyul/KnowledgeBaseTest.cpp
@@ -58,7 +58,7 @@ class KnowledgeBaseTest
 		for (auto const& [name, expression]: m_ssaValues.values())
 			m_values[name].value = expression;
 
-		return KnowledgeBase(m_dialect, m_values);
+		return KnowledgeBase(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_values, _var); });
 	}
 
 	EVMDialect m_dialect{EVMVersion{}, true};

Original file line number	Diff line number	Diff line change
`@@ -95,18 +95,18 @@ void CommonSubexpressionEliminator::visit(Expression& _e)`
`95`	`95`	`if (Identifier const* identifier = get_if<Identifier>(&_e))`
`96`	`96`	`{`
`97`	`97`	`YulString identifierName = identifier->name;`
`98`		`- if (m_value.count(identifierName))`
	`98`	`+ if (AssignedValue const* assignedValue = variableValue(identifierName))`
`99`	`99`	`{`
`100`		`- assertThrow(m_value.at(identifierName).value, OptimizerException, "");`
`101`		`- if (Identifier const* value = get_if<Identifier>(m_value.at(identifierName).value))`
	`100`	`+ assertThrow(assignedValue->value, OptimizerException, "");`
	`101`	`+ if (Identifier const* value = get_if<Identifier>(assignedValue->value))`
`102`	`102`	`if (inScope(value->name))`
`103`	`103`	`_e = Identifier{debugDataOf(_e), value->name};`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`else`
`107`	`107`	`{`
`108`	`108`	`// TODO this search is rather inefficient.`
`109`		`- for (auto const& [variable, value]: m_value)`
	`109`	`+ for (auto const& [variable, value]: allValues())`
`110`	`110`	`{`
`111`	`111`	`assertThrow(value.value, OptimizerException, "");`
`112`	`112`	`// Prevent using the default value of return variables`
Original file line number	Diff line number	Diff line change
`@@ -54,13 +54,13 @@ void EqualStoreEliminator::visit(Statement& _statement)`
`54`	`54`	`{`
`55`	`55`	`if (auto vars = isSimpleStore(StoreLoadLocation::Storage, *expression))`
`56`	`56`	`{`
`57`		`- if (auto const* currentValue = util::valueOrNullptr(m_storage, vars->first))`
	`57`	`+ if (optional<YulString> currentValue = storageValue(vars->first))`
`58`	`58`	`if (*currentValue == vars->second)`
`59`	`59`	`m_pendingRemovals.insert(&_statement);`
`60`	`60`	`}`
`61`	`61`	`else if (auto vars = isSimpleStore(StoreLoadLocation::Memory, *expression))`
`62`	`62`	`{`
`63`		`- if (auto const* currentValue = util::valueOrNullptr(m_memory, vars->first))`
	`63`	`+ if (optional<YulString> currentValue = memoryValue(vars->first))`
`64`	`64`	`if (*currentValue == vars->second)`
`65`	`65`	`m_pendingRemovals.insert(&_statement);`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,10 @@ void ExpressionSimplifier::visit(Expression& _expression)`
`38`	`38`	`{`
`39`	`39`	`ASTModifier::visit(_expression);`
`40`	`40`
`41`		`- while (auto const* match = SimplificationRules::findFirstMatch(_expression, m_dialect, m_value))`
	`41`	`+ while (auto const* match = SimplificationRules::findFirstMatch(`
	`42`	`+ _expression,`
	`43`	`+ m_dialect,`
	`44`	`+ [this](YulString _var) { return variableValue(_var); }`
	`45`	`+ ))`
`42`	`46`	`_expression = match->action().toExpression(debugDataOf(_expression));`
`43`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,8 +80,8 @@ bool KnowledgeBase::knownToBeZero(YulString _a)`
`80`	`80`
`81`	`81`	`optional<u256> KnowledgeBase::valueIfKnownConstant(YulString _a)`
`82`	`82`	`{`
`83`		`- if (m_variableValues.count(_a))`
`84`		`- if (Literal const* literal = get_if<Literal>(m_variableValues.at(_a).value))`
	`83`	`+ if (AssignedValue const* value = m_variableValues(_a))`
	`84`	`+ if (Literal const* literal = get_if<Literal>(value->value))`
`85`	`85`	`return valueOfLiteral(*literal);`
`86`	`86`	`return {};`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,12 +82,12 @@ void LoadResolver::tryResolve(`
`82`	`82`	`YulString key = std::get<Identifier>(_arguments.at(0)).name;`
`83`	`83`	`if (_location == StoreLoadLocation::Storage)`
`84`	`84`	`{`
`85`		`- if (auto value = util::valueOrNullptr(m_storage, key))`
	`85`	`+ if (auto value = storageValue(key))`
`86`	`86`	`if (inScope(*value))`
`87`	`87`	`_e = Identifier{debugDataOf(_e), *value};`
`88`	`88`	`}`
`89`	`89`	`else if (!m_containsMSize && _location == StoreLoadLocation::Memory)`
`90`		`- if (auto value = util::valueOrNullptr(m_memory, key))`
	`90`	`+ if (auto value = memoryValue(key))`
`91`	`91`	`if (inScope(*value))`
`92`	`92`	`_e = Identifier{debugDataOf(_e), *value};`
`93`	`93`	`}`
`@@ -129,10 +129,10 @@ void LoadResolver::tryEvaluateKeccak(`
`129`	`129`	`if (costOfLiteral > costOfKeccak)`
`130`	`130`	`return;`
`131`	`131`
`132`		`- auto memoryValue = util::valueOrNullptr(m_memory, memoryKey->name);`
`133`		`- if (memoryValue && inScope(*memoryValue))`
	`132`	`+ optional<YulString> value = memoryValue(memoryKey->name);`
	`133`	`+ if (value && inScope(*value))`
`134`	`134`	`{`
`135`		`- optional<u256> memoryContent = valueOfIdentifier(*memoryValue);`
	`135`	`+ optional<u256> memoryContent = valueOfIdentifier(*value);`
`136`	`136`	`optional<u256> byteLength = valueOfIdentifier(length->name);`
`137`	`137`	`if (memoryContent && byteLength && *byteLength <= 32)`
`138`	`138`	`{`
Original file line number	Diff line number	Diff line change
`@@ -79,30 +79,30 @@ void Rematerialiser::visit(Expression& _e)`
`79`	`79`	`{`
`80`	`80`	`Identifier& identifier = std::get<Identifier>(_e);`
`81`	`81`	`YulString name = identifier.name;`
`82`		`- if (m_value.count(name))`
	`82`	`+ if (AssignedValue const* value = variableValue(name))`
`83`	`83`	`{`
`84`		`- assertThrow(m_value.at(name).value, OptimizerException, "");`
`85`		`- AssignedValue const& value = m_value.at(name);`
	`84`	`+ assertThrow(value->value, OptimizerException, "");`
`86`	`85`	`size_t refs = m_referenceCounts[name];`
`87`		`- size_t cost = CodeCost::codeCost(m_dialect, *value.value);`
	`86`	`+ size_t cost = CodeCost::codeCost(m_dialect, *value->value);`
`88`	`87`	`if (`
`89`	`88`	`(`
`90`	`89`	`!m_onlySelectedVariables && (`
`91`		`- (refs <= 1 && value.loopDepth == m_loopDepth) \|\|`
	`90`	`+ (refs <= 1 && value->loopDepth == m_loopDepth) \|\|`
`92`	`91`	`cost == 0 \|\|`
`93`	`92`	`(refs <= 5 && cost <= 1 && m_loopDepth == 0)`
`94`	`93`	`)`
`95`	`94`	`) \|\| m_varsToAlwaysRematerialize.count(name)`
`96`	`95`	`)`
`97`	`96`	`{`
`98`	`97`	`assertThrow(m_referenceCounts[name] > 0, OptimizerException, "");`
`99`		`- if (ranges::all_of(m_references[name], [&](auto const& ref) { return inScope(ref); }))`
	`98`	`+ auto variableReferences = references(name);`
	`99`	`+ if (!variableReferences \|\| ranges::all_of(*variableReferences, [&](auto const& ref) { return inScope(ref); }))`
`100`	`100`	`{`
`101`	`101`	`// update reference counts`
`102`	`102`	`m_referenceCounts[name]--;`
`103`		`- for (auto const& ref: ReferencesCounter::countReferences(*value.value))`
	`103`	`+ for (auto const& ref: ReferencesCounter::countReferences(*value->value))`
`104`	`104`	`m_referenceCounts[ref.first] += ref.second;`
`105`		`- _e = (ASTCopier{}).translate(*value.value);`
	`105`	`+ _e = (ASTCopier{}).translate(*value->value);`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`}`
`@@ -116,12 +116,11 @@ void LiteralRematerialiser::visit(Expression& _e)`
`116`	`116`	`{`
`117`	`117`	`Identifier& identifier = std::get<Identifier>(_e);`
`118`	`118`	`YulString name = identifier.name;`
`119`		`- if (m_value.count(name))`
	`119`	`+ if (AssignedValue const* value = variableValue(name))`
`120`	`120`	`{`
`121`		`- Expression const* value = m_value.at(name).value;`
`122`		`- assertThrow(value, OptimizerException, "");`
`123`		`- if (holds_alternative<Literal>(*value))`
`124`		`- _e = *value;`
	`121`	`+ assertThrow(value->value, OptimizerException, "");`
	`122`	`+ if (holds_alternative<Literal>(*value->value))`
	`123`	`+ _e = *value->value;`
`125`	`124`	`}`
`126`	`125`	`}`
`127`	`126`	`DataFlowAnalyzer::visit(_e);`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ using namespace solidity::yul;`
`41`	`41`	`SimplificationRules::Rule const* SimplificationRules::findFirstMatch(`
`42`	`42`	`Expression const& _expr,`
`43`	`43`	`Dialect const& _dialect,`
`44`		`- map<YulString, AssignedValue> const& _ssaValues`
	`44`	`+ function<AssignedValue const*(YulString)> const& _ssaValues`
`45`	`45`	`)`
`46`	`46`	`{`
`47`	`47`	`auto instruction = instructionAndArguments(_dialect, _expr);`
`@@ -138,7 +138,7 @@ void Pattern::setMatchGroup(unsigned _group, map<unsigned, Expression const*>& _`
`138`	`138`	`bool Pattern::matches(`
`139`	`139`	`Expression const& _expr,`
`140`	`140`	`Dialect const& _dialect,`
`141`		`- map<YulString, AssignedValue> const& _ssaValues`
	`141`	`+ function<AssignedValue const*(YulString)> const& _ssaValues`
`142`	`142`	`) const`
`143`	`143`	`{`
`144`	`144`	`Expression const* expr = &_expr;`
`@@ -148,8 +148,8 @@ bool Pattern::matches(`
`148`	`148`	`if (m_kind != PatternKind::Any && holds_alternative<Identifier>(_expr))`
`149`	`149`	`{`
`150`	`150`	`YulString varName = std::get<Identifier>(_expr).name;`
`151`		`- if (_ssaValues.count(varName))`
`152`		`- if (Expression const* new_expr = _ssaValues.at(varName).value)`
	`151`	`+ if (AssignedValue const* value = _ssaValues(varName))`
	`152`	`+ if (Expression const* new_expr = value->value)`
`153`	`153`	`expr = new_expr;`
`154`	`154`	`}`
`155`	`155`	`assertThrow(expr, OptimizerException, "");`