Pass EVMDialect to StackLayoutGenerator directly.

Author: ekpyron

libyul/backends/evm/OptimizedEVMCodeTransform.cpp

@@ -49,7 +49,7 @@ std::vector<StackTooDeepError> OptimizedEVMCodeTransform::run(
 )
 {
 	std::unique_ptr<CFG> dfg = ControlFlowGraphBuilder::build(_analysisInfo, _dialect, _block);
-	StackLayout stackLayout = StackLayoutGenerator::run(*dfg, !_dialect.eofVersion().has_value(), _dialect.reachableStackDepth());
+	StackLayout stackLayout = StackLayoutGenerator::run(*dfg, _dialect);
 
 	if (_dialect.eofVersion().has_value())
 	{

libyul/backends/evm/StackLayoutGenerator.cpp

@@ -45,46 +45,42 @@
 using namespace solidity;
 using namespace solidity::yul;
 
-StackLayout StackLayoutGenerator::run(CFG const& _cfg, bool _simulateFunctionsWithJumps, size_t _reachableStackDepth)
+StackLayout StackLayoutGenerator::run(CFG const& _cfg, EVMDialect const& _evmDialect)
 {
 	StackLayout stackLayout{{}, {}};
 	StackLayoutGenerator{
 		stackLayout,
 		nullptr,
-		_simulateFunctionsWithJumps,
-		_reachableStackDepth
+		_evmDialect
 	}.processEntryPoint(*_cfg.entry);
 
 	for (auto& functionInfo: _cfg.functionInfo | ranges::views::values)
 		StackLayoutGenerator{
 			stackLayout,
 			&functionInfo,
-			_simulateFunctionsWithJumps,
-			_reachableStackDepth
+			_evmDialect
 		}.processEntryPoint(*functionInfo.entry, &functionInfo);
 
 	return stackLayout;
 }
 
 std::map<YulName, std::vector<StackLayoutGenerator::StackTooDeep>> StackLayoutGenerator::reportStackTooDeep(
 	CFG const& _cfg,
-	bool _simulateFunctionsWithJumps,
-	size_t _reachableStackDepth
+	EVMDialect const& _evmDialect
 )
 {
 	std::map<YulName, std::vector<StackLayoutGenerator::StackTooDeep>> stackTooDeepErrors;
-	stackTooDeepErrors[YulName{}] = reportStackTooDeep(_cfg, YulName{}, _simulateFunctionsWithJumps, _reachableStackDepth);
+	stackTooDeepErrors[YulName{}] = reportStackTooDeep(_cfg, YulName{}, _evmDialect);
 	for (auto const& function: _cfg.functions)
-		if (auto errors = reportStackTooDeep(_cfg, function->name, _simulateFunctionsWithJumps, _reachableStackDepth); !errors.empty())
+		if (auto errors = reportStackTooDeep(_cfg, function->name, _evmDialect); !errors.empty())
 			stackTooDeepErrors[function->name] = std::move(errors);
 	return stackTooDeepErrors;
 }
 
 std::vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStackTooDeep(
 	CFG const& _cfg,
 	YulName _functionName,
-	bool _simulateFunctionsWithJumps,
-	size_t _reachableStackDepth
+	EVMDialect const& _evmDialect
 )
 {
 	StackLayout stackLayout{{}, {}};
@@ -99,7 +95,7 @@ std::vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStac
 		yulAssert(functionInfo, "Function not found.");
 	}
 
-	StackLayoutGenerator generator{stackLayout, functionInfo, _simulateFunctionsWithJumps, _reachableStackDepth};
+	StackLayoutGenerator generator{stackLayout, functionInfo, _evmDialect};
 	CFG::BasicBlock const* entry = functionInfo ? functionInfo->entry : _cfg.entry;
 	generator.processEntryPoint(*entry);
 	return generator.reportStackTooDeep(*entry);
@@ -108,13 +104,11 @@ std::vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStac
 StackLayoutGenerator::StackLayoutGenerator(
 	StackLayout& _layout,
 	CFG::FunctionInfo const* _functionInfo,
-	bool _simulateFunctionsWithJumps,
-	size_t _reachableStackDepth
+	EVMDialect const& _evmDialect
 ):
 	m_layout(_layout),
 	m_currentFunctionInfo(_functionInfo),
-	m_simulateFunctionsWithJumps(_simulateFunctionsWithJumps),
-	m_reachableStackDepth(_reachableStackDepth)
+	m_evmDialect(_evmDialect)
 {
 }
 
@@ -312,7 +306,7 @@ Stack StackLayoutGenerator::propagateStackThroughOperation(Stack _exitStack, CFG
 
 	// Determine the ideal permutation of the slots in _exitLayout that are not operation outputs (and not to be
 	// generated on the fly), s.t. shuffling the `stack + _operation.output` to _exitLayout is cheap.
-	Stack stack = createIdealLayout(_operation.output, _exitStack, generateSlotOnTheFly, m_reachableStackDepth);
+	Stack stack = createIdealLayout(_operation.output, _exitStack, generateSlotOnTheFly, reachableStackDepth());
 
 	// Make sure the resulting previous slots do not overlap with any assignmed variables.
 	if (auto const* assignment = std::get_if<CFG::Assignment>(&_operation.operation))
@@ -336,7 +330,7 @@ Stack StackLayoutGenerator::propagateStackThroughOperation(Stack _exitStack, CFG
 			stack.pop_back();
 		else if (auto offset = util::findOffset(stack | ranges::views::reverse | ranges::views::drop(1), stack.back()))
 		{
-			if (*offset + 2 < m_reachableStackDepth)
+			if (*offset + 2 < reachableStackDepth())
 				stack.pop_back();
 			else
 				break;
@@ -354,7 +348,7 @@ Stack StackLayoutGenerator::propagateStackThroughBlock(Stack _exitStack, CFG::Ba
 	for (auto&& [idx, operation]: _block.operations | ranges::views::enumerate | ranges::views::reverse)
 	{
 		Stack newStack = propagateStackThroughOperation(stack, operation, _aggressiveStackCompression);
-		if (!_aggressiveStackCompression && !findStackTooDeep(newStack, stack, m_reachableStackDepth).empty())
+		if (!_aggressiveStackCompression && !findStackTooDeep(newStack, stack, reachableStackDepth()).empty())
 			// If we had stack errors, run again with aggressive stack compression.
 			return propagateStackThroughBlock(std::move(_exitStack), _block, true);
 		stack = std::move(newStack);
@@ -476,7 +470,7 @@ std::optional<Stack> StackLayoutGenerator::getExitLayoutOrStageDependencies(
 				Stack stack = combineStack(
 					m_layout.blockInfos.at(_conditionalJump.zero).entryLayout,
 					m_layout.blockInfos.at(_conditionalJump.nonZero).entryLayout,
-					m_reachableStackDepth
+					reachableStackDepth()
 				);
 				// Additionally, the jump condition has to be at the stack top at exit.
 				stack.emplace_back(_conditionalJump.condition);
@@ -497,7 +491,7 @@ std::optional<Stack> StackLayoutGenerator::getExitLayoutOrStageDependencies(
 				return StackSlot{_varSlot};
 			}) | ranges::to<Stack>;
 
-			if (m_simulateFunctionsWithJumps)
+			if (simulateFunctionsWithJumps())
 				stack.emplace_back(FunctionReturnLabelSlot{_functionReturn.info->function});
 			return stack;
 		},
@@ -677,7 +671,7 @@ std::vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStac
 		{
 			Stack& operationEntry = m_layout.operationEntryLayout.at(&operation);
 
-			stackTooDeepErrors += findStackTooDeep(currentStack, operationEntry, m_reachableStackDepth);
+			stackTooDeepErrors += findStackTooDeep(currentStack, operationEntry, reachableStackDepth());
 			currentStack = operationEntry;
 			for (size_t i = 0; i < operation.input.size(); i++)
 				currentStack.pop_back();
@@ -691,7 +685,7 @@ std::vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStac
 			[&](CFG::BasicBlock::Jump const& _jump)
 			{
 				Stack const& targetLayout = m_layout.blockInfos.at(_jump.target).entryLayout;
-				stackTooDeepErrors += findStackTooDeep(currentStack, targetLayout, m_reachableStackDepth);
+				stackTooDeepErrors += findStackTooDeep(currentStack, targetLayout, reachableStackDepth());
 
 				if (!_jump.backwards)
 					_addChild(_jump.target);
@@ -702,7 +696,7 @@ std::vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStac
 					m_layout.blockInfos.at(_conditionalJump.zero).entryLayout,
 					m_layout.blockInfos.at(_conditionalJump.nonZero).entryLayout
 				})
-					stackTooDeepErrors += findStackTooDeep(currentStack, targetLayout, m_reachableStackDepth);
+					stackTooDeepErrors += findStackTooDeep(currentStack, targetLayout, reachableStackDepth());
 
 				_addChild(_conditionalJump.zero);
 				_addChild(_conditionalJump.nonZero);
@@ -769,7 +763,7 @@ void StackLayoutGenerator::fillInJunk(CFG::BasicBlock const& _block, CFG::Functi
 					_addChild(_conditionalJump.zero);
 					_addChild(_conditionalJump.nonZero);
 				},
-				[&](CFG::BasicBlock::FunctionReturn const&) { yulAssert(!m_simulateFunctionsWithJumps); },
+				[&](CFG::BasicBlock::FunctionReturn const&) { yulAssert(!simulateFunctionsWithJumps()); },
 				[&](CFG::BasicBlock::Terminated const&) {},
 			}, _block->exit);
 		});
@@ -779,21 +773,21 @@ void StackLayoutGenerator::fillInJunk(CFG::BasicBlock const& _block, CFG::Functi
 		size_t opGas = 0;
 		auto swap = [&](unsigned _swapDepth)
 		{
-			if (_swapDepth > m_reachableStackDepth)
+			if (_swapDepth > reachableStackDepth())
 				opGas += 1000;
 			else
-				opGas += evmasm::GasMeter::swapGas(_swapDepth, langutil::EVMVersion{});
+				opGas += evmasm::GasMeter::swapGas(_swapDepth, m_evmDialect.evmVersion());
 		};
 		auto dupOrPush = [&](StackSlot const& _slot)
 		{
 			if (canBeFreelyGenerated(_slot))
-				opGas += evmasm::GasMeter::runGas(evmasm::pushInstruction(32), langutil::EVMVersion());
+				opGas += evmasm::GasMeter::runGas(evmasm::pushInstruction(32), m_evmDialect.evmVersion());
 			else
 			{
 				if (auto depth = util::findOffset(_source | ranges::views::reverse, _slot))
 				{
-					if (*depth < m_reachableStackDepth)
-						opGas += evmasm::GasMeter::dupGas(*depth + 1, langutil::EVMVersion{});
+					if (*depth < reachableStackDepth())
+						opGas += evmasm::GasMeter::dupGas(*depth + 1, m_evmDialect.evmVersion());
 					else
 						opGas += 1000;
 				}
@@ -805,12 +799,12 @@ void StackLayoutGenerator::fillInJunk(CFG::BasicBlock const& _block, CFG::Functi
 					yulAssert(util::contains(m_currentFunctionInfo->returnVariables, std::get<VariableSlot>(_slot)));
 					// Strictly speaking the cost of the PUSH0 depends on the targeted EVM version, but the difference
 					// will not matter here.
-					opGas += evmasm::GasMeter::pushGas(u256(0), langutil::EVMVersion());
+					opGas += evmasm::GasMeter::pushGas(u256(0), m_evmDialect.evmVersion());
 				}
 			}
 		};
-		auto pop = [&]() { opGas += evmasm::GasMeter::runGas(evmasm::Instruction::POP,langutil::EVMVersion()); };
-		createStackLayout(_source, _target, swap, dupOrPush, pop, m_reachableStackDepth);
+		auto pop = [&]() { opGas += evmasm::GasMeter::runGas(evmasm::Instruction::POP, m_evmDialect.evmVersion()); };
+		createStackLayout(_source, _target, swap, dupOrPush, pop, reachableStackDepth());
 		return opGas;
 	};
 	/// @returns the number of junk slots to be prepended to @a _targetLayout for an optimal transition from

libyul/backends/evm/StackLayoutGenerator.h

@@ -22,6 +22,7 @@
 #pragma once
 
 #include <libyul/backends/evm/ControlFlowGraph.h>
+#include <libyul/backends/evm/EVMDialect.h>
 
 #include <map>
 
@@ -55,31 +56,28 @@ class StackLayoutGenerator
 		std::vector<YulName> variableChoices;
 	};
 
-	static StackLayout run(CFG const& _cfg, bool _simulateFunctionsWithJumps, size_t _reachableStackDepth);
+	static StackLayout run(CFG const& _cfg, EVMDialect const& _evmDialect);
 	/// @returns a map from function names to the stack too deep errors occurring in that function.
 	/// Requires @a _cfg to be a control flow graph generated from disambiguated Yul.
 	/// The empty string is mapped to the stack too deep errors of the main entry point.
 	static std::map<YulName, std::vector<StackTooDeep>> reportStackTooDeep(
 		CFG const& _cfg,
-		bool _simulateFunctionsWithJumps,
-		size_t _reachableStackDepth
+		EVMDialect const& _evmDialect
 	);
 	/// @returns all stack too deep errors in the function named @a _functionName.
 	/// Requires @a _cfg to be a control flow graph generated from disambiguated Yul.
 	/// If @a _functionName is empty, the stack too deep errors of the main entry point are reported instead.
 	static std::vector<StackTooDeep> reportStackTooDeep(
 		CFG const& _cfg,
 		YulName _functionName,
-		bool _simulateFunctionsWithJumps,
-		size_t _reachableStackDepth
+		EVMDialect const& _evmDialect
 	);
 
 private:
 	StackLayoutGenerator(
 		StackLayout& _context,
 		CFG::FunctionInfo const* _functionInfo,
-		bool _simulateFunctionsWithJumps,
-		size_t _reachableStackDepth
+		EVMDialect const& _evmDialect
 	);
 
 	/// @returns the optimal entry stack layout, s.t. @a _operation can be applied to it and
@@ -128,11 +126,19 @@ class StackLayoutGenerator
 	//// Fills in junk when entering branches that do not need a clean stack in case the result is cheaper.
 	void fillInJunk(CFG::BasicBlock const& _block, CFG::FunctionInfo const* _functionInfo = nullptr);
 
+	/// True if it simulates functions with jumps. False otherwise. True for legacy bytecode.
+	bool simulateFunctionsWithJumps() const
+	{
+		return !m_evmDialect.eofVersion().has_value();
+	}
+	size_t reachableStackDepth() const
+	{
+		return m_evmDialect.reachableStackDepth();
+	}
+
 	StackLayout& m_layout;
 	CFG::FunctionInfo const* m_currentFunctionInfo = nullptr;
-	/// True if it simulates functions with jumps. False otherwise. True for legacy bytecode
-	bool m_simulateFunctionsWithJumps = true;
-	size_t const m_reachableStackDepth{};
+	EVMDialect const& m_evmDialect;
 };
 
 }

libyul/optimiser/StackCompressor.cpp

@@ -248,15 +248,14 @@ std::tuple<bool, Block> StackCompressor::run(
 		"Need to run the function grouper before the stack compressor."
 	);
 	bool usesOptimizedCodeGenerator = false;
-	bool simulateFunctionsWithJumps = true;
-	if (auto evmDialect = dynamic_cast<EVMDialect const*>(_object.dialect()))
+	auto evmDialect = dynamic_cast<EVMDialect const*>(_object.dialect());
+	if (evmDialect)
 	{
 		yulAssert(!evmDialect->eofVersion().has_value(), "StackCompressor does not support EOF.");
 		usesOptimizedCodeGenerator =
 			_optimizeStackAllocation &&
 			evmDialect->evmVersion().canOverchargeGasForCall() &&
 			evmDialect->providesObjectAccess();
-		simulateFunctionsWithJumps = !evmDialect->eofVersion().has_value();
 	}
 	bool allowMSizeOptimization = !MSizeFinder::containsMSize(*_object.dialect(), _object.code()->root());
 	Block astRoot = std::get<Block>(ASTCopier{}(_object.code()->root()));
@@ -268,10 +267,11 @@ std::tuple<bool, Block> StackCompressor::run(
 			_object.summarizeStructure()
 		);
 		std::unique_ptr<CFG> cfg = ControlFlowGraphBuilder::build(analysisInfo, *_object.dialect(), astRoot);
+		yulAssert(evmDialect);
 		eliminateVariablesOptimizedCodegen(
 			*_object.dialect(),
 			astRoot,
-			StackLayoutGenerator::reportStackTooDeep(*cfg, simulateFunctionsWithJumps, 16u),
+			StackLayoutGenerator::reportStackTooDeep(*cfg, *evmDialect),
 			allowMSizeOptimization
 		);
 	}

libyul/optimiser/StackLimitEvader.cpp

@@ -145,7 +145,7 @@ Block StackLimitEvader::run(
 			_object.summarizeStructure()
 		);
 		std::unique_ptr<CFG> cfg = ControlFlowGraphBuilder::build(analysisInfo, *evmDialect, astRoot);
-		run(_context, astRoot, StackLayoutGenerator::reportStackTooDeep(*cfg, !evmDialect->eofVersion().has_value(), evmDialect->reachableStackDepth()));
+		run(_context, astRoot, StackLayoutGenerator::reportStackTooDeep(*cfg, *evmDialect));
 	}
 	else
 	{

test/libyul/StackLayoutGeneratorTest.cpp

@@ -234,10 +234,8 @@ TestCase::TestResult StackLayoutGeneratorTest::run(std::ostream& _stream, std::s
 
 	auto const* evmDialect = dynamic_cast<EVMDialect const*>(&yulStack.dialect());
 	solAssert(evmDialect, "StackLayoutGenerator can only be run on EVM dialects.");
-	bool simulateFunctionsWithJumps = !evmDialect->eofVersion().has_value();
-	size_t reachableStackDepth = evmDialect->reachableStackDepth();
 
-	StackLayout stackLayout = StackLayoutGenerator::run(*cfg, simulateFunctionsWithJumps, reachableStackDepth);
+	StackLayout stackLayout = StackLayoutGenerator::run(*cfg, *evmDialect);
 
 	output << "digraph CFG {\nnodesep=0.7;\nnode[shape=box];\n\n";
 	StackLayoutPrinter printer{output, stackLayout, yulStack.dialect()};