Make the dialect available everywhere.

libsolidity/interface/AssemblyStack.cpp

@@ -134,7 +134,7 @@ void AssemblyStack::optimize(yul::Object& _object)
 	for (auto& subNode: _object.subObjects)
 		if (auto subObject = dynamic_cast<yul::Object*>(subNode.get()))
 			optimize(*subObject);
-	yul::OptimiserSuite::run(*_object.code, *_object.analysisInfo);
+	yul::OptimiserSuite::run(*languageToDialect(m_language), *_object.code, *_object.analysisInfo);
 }
 
 MachineAssemblyObject AssemblyStack::assemble(Machine _machine, bool _optimize) const

libyul/optimiser/CommonSubexpressionEliminator.h

@@ -34,6 +34,9 @@ namespace yul
  */
 class CommonSubexpressionEliminator: public DataFlowAnalyzer
 {
+public:
+	CommonSubexpressionEliminator(Dialect const& _dialect): DataFlowAnalyzer(_dialect) {}
+
 protected:
 	using ASTModifier::visit;
 	void visit(Expression& _e) override;

libyul/optimiser/DataFlowAnalyzer.cpp

@@ -142,7 +142,7 @@ void DataFlowAnalyzer::handleAssignment(set<YulString> const& _variables, Expres
 	static Expression const zero{Literal{{}, LiteralKind::Number, YulString{"0"}, {}}};
 	clearValues(_variables);
 
-	MovableChecker movableChecker;
+	MovableChecker movableChecker{m_dialect};
 	if (_value)
 		movableChecker.visit(*_value);
 	else

libyul/optimiser/DataFlowAnalyzer.h

@@ -30,6 +30,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Base class to perform data flow analysis during AST walks.
@@ -43,6 +44,8 @@ namespace yul
 class DataFlowAnalyzer: public ASTModifier
 {
 public:
+	explicit DataFlowAnalyzer(Dialect const& _dialect): m_dialect(_dialect) {}
+
 	using ASTModifier::operator();
 	void operator()(Assignment& _assignment) override;
 	void operator()(VariableDeclaration& _varDecl) override;
@@ -84,6 +87,7 @@ protected:
 	};
 	/// List of scopes.
 	std::vector<Scope> m_variableScopes;
+	Dialect const& m_dialect;
 };
 
 }

libyul/optimiser/Disambiguator.cpp

@@ -23,6 +23,7 @@
 #include <libyul/Exceptions.h>
 #include <libyul/AsmData.h>
 #include <libyul/AsmScope.h>
+#include <libyul/Dialect.h>
 
 using namespace std;
 using namespace dev;
@@ -31,7 +32,7 @@ using namespace dev::solidity;
 
 YulString Disambiguator::translateIdentifier(YulString _originalName)
 {
-	if ((m_externallyUsedIdentifiers.count(_originalName)))
+	if (m_dialect.builtin(_originalName) || m_externallyUsedIdentifiers.count(_originalName))
 		return _originalName;
 
 	assertThrow(!m_scopes.empty() && m_scopes.back(), OptimizerException, "");

libyul/optimiser/Disambiguator.h

@@ -32,6 +32,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Creates a copy of a Yul AST replacing all identifiers by unique names.
@@ -40,10 +41,14 @@ class Disambiguator: public ASTCopier
 {
 public:
 	explicit Disambiguator(
+		Dialect const& _dialect,
 		AsmAnalysisInfo const& _analysisInfo,
 		std::set<YulString> const& _externallyUsedIdentifiers = {}
 	):
-		m_info(_analysisInfo), m_externallyUsedIdentifiers(_externallyUsedIdentifiers), m_nameDispenser(m_externallyUsedIdentifiers)
+		m_info(_analysisInfo),
+		m_dialect(_dialect),
+		m_externallyUsedIdentifiers(_externallyUsedIdentifiers),
+		m_nameDispenser(_dialect, m_externallyUsedIdentifiers)
 	{
 	}
 
@@ -58,6 +63,7 @@ protected:
 	void leaveScopeInternal(Scope& _scope);
 
 	AsmAnalysisInfo const& m_info;
+	Dialect const& m_dialect;
 	std::set<YulString> const& m_externallyUsedIdentifiers;
 
 	std::vector<Scope*> m_scopes;

libyul/optimiser/ExpressionInliner.cpp

@@ -56,7 +56,7 @@ void ExpressionInliner::visit(Expression& _expression)
 
 		bool movable = boost::algorithm::all_of(
 			funCall.arguments,
-			[=](Expression const& _arg) { return MovableChecker(_arg).movable(); }
+			[=](Expression const& _arg) { return MovableChecker(m_dialect, _arg).movable(); }
 		);
 		if (m_inlinableFunctions.count(funCall.functionName.name) && movable)
 		{

libyul/optimiser/ExpressionInliner.h

@@ -29,6 +29,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Optimiser component that modifies an AST in place, inlining functions that can be
@@ -44,8 +45,8 @@ namespace yul
 class ExpressionInliner: public ASTModifier
 {
 public:
-	ExpressionInliner(Block& _block):
+	ExpressionInliner(Dialect const& _dialect, Block& _block):
-		m_block(_block)
+		m_block(_block), m_dialect(_dialect)
 	{}
 
 	void run();
@@ -62,6 +63,7 @@ private:
 	std::set<YulString> m_currentFunctions;
 
 	Block& m_block;
+	Dialect const& m_dialect;
 };
 
 

libyul/optimiser/ExpressionSimplifier.cpp

@@ -36,7 +36,7 @@ using namespace dev::solidity;
 void ExpressionSimplifier::visit(Expression& _expression)
 {
 	ASTModifier::visit(_expression);
-	while (auto match = SimplificationRules::findFirstMatch(_expression, m_ssaValues))
+	while (auto match = SimplificationRules::findFirstMatch(_expression, m_dialect, m_ssaValues))
 	{
 		// Do not apply the rule if it removes non-constant parts of the expression.
 		// TODO: The check could actually be less strict than "movable".
@@ -45,15 +45,15 @@ void ExpressionSimplifier::visit(Expression& _expression)
 		// so if the value of the variable is not movable, the expression that references
 		// the variable still is.
 
-		if (match->removesNonConstants && !MovableChecker(_expression).movable())
+		if (match->removesNonConstants && !MovableChecker(m_dialect, _expression).movable())
 			return;
 		_expression = match->action().toExpression(locationOf(_expression));
 	}
 }
 
-void ExpressionSimplifier::run(Block& _ast)
+void ExpressionSimplifier::run(Dialect const& _dialect, Block& _ast)
 {
 	SSAValueTracker ssaValues;
 	ssaValues(_ast);
-	ExpressionSimplifier{ssaValues.values()}(_ast);
+	ExpressionSimplifier{_dialect, ssaValues.values()}(_ast);
 }

libyul/optimiser/ExpressionSimplifier.h

@@ -26,6 +26,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Applies simplification rules to all expressions.
@@ -40,12 +41,13 @@ public:
 	using ASTModifier::operator();
 	virtual void visit(Expression& _expression);
 
-	static void run(Block& _ast);
+	static void run(Dialect const& _dialect, Block& _ast);
 private:
-	explicit ExpressionSimplifier(std::map<YulString, Expression const*> _ssaValues):
+	explicit ExpressionSimplifier(Dialect const& _dialect, std::map<YulString, Expression const*> _ssaValues):
-		m_ssaValues(std::move(_ssaValues))
+		m_dialect(_dialect), m_ssaValues(std::move(_ssaValues))
 	{}
 
+	Dialect const& m_dialect;
 	std::map<YulString, Expression const*> m_ssaValues;
 };
 

libyul/optimiser/NameDispenser.cpp

@@ -22,17 +22,19 @@
 
 #include <libyul/optimiser/NameCollector.h>
 #include <libyul/AsmData.h>
+#include <libyul/Dialect.h>
 
 using namespace std;
 using namespace dev;
 using namespace yul;
 
-NameDispenser::NameDispenser(Block const& _ast):
+NameDispenser::NameDispenser(Dialect const& _dialect, Block const& _ast):
-	NameDispenser(NameCollector(_ast).names())
+	NameDispenser(_dialect, NameCollector(_ast).names())
 {
 }
 
-NameDispenser::NameDispenser(set<YulString> _usedNames):
+NameDispenser::NameDispenser(Dialect const& _dialect, set<YulString> _usedNames):
+	m_dialect(_dialect),
 	m_usedNames(std::move(_usedNames))
 {
 }
@@ -51,7 +53,7 @@ YulString NameDispenser::newName(YulString _nameHint, YulString _context)
 YulString NameDispenser::newNameInternal(YulString _nameHint)
 {
 	YulString name = _nameHint;
-	while (name.empty() || m_usedNames.count(name))
+	while (name.empty() || m_usedNames.count(name) || m_dialect.builtin(name))
 	{
 		m_counter++;
 		name = YulString(_nameHint.str() + "_" + to_string(m_counter));

libyul/optimiser/NameDispenser.h

@@ -27,6 +27,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Optimizer component that can be used to generate new names that
@@ -38,9 +39,9 @@ class NameDispenser
 {
 public:
 	/// Initialize the name dispenser with all the names used in the given AST.
-	explicit NameDispenser(Block const& _ast);
+	explicit NameDispenser(Dialect const& _dialect, Block const& _ast);
 	/// Initialize the name dispenser with the given used names.
-	explicit NameDispenser(std::set<YulString> _usedNames);
+	explicit NameDispenser(Dialect const& _dialect, std::set<YulString> _usedNames);
 
 	/// @returns a currently unused name that should be similar to _nameHint
 	/// and prefixed by _context if present.
@@ -51,6 +52,7 @@ public:
 private:
 	YulString newNameInternal(YulString _nameHint);
 
+	Dialect const& m_dialect;
 	std::set<YulString> m_usedNames;
 	size_t m_counter = 0;
 };

libyul/optimiser/RedundantAssignEliminator.cpp

@@ -150,9 +150,9 @@ void RedundantAssignEliminator::operator()(Block const& _block)
 	ASTWalker::operator()(_block);
 }
 
-void RedundantAssignEliminator::run(Block& _ast)
+void RedundantAssignEliminator::run(Dialect const& _dialect, Block& _ast)
 {
-	RedundantAssignEliminator rae;
+	RedundantAssignEliminator rae{_dialect};
 	rae(_ast);
 
 	AssignmentRemover remover{rae.m_assignmentsToRemove};
@@ -211,7 +211,7 @@ void RedundantAssignEliminator::finalize(YulString _variable)
 	for (auto& assignment: m_assignments[_variable])
 	{
 		assertThrow(assignment.second != State::Undecided, OptimizerException, "");
-		if (assignment.second == State{State::Unused} && MovableChecker{*assignment.first->value}.movable())
+		if (assignment.second == State{State::Unused} && MovableChecker{*m_dialect, *assignment.first->value}.movable())
 			// TODO the only point where we actually need this
 			// to be a set is for the for loop
 			m_assignmentsToRemove.insert(assignment.first);

libyul/optimiser/RedundantAssignEliminator.h

@@ -28,6 +28,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Optimiser component that removes assignments to variables that are not used
@@ -98,6 +99,7 @@ namespace yul
 class RedundantAssignEliminator: public ASTWalker
 {
 public:
+	explicit RedundantAssignEliminator(Dialect const& _dialect): m_dialect(&_dialect) {}
 	RedundantAssignEliminator(RedundantAssignEliminator const&) = default;
 	RedundantAssignEliminator& operator=(RedundantAssignEliminator const&) = default;
 	RedundantAssignEliminator(RedundantAssignEliminator&&) = default;
@@ -112,7 +114,7 @@ public:
 	void operator()(ForLoop const&) override;
 	void operator()(Block const& _block) override;
 
-	static void run(Block& _ast);
+	static void run(Dialect const& _dialect, Block& _ast);
 
 private:
 	RedundantAssignEliminator() = default;
@@ -167,6 +169,7 @@ private:
 	void changeUndecidedTo(YulString _variable, State _newState);
 	void finalize(YulString _variable);
 
+	Dialect const* m_dialect;
 	std::set<YulString> m_declaredVariables;
 	// TODO check that this does not cause nondeterminism!
 	// This could also be a pseudo-map from state to assignment.

libyul/optimiser/Rematerialiser.cpp

@@ -30,12 +30,13 @@ using namespace std;
 using namespace dev;
 using namespace yul;
 
-void Rematerialiser::run(Block& _ast)
+void Rematerialiser::run(Dialect const& _dialect, Block& _ast)
 {
-	Rematerialiser{_ast}(_ast);
+	Rematerialiser{_dialect, _ast}(_ast);
 }
 
-Rematerialiser::Rematerialiser(Block& _ast):
+Rematerialiser::Rematerialiser(Dialect const& _dialect, Block& _ast):
+	DataFlowAnalyzer(_dialect),
 	m_referenceCounts(ReferencesCounter::countReferences(_ast))
 {
 }

libyul/optimiser/Rematerialiser.h

@@ -38,10 +38,10 @@ namespace yul
 class Rematerialiser: public DataFlowAnalyzer
 {
 public:
-	static void run(Block& _ast);
+	static void run(Dialect const& _dialect, Block& _ast);
 
 protected:
-	Rematerialiser(Block& _ast);
+	Rematerialiser(Dialect const& _dialect, Block& _ast);
 
 	using ASTModifier::visit;
 	void visit(Expression& _e) override;

libyul/optimiser/Semantics.cpp

@@ -22,6 +22,7 @@
 
 #include <libyul/Exceptions.h>
 #include <libyul/AsmData.h>
+#include <libyul/Dialect.h>
 
 #include <libevmasm/SemanticInformation.h>
 
@@ -31,7 +32,13 @@ using namespace std;
 using namespace dev;
 using namespace yul;
 
-MovableChecker::MovableChecker(Expression const& _expression)
+MovableChecker::MovableChecker(Dialect const& _dialect):
+	m_dialect(_dialect)
+{
+}
+
+MovableChecker::MovableChecker(Dialect const& _dialect, Expression const& _expression):
+	MovableChecker(_dialect)
 {
 	visit(_expression);
 }
@@ -50,8 +57,14 @@ void MovableChecker::operator()(FunctionalInstruction const& _instr)
 		ASTWalker::operator()(_instr);
 }
 
-void MovableChecker::operator()(FunctionCall const&)
+void MovableChecker::operator()(FunctionCall const& _functionCall)
 {
+	if (BuiltinFunction const* f = m_dialect.builtin(_functionCall.functionName.name))
+		if (f->movable)
+		{
+			ASTWalker::operator()(_functionCall);
+			return;
+		}
 	m_movable = false;
 }
 

libyul/optimiser/Semantics.h

@@ -26,6 +26,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Specific AST walker that determines whether an expression is movable.
@@ -33,8 +34,8 @@ namespace yul
 class MovableChecker: public ASTWalker
 {
 public:
-	MovableChecker() = default;
+	explicit MovableChecker(Dialect const& _dialect);
-	explicit MovableChecker(Expression const& _expression);
+	MovableChecker(Dialect const& _dialect, Expression const& _expression);
 
 	void operator()(Identifier const& _identifier) override;
 	void operator()(FunctionalInstruction const& _functionalInstruction) override;
@@ -48,6 +49,7 @@ public:
 	std::set<YulString> const& referencedVariables() const { return m_variableReferences; }
 
 private:
+	Dialect const& m_dialect;
 	/// Which variables the current expression references.
 	std::set<YulString> m_variableReferences;
 	/// Is the current expression movable or not.

libyul/optimiser/SimplificationRules.cpp

@@ -36,6 +36,7 @@ using namespace yul;
 
 SimplificationRule<Pattern> const* SimplificationRules::findFirstMatch(
 	Expression const& _expr,
+	Dialect const& _dialect,
 	map<YulString, Expression const*> const& _ssaValues
 )
 {
@@ -49,7 +50,7 @@ SimplificationRule<Pattern> const* SimplificationRules::findFirstMatch(
 	for (auto const& rule: rules.m_rules[uint8_t(instruction.instruction)])
 	{
 		rules.resetMatchGroups();
-		if (rule.pattern.matches(_expr, _ssaValues))
+		if (rule.pattern.matches(_expr, _dialect, _ssaValues))
 			return &rule;
 	}
 	return nullptr;
@@ -104,7 +105,11 @@ void Pattern::setMatchGroup(unsigned _group, map<unsigned, Expression const*>& _
 	m_matchGroups = &_matchGroups;
 }
 
-bool Pattern::matches(Expression const& _expr, map<YulString, Expression const*> const& _ssaValues) const
+bool Pattern::matches(
+	Expression const& _expr,
+	Dialect const& _dialect,
+	map<YulString, Expression const*> const& _ssaValues
+) const
 {
 	Expression const* expr = &_expr;
 
@@ -139,7 +144,7 @@ bool Pattern::matches(Expression const& _expr, map<YulString, Expression const*>
 			return false;
 		assertThrow(m_arguments.size() == instr.arguments.size(), OptimizerException, "");
 		for (size_t i = 0; i < m_arguments.size(); ++i)
-			if (!m_arguments[i].matches(instr.arguments.at(i), _ssaValues))
+			if (!m_arguments[i].matches(instr.arguments.at(i), _dialect, _ssaValues))
 				return false;
 	}
 	else
@@ -167,7 +172,7 @@ bool Pattern::matches(Expression const& _expr, map<YulString, Expression const*>
 			assertThrow(firstMatch, OptimizerException, "Match set but to null.");
 			return
 				SyntacticalEqualityChecker::equal(*firstMatch, _expr) &&
-				MovableChecker(_expr).movable();
+				MovableChecker(_dialect, _expr).movable();
 		}
 		else if (m_kind == PatternKind::Any)
 			(*m_matchGroups)[m_matchGroup] = &_expr;

libyul/optimiser/SimplificationRules.h

@@ -33,7 +33,7 @@
 
 namespace yul
 {
-
+struct Dialect;
 class Pattern;
 
 /**
@@ -49,6 +49,7 @@ public:
 	/// @param _ssaValues values of variables that are assigned exactly once.
 	static SimplificationRule<Pattern> const* findFirstMatch(
 		Expression const& _expr,
+		Dialect const& _dialect,
 		std::map<YulString, Expression const*> const& _ssaValues
 	);
 
@@ -93,7 +94,11 @@ public:
 	/// same expression equivalence class.
 	void setMatchGroup(unsigned _group, std::map<unsigned, Expression const*>& _matchGroups);
 	unsigned matchGroup() const { return m_matchGroup; }
-	bool matches(Expression const& _expr, std::map<YulString, Expression const*> const& _ssaValues) const;
+	bool matches(
+		Expression const& _expr,
+		Dialect const& _dialect,
+		std::map<YulString, Expression const*> const& _ssaValues
+	) const;
 
 	std::vector<Pattern> arguments() const { return m_arguments; }
 

libyul/optimiser/StructuralSimplifier.h

@@ -38,6 +38,8 @@ namespace yul
 class StructuralSimplifier: public DataFlowAnalyzer
 {
 public:
+	explicit StructuralSimplifier(Dialect const& _dialect): DataFlowAnalyzer(_dialect) {}
+
 	using DataFlowAnalyzer::operator();
 	void operator()(Block& _block) override;
 private:

libyul/optimiser/Suite.cpp

@@ -47,6 +47,7 @@ using namespace dev;
 using namespace yul;
 
 void OptimiserSuite::run(
+	Dialect const& _dialect,
 	Block& _ast,
 	AsmAnalysisInfo const& _analysisInfo,
 	set<YulString> const& _externallyUsedIdentifiers
@@ -54,69 +55,69 @@ void OptimiserSuite::run(
 {
 	set<YulString> reservedIdentifiers = _externallyUsedIdentifiers;
 
-	Block ast = boost::get<Block>(Disambiguator(_analysisInfo, reservedIdentifiers)(_ast));
+	Block ast = boost::get<Block>(Disambiguator(_dialect, _analysisInfo, reservedIdentifiers)(_ast));
 
 	(VarDeclInitializer{})(ast);
 	(FunctionHoister{})(ast);
 	(FunctionGrouper{})(ast);
 	(ForLoopInitRewriter{})(ast);
-	StructuralSimplifier{}(ast);
+	StructuralSimplifier{_dialect}(ast);
 
-	NameDispenser dispenser{ast};
+	NameDispenser dispenser{_dialect, ast};
 
 	for (size_t i = 0; i < 4; i++)
 	{
 		ExpressionSplitter{dispenser}(ast);
 		SSATransform::run(ast, dispenser);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
 
-		CommonSubexpressionEliminator{}(ast);
+		CommonSubexpressionEliminator{_dialect}(ast);
-		ExpressionSimplifier::run(ast);
+		ExpressionSimplifier::run(_dialect, ast);
-		StructuralSimplifier{}(ast);
+		StructuralSimplifier{_dialect}(ast);
 		SSATransform::run(ast, dispenser);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		UnusedPruner::runUntilStabilised(ast, reservedIdentifiers);
+		UnusedPruner::runUntilStabilised(_dialect, ast, reservedIdentifiers);
-		CommonSubexpressionEliminator{}(ast);
+		CommonSubexpressionEliminator{_dialect}(ast);
-		UnusedPruner::runUntilStabilised(ast, reservedIdentifiers);
+		UnusedPruner::runUntilStabilised(_dialect, ast, reservedIdentifiers);
 		SSATransform::run(ast, dispenser);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
 
 		ExpressionJoiner::run(ast);
 		ExpressionJoiner::run(ast);
-		ExpressionInliner(ast).run();
+		ExpressionInliner(_dialect, ast).run();
-		UnusedPruner::runUntilStabilised(ast);
+		UnusedPruner::runUntilStabilised(_dialect, ast);
 
 		ExpressionSplitter{dispenser}(ast);
 		SSATransform::run(ast, dispenser);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		CommonSubexpressionEliminator{}(ast);
+		CommonSubexpressionEliminator{_dialect}(ast);
 		FullInliner{ast, dispenser}.run();
 		SSATransform::run(ast, dispenser);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		ExpressionSimplifier::run(ast);
+		ExpressionSimplifier::run(_dialect, ast);
-		StructuralSimplifier{}(ast);
+		StructuralSimplifier{_dialect}(ast);
-		CommonSubexpressionEliminator{}(ast);
+		CommonSubexpressionEliminator{_dialect}(ast);
 		SSATransform::run(ast, dispenser);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		RedundantAssignEliminator::run(ast);
+		RedundantAssignEliminator::run(_dialect, ast);
-		UnusedPruner::runUntilStabilised(ast, reservedIdentifiers);
+		UnusedPruner::runUntilStabilised(_dialect, ast, reservedIdentifiers);
-		CommonSubexpressionEliminator{}(ast);
+		CommonSubexpressionEliminator{_dialect}(ast);
 	}
 	ExpressionJoiner::run(ast);
-	Rematerialiser::run(ast);
+	Rematerialiser::run(_dialect, ast);
-	UnusedPruner::runUntilStabilised(ast);
+	UnusedPruner::runUntilStabilised(_dialect, ast);
 	ExpressionJoiner::run(ast);
-	UnusedPruner::runUntilStabilised(ast);
+	UnusedPruner::runUntilStabilised(_dialect, ast);
 	ExpressionJoiner::run(ast);
-	UnusedPruner::runUntilStabilised(ast);
+	UnusedPruner::runUntilStabilised(_dialect, ast);
 	ExpressionJoiner::run(ast);
-	Rematerialiser::run(ast);
+	Rematerialiser::run(_dialect, ast);
-	UnusedPruner::runUntilStabilised(ast);
+	UnusedPruner::runUntilStabilised(_dialect, ast);
 
 	_ast = std::move(ast);
 }

libyul/optimiser/Suite.h

@@ -29,6 +29,7 @@ namespace yul
 {
 
 struct AsmAnalysisInfo;
+struct Dialect;
 
 /**
  * Optimiser suite that combines all steps and also provides the settings for the heuristics
@@ -37,6 +38,7 @@ class OptimiserSuite
 {
 public:
 	static void run(
+		Dialect const& _dialect,
 		Block& _ast,
 		AsmAnalysisInfo const& _analysisInfo,
 

libyul/optimiser/UnusedPruner.cpp

@@ -32,7 +32,8 @@ using namespace std;
 using namespace dev;
 using namespace yul;
 
-UnusedPruner::UnusedPruner(Block& _ast, set<YulString> const& _externallyUsedFunctions)
+UnusedPruner::UnusedPruner(Dialect const& _dialect, Block& _ast, set<YulString> const& _externallyUsedFunctions):
+	m_dialect(_dialect)
 {
 	ReferencesCounter counter;
 	counter(_ast);
@@ -69,7 +70,7 @@ void UnusedPruner::operator()(Block& _block)
 			{
 				if (!varDecl.value)
 					statement = Block{std::move(varDecl.location), {}};
-				else if (MovableChecker(*varDecl.value).movable())
+				else if (MovableChecker(m_dialect, *varDecl.value).movable())
 				{
 					subtractReferences(ReferencesCounter::countReferences(*varDecl.value));
 					statement = Block{std::move(varDecl.location), {}};
@@ -87,7 +88,7 @@ void UnusedPruner::operator()(Block& _block)
 		else if (statement.type() == typeid(ExpressionStatement))
 		{
 			ExpressionStatement& exprStmt = boost::get<ExpressionStatement>(statement);
-			if (MovableChecker(exprStmt.expression).movable())
+			if (MovableChecker(m_dialect, exprStmt.expression).movable())
 			{
 				// pop(x) should be movable!
 				subtractReferences(ReferencesCounter::countReferences(exprStmt.expression));
@@ -100,11 +101,15 @@ void UnusedPruner::operator()(Block& _block)
 	ASTModifier::operator()(_block);
 }
 
-void UnusedPruner::runUntilStabilised(Block& _ast, set<YulString> const& _externallyUsedFunctions)
+void UnusedPruner::runUntilStabilised(
+	Dialect const& _dialect,
+	Block& _ast,
+	set<YulString> const& _externallyUsedFunctions
+)
 {
 	while (true)
 	{
-		UnusedPruner pruner(_ast, _externallyUsedFunctions);
+		UnusedPruner pruner(_dialect, _ast, _externallyUsedFunctions);
 		pruner(_ast);
 		if (!pruner.shouldRunAgain())
 			return;

libyul/optimiser/UnusedPruner.h

@@ -28,6 +28,7 @@
 
 namespace yul
 {
+struct Dialect;
 
 /**
  * Optimisation stage that removes unused variables and functions and also
@@ -40,7 +41,11 @@ namespace yul
 class UnusedPruner: public ASTModifier
 {
 public:
-	explicit UnusedPruner(Block& _ast, std::set<YulString> const& _externallyUsedFunctions = {});
+	UnusedPruner(
+		Dialect const& _dialect,
+		Block& _ast,
+		std::set<YulString> const& _externallyUsedFunctions = {}
+	);
 
 	using ASTModifier::operator();
 	void operator()(Block& _block) override;
@@ -49,12 +54,17 @@ public:
 	bool shouldRunAgain() const { return m_shouldRunAgain; }
 
 	// Run the pruner until the code does not change anymore.
-	static void runUntilStabilised(Block& _ast, std::set<YulString> const& _externallyUsedFunctions = {});
+	static void runUntilStabilised(
+		Dialect const& _dialect,
+		Block& _ast,
+		std::set<YulString> const& _externallyUsedFunctions = {}
+	);
 
 private:
 	bool used(YulString _name) const;
 	void subtractReferences(std::map<YulString, size_t> const& _subtrahend);
 
+	Dialect const& m_dialect;
 	bool m_shouldRunAgain = false;
 	std::map<YulString, size_t> m_references;
 };

test/libyul/Common.cpp

@@ -41,6 +41,14 @@ using namespace langutil;
 using namespace yul;
 using namespace dev::solidity;
 
+namespace
+{
+shared_ptr<Dialect> defaultDialect(bool _yul)
+{
+	return _yul ? yul::Dialect::yul() : yul::EVMDialect::strictAssemblyForEVM();
+}
+}
+
 void yul::test::printErrors(ErrorList const& _errors)
 {
 	SourceReferenceFormatter formatter(cout);
@@ -55,7 +63,7 @@ void yul::test::printErrors(ErrorList const& _errors)
 
 pair<shared_ptr<Block>, shared_ptr<yul::AsmAnalysisInfo>> yul::test::parse(string const& _source, bool _yul)
 {
-	shared_ptr<Dialect> dialect = _yul ? yul::Dialect::yul() : yul::EVMDialect::strictAssemblyForEVM();
+	shared_ptr<Dialect> dialect = defaultDialect(_yul);
 	ErrorList errors;
 	ErrorReporter errorReporter(errors);
 	auto scanner = make_shared<Scanner>(CharStream(_source, ""));
@@ -87,7 +95,7 @@ pair<shared_ptr<Block>, shared_ptr<yul::AsmAnalysisInfo>> yul::test::parse(strin
 yul::Block yul::test::disambiguate(string const& _source, bool _yul)
 {
 	auto result = parse(_source, _yul);
-	return boost::get<Block>(Disambiguator(*result.second, {})(*result.first));
+	return boost::get<Block>(Disambiguator(*defaultDialect(_yul), *result.second, {})(*result.first));
 }
 
 string yul::test::format(string const& _source, bool _yul)

test/libyul/YulOptimizerTest.cpp

@@ -117,11 +117,11 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
 	else if (m_optimizerStep == "commonSubexpressionEliminator")
 	{
 		disambiguate();
-		(CommonSubexpressionEliminator{})(*m_ast);
+		(CommonSubexpressionEliminator{*m_dialect})(*m_ast);
 	}
 	else if (m_optimizerStep == "expressionSplitter")
 	{
-		NameDispenser nameDispenser(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
 		ExpressionSplitter{nameDispenser}(*m_ast);
 	}
 	else if (m_optimizerStep == "expressionJoiner")
@@ -132,7 +132,7 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
 	else if (m_optimizerStep == "splitJoin")
 	{
 		disambiguate();
-		NameDispenser nameDispenser(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
 		ExpressionSplitter{nameDispenser}(*m_ast);
 		ExpressionJoiner::run(*m_ast);
 		ExpressionJoiner::run(*m_ast);
@@ -150,14 +150,14 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
 	else if (m_optimizerStep == "expressionInliner")
 	{
 		disambiguate();
-		ExpressionInliner(*m_ast).run();
+		ExpressionInliner(*m_dialect, *m_ast).run();
 	}
 	else if (m_optimizerStep == "fullInliner")
 	{
 		disambiguate();
 		(FunctionHoister{})(*m_ast);
 		(FunctionGrouper{})(*m_ast);
-		NameDispenser nameDispenser(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
 		ExpressionSplitter{nameDispenser}(*m_ast);
 		FullInliner(*m_ast, nameDispenser).run();
 		ExpressionJoiner::run(*m_ast);
@@ -171,54 +171,54 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
 	else if (m_optimizerStep == "rematerialiser")
 	{
 		disambiguate();
-		Rematerialiser::run(*m_ast);
+		Rematerialiser::run(*m_dialect, *m_ast);
 	}
 	else if (m_optimizerStep == "expressionSimplifier")
 	{
 		disambiguate();
-		ExpressionSimplifier::run(*m_ast);
+		ExpressionSimplifier::run(*m_dialect, *m_ast);
 	}
 	else if (m_optimizerStep == "fullSimplify")
 	{
 		disambiguate();
-		NameDispenser nameDispenser(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
 		ExpressionSplitter{nameDispenser}(*m_ast);
-		CommonSubexpressionEliminator{}(*m_ast);
+		CommonSubexpressionEliminator{*m_dialect}(*m_ast);
-		ExpressionSimplifier::run(*m_ast);
+		ExpressionSimplifier::run(*m_dialect, *m_ast);
-		UnusedPruner::runUntilStabilised(*m_ast);
+		UnusedPruner::runUntilStabilised(*m_dialect, *m_ast);
 		ExpressionJoiner::run(*m_ast);
 		ExpressionJoiner::run(*m_ast);
 	}
 	else if (m_optimizerStep == "unusedPruner")
 	{
 		disambiguate();
-		UnusedPruner::runUntilStabilised(*m_ast);
+		UnusedPruner::runUntilStabilised(*m_dialect, *m_ast);
 	}
 	else if (m_optimizerStep == "ssaTransform")
 	{
 		disambiguate();
-		NameDispenser nameDispenser(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
 		SSATransform::run(*m_ast, nameDispenser);
 	}
 	else if (m_optimizerStep == "redundantAssignEliminator")
 	{
 		disambiguate();
-		RedundantAssignEliminator::run(*m_ast);
+		RedundantAssignEliminator::run(*m_dialect, *m_ast);
 	}
 	else if (m_optimizerStep == "ssaPlusCleanup")
 	{
 		disambiguate();
-		NameDispenser nameDispenser(*m_ast);
+		NameDispenser nameDispenser{*m_dialect, *m_ast};
 		SSATransform::run(*m_ast, nameDispenser);
-		RedundantAssignEliminator::run(*m_ast);
+		RedundantAssignEliminator::run(*m_dialect, *m_ast);
 	}
 	else if (m_optimizerStep == "structuralSimplifier")
 	{
 		disambiguate();
-		StructuralSimplifier{}(*m_ast);
+		StructuralSimplifier{*m_dialect}(*m_ast);
 	}
 	else if (m_optimizerStep == "fullSuite")
-		OptimiserSuite::run(*m_ast, *m_analysisInfo);
+		OptimiserSuite::run(*m_dialect, *m_ast, *m_analysisInfo);
 	else
 	{
 		FormattedScope(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Invalid optimizer step: " << m_optimizerStep << endl;
@@ -260,11 +260,11 @@ void YulOptimizerTest::printIndented(ostream& _stream, string const& _output, st
 
 bool YulOptimizerTest::parse(ostream& _stream, string const& _linePrefix, bool const _formatted)
 {
-	shared_ptr<yul::Dialect> dialect = m_yul ? yul::Dialect::yul() : yul::EVMDialect::strictAssemblyForEVM();
+	m_dialect = m_yul ? yul::Dialect::yul() : yul::EVMDialect::strictAssemblyForEVM();
 	ErrorList errors;
 	ErrorReporter errorReporter(errors);
 	shared_ptr<Scanner> scanner = make_shared<Scanner>(CharStream(m_source, ""));
-	m_ast = yul::Parser(errorReporter, dialect).parse(scanner, false);
+	m_ast = yul::Parser(errorReporter, m_dialect).parse(scanner, false);
 	if (!m_ast || !errorReporter.errors().empty())
 	{
 		FormattedScope(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << endl;
@@ -277,7 +277,7 @@ bool YulOptimizerTest::parse(ostream& _stream, string const& _linePrefix, bool c
 		errorReporter,
 		dev::test::Options::get().evmVersion(),
 		boost::none,
-		dialect
+		m_dialect
 	);
 	if (!analyzer.analyze(*m_ast) || !errorReporter.errors().empty())
 	{
@@ -290,7 +290,7 @@ bool YulOptimizerTest::parse(ostream& _stream, string const& _linePrefix, bool c
 
 void YulOptimizerTest::disambiguate()
 {
-	*m_ast = boost::get<Block>(Disambiguator(*m_analysisInfo)(*m_ast));
+	*m_ast = boost::get<Block>(Disambiguator(*m_dialect, *m_analysisInfo)(*m_ast));
 	m_analysisInfo.reset();
 }
 

test/libyul/YulOptimizerTest.h

@@ -30,6 +30,7 @@ namespace yul
 {
 struct AsmAnalysisInfo;
 struct Block;
+struct Dialect;
 }
 
 namespace yul
@@ -64,6 +65,7 @@ private:
 	std::string m_optimizerStep;
 	std::string m_expectation;
 
+	std::shared_ptr<Dialect> m_dialect;
 	std::shared_ptr<Block> m_ast;
 	std::shared_ptr<AsmAnalysisInfo> m_analysisInfo;
 	std::string m_obtainedResult;

test/tools/yulopti.cpp

@@ -85,7 +85,7 @@ public:
 	{
 		ErrorReporter errorReporter(m_errors);
 		shared_ptr<Scanner> scanner = make_shared<Scanner>(CharStream(_input, ""));
-		m_ast = yul::Parser(errorReporter, yul::EVMDialect::strictAssemblyForEVM()).parse(scanner, false);
+		m_ast = yul::Parser(errorReporter, m_dialect).parse(scanner, false);
 		if (!m_ast || !errorReporter.errors().empty())
 		{
 			cout << "Error parsing source." << endl;
@@ -98,7 +98,7 @@ public:
 			errorReporter,
 			EVMVersion::byzantium(),
 			langutil::Error::Type::SyntaxError,
-			EVMDialect::strictAssemblyForEVM()
+			m_dialect
 		);
 		if (!analyzer.analyze(*m_ast) || !errorReporter.errors().empty())
 		{
@@ -120,9 +120,9 @@ public:
 				return;
 			if (!disambiguated)
 			{
-				*m_ast = boost::get<yul::Block>(Disambiguator(*m_analysisInfo)(*m_ast));
+				*m_ast = boost::get<yul::Block>(Disambiguator(*m_dialect, *m_analysisInfo)(*m_ast));
 				m_analysisInfo.reset();
-				m_nameDispenser = make_shared<NameDispenser>(*m_ast);
+				m_nameDispenser = make_shared<NameDispenser>(*m_dialect, *m_ast);
 				disambiguated = true;
 			}
 			cout << "(q)quit/(f)flatten/(c)se/initialize var(d)ecls/(x)plit/(j)oin/(g)rouper/(h)oister/" << endl;
@@ -143,7 +143,7 @@ public:
 				ForLoopInitRewriter{}(*m_ast);
 				break;
 			case 'c':
-				(CommonSubexpressionEliminator{})(*m_ast);
+				(CommonSubexpressionEliminator{*m_dialect})(*m_ast);
 				break;
 			case 'd':
 				(VarDeclInitializer{})(*m_ast);
@@ -161,28 +161,28 @@ public:
 				(FunctionHoister{})(*m_ast);
 				break;
 			case 'e':
-				ExpressionInliner{*m_ast}.run();
+				ExpressionInliner{*m_dialect, *m_ast}.run();
 				break;
 			case 'i':
 				FullInliner(*m_ast, *m_nameDispenser).run();
 				break;
 			case 's':
-				ExpressionSimplifier::run(*m_ast);
+				ExpressionSimplifier::run(*m_dialect, *m_ast);
 				break;
 			case 't':
-				(StructuralSimplifier{})(*m_ast);
+				(StructuralSimplifier{*m_dialect})(*m_ast);
 				break;
 			case 'u':
-				UnusedPruner::runUntilStabilised(*m_ast);
+				UnusedPruner::runUntilStabilised(*m_dialect, *m_ast);
 				break;
 			case 'a':
 				SSATransform::run(*m_ast, *m_nameDispenser);
 				break;
 			case 'r':
-				RedundantAssignEliminator::run(*m_ast);
+				RedundantAssignEliminator::run(*m_dialect, *m_ast);
 				break;
 			case 'm':
-				Rematerialiser::run(*m_ast);
+				Rematerialiser::run(*m_dialect, *m_ast);
 				break;
 			default:
 				cout << "Unknown option." << endl;
@@ -194,6 +194,7 @@ public:
 private:
 	ErrorList m_errors;
 	shared_ptr<yul::Block> m_ast;
+	shared_ptr<Dialect> m_dialect{EVMDialect::strictAssemblyForEVMObjects()};
 	shared_ptr<AsmAnalysisInfo> m_analysisInfo;
 	shared_ptr<NameDispenser> m_nameDispenser;
 };