Compatibility with StackCompressor and StackLimitEvader.

libsolidity/codegen/ir/IRGenerator.cpp

@@ -1032,7 +1032,7 @@ string IRGenerator::memoryInit(bool _useMemoryGuard)
 {
 	// TODO: Remove once we have made sure it is safe, i.e. after "Yul memory objects lite".
 	//       Also restore the tests removed in the commit that adds this comment.
-	_useMemoryGuard = false;
+	// _useMemoryGuard = false;
 	// This function should be called at the beginning of the EVM call frame
 	// and thus can assume all memory to be zero, including the contents of
 	// the "zero memory area" (the position CompilerUtils::zeroPointer points to).

libyul/backends/evm/EVMDialect.cpp

@@ -26,8 +26,8 @@
 #include <libyul/Object.h>
 #include <libyul/Exceptions.h>
 #include <libyul/AsmParser.h>
+#include <libyul/Utilities.h>
 #include <libyul/backends/evm/AbstractAssembly.h>
-
 #include <libevmasm/SemanticInformation.h>
 #include <libevmasm/Instruction.h>
 
@@ -185,9 +185,12 @@ map<YulString, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _evmVe
 				FunctionCall const& _call,
 				AbstractAssembly& _assembly,
 				BuiltinContext&,
-				function<void(Expression const&)> _visitExpression
+				function<void(Expression const&)>
 			) {
-				visitArguments(_assembly, _call, _visitExpression);
+				yulAssert(_call.arguments.size() == 1, "");
+				Literal const* literal = get_if<Literal>(&_call.arguments.front());
+				yulAssert(literal, "");
+				_assembly.appendConstant(valueOfLiteral(*literal));
 			})
 		);
 

libyul/backends/evm/StackHelpers.h

@@ -141,6 +141,7 @@ private:
 					[&](size_t _offset) { return _ops.sourceIsSame(sourceOffset, _offset); }
 				))
 					continue;
+
 				// Bring up the target slot that would otherwise become unreachable.
 				for (size_t targetOffset: ranges::views::iota(0u, _ops.targetSize()))
 					if (!_ops.targetIsArbitrary(targetOffset) && _ops.isCompatible(sourceOffset, targetOffset))

libyul/backends/evm/StackLayoutGenerator.cpp

@@ -38,6 +38,7 @@
 #include <range/v3/view/map.hpp>
 #include <range/v3/view/reverse.hpp>
 #include <range/v3/view/take.hpp>
+#include <range/v3/view/take_last.hpp>
 #include <range/v3/view/transform.hpp>
 
 using namespace solidity;
@@ -47,17 +48,53 @@ using namespace std;
 StackLayout StackLayoutGenerator::run(CFG const& _cfg)
 {
 	StackLayout stackLayout;
-	StackLayoutGenerator{stackLayout, {}}.processEntryPoint(*_cfg.entry);
+	{
+		StackLayoutGenerator generator{stackLayout};
+		generator.processEntryPoint(*_cfg.entry);
+	}
 
 	for (auto& functionInfo: _cfg.functionInfo | ranges::views::values)
-		StackLayoutGenerator{stackLayout, functionInfo.returnVariables}.processEntryPoint(*functionInfo.entry);
+	{
+		StackLayoutGenerator generator{stackLayout};
+		generator.processEntryPoint(*functionInfo.entry);
+	}
 
 	return stackLayout;
 }
+map<YulString, vector<StackLayoutGenerator::StackTooDeep>> StackLayoutGenerator::reportStackTooDeep(CFG const& _cfg)
+{
+	map<YulString, vector<StackLayoutGenerator::StackTooDeep>> stackTooDeepErrors;
+	stackTooDeepErrors[YulString{}] = reportStackTooDeep(_cfg, YulString{});
+	for (auto const& function: _cfg.functions)
+	{
+		auto errors = reportStackTooDeep(_cfg, function->name);
+		if (!errors.empty())
+			stackTooDeepErrors[function->name] = errors;
+	}
+	return stackTooDeepErrors;
+}
+vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStackTooDeep(CFG const& _cfg, YulString _functionName)
+{
+	StackLayout stackLayout;
+	CFG::FunctionInfo const* functionInfo = nullptr;
+	if (!_functionName.empty())
+	{
+		for (auto&& [function, info]: _cfg.functionInfo)
+			if (info.function.name.str() == _functionName.str())
+			{
+				functionInfo = &info;
+				break;
+			}
+		yulAssert(functionInfo, "Function not found.");
+	}
 
-StackLayoutGenerator::StackLayoutGenerator(StackLayout& _layout, vector<VariableSlot> _currentFunctionReturnVariables):
-	m_layout(_layout),
-	m_currentFunctionReturnVariables(move(_currentFunctionReturnVariables))
+	StackLayoutGenerator generator{stackLayout};
+	CFG::BasicBlock const* entry = functionInfo ? functionInfo->entry : _cfg.entry;
+	generator.processEntryPoint(*entry);
+	return generator.reportStackTooDeep(*entry);
+}
+
+StackLayoutGenerator::StackLayoutGenerator(StackLayout& _layout): m_layout(_layout)
 {
 }
 
@@ -481,8 +518,10 @@ Stack StackLayoutGenerator::combineStack(Stack const& _stack1, Stack const& _sta
 	Stack stack2Tail = _stack2 | ranges::views::drop(commonPrefix.size()) | ranges::to<Stack>;
 
 	if (stack1Tail.empty())
+		// TODO: check if compress stack is actually good here.
 		return commonPrefix + compressStack(stack2Tail);
 	if (stack2Tail.empty())
+		// TODO: check if compress stack is actually good here.
 		return commonPrefix + compressStack(stack1Tail);
 
 	Stack candidate;
@@ -492,6 +531,7 @@ Stack StackLayoutGenerator::combineStack(Stack const& _stack1, Stack const& _sta
 	for (auto slot: stack2Tail)
 		if (!util::findOffset(candidate, slot))
 			candidate.emplace_back(slot);
+	// TODO: check if compressing here is actually good.
 	cxx20::erase_if(candidate, [](StackSlot const& slot) {
 		return holds_alternative<LiteralSlot>(slot) || holds_alternative<FunctionCallReturnLabelSlot>(slot);
 	});
@@ -550,6 +590,91 @@ Stack StackLayoutGenerator::combineStack(Stack const& _stack1, Stack const& _sta
 	return commonPrefix + bestCandidate;
 }
 
+namespace
+{
+vector<StackLayoutGenerator::StackTooDeep> findStackTooDeep(Stack const& _source, Stack const& _target)
+{
+	Stack currentStack = _source;
+	vector<StackLayoutGenerator::StackTooDeep> stackTooDeepErrors;
+	auto getVariableChoices = [](auto&& range) {
+		set<YulString> result;
+		for (auto const& slot: range)
+			if (auto const* variableSlot = get_if<VariableSlot>(&slot))
+				result.insert(variableSlot->variable.get().name);
+		return result;
+	};
+	::createStackLayout(currentStack, _target, [&](unsigned _i) {
+		if (_i > 16)
+			stackTooDeepErrors.emplace_back(StackLayoutGenerator::StackTooDeep{
+				_i - 16,
+				getVariableChoices(currentStack | ranges::views::take_last(_i + 1))
+			});
+	}, [&](StackSlot const& _slot) {
+		if (canBeFreelyGenerated(_slot))
+			return;
+		if (
+			auto depth = util::findOffset(currentStack | ranges::views::reverse, _slot);
+			depth && *depth >= 16
+		)
+			stackTooDeepErrors.emplace_back(StackLayoutGenerator::StackTooDeep{
+				*depth - 15,
+				getVariableChoices(currentStack | ranges::views::take_last(*depth + 1))
+			});
+	}, [&]() {});
+	return stackTooDeepErrors;
+
+}
+}
+
+vector<StackLayoutGenerator::StackTooDeep> StackLayoutGenerator::reportStackTooDeep(CFG::BasicBlock const& _entry)
+{
+	vector<StackTooDeep> stackTooDeepErrors;
+	util::BreadthFirstSearch<CFG::BasicBlock const*> breadthFirstSearch{{&_entry}};
+	breadthFirstSearch.run([&](CFG::BasicBlock const* _block, auto _addChild) {
+		Stack stack;
+		stack = m_layout.blockInfos.at(_block).entryLayout;
+
+		for (auto const& operation: _block->operations)
+		{
+			Stack& operationEntry = m_layout.operationEntryLayout.at(&operation);
+
+			stackTooDeepErrors += findStackTooDeep(stack, operationEntry);
+			stack = operationEntry;
+			for (size_t i = 0; i < operation.input.size(); i++)
+				stack.pop_back();
+			stack += operation.output;
+		}
+		// Do not create attempt to create the exit layout here, since the code generator will directly move to the
+		// target entry layout.
+
+		std::visit(util::GenericVisitor{
+			[&](CFG::BasicBlock::MainExit const&) {},
+			[&](CFG::BasicBlock::Jump const& _jump)
+			{
+				Stack const& targetLayout = m_layout.blockInfos.at(_jump.target).entryLayout;
+				stackTooDeepErrors += findStackTooDeep(stack, targetLayout);
+
+				if (!_jump.backwards)
+					_addChild(_jump.target);
+			},
+			[&](CFG::BasicBlock::ConditionalJump const& _conditionalJump)
+			{
+				for (Stack const& targetLayout: {
+					m_layout.blockInfos.at(_conditionalJump.zero).entryLayout,
+					m_layout.blockInfos.at(_conditionalJump.nonZero).entryLayout
+				})
+					stackTooDeepErrors += findStackTooDeep(stack, targetLayout);
+
+				_addChild(_conditionalJump.zero);
+				_addChild(_conditionalJump.nonZero);
+			},
+			[&](CFG::BasicBlock::FunctionReturn const&) {},
+			[&](CFG::BasicBlock::Terminated const&) {},
+		}, _block->exit);
+	});
+	return stackTooDeepErrors;
+}
+
 Stack StackLayoutGenerator::compressStack(Stack _stack)
 {
 	optional<size_t> firstDupOffset;

libyul/backends/evm/StackLayoutGenerator.h

@@ -47,10 +47,20 @@ struct StackLayout
 class StackLayoutGenerator
 {
 public:
+	struct StackTooDeep
+	{
+		/// Number of slots that need to be saved.
+		size_t deficit = 0;
+		/// Set of variables, eliminating which would decrease the stack deficit.
+		std::set<YulString> variableChoices;
+	};
+
 	static StackLayout run(CFG const& _cfg);
+	static std::map<YulString, std::vector<StackTooDeep>> reportStackTooDeep(CFG const& _cfg);
+	static std::vector<StackTooDeep> reportStackTooDeep(CFG const& _cfg, YulString _functionName);
 
 private:
-	StackLayoutGenerator(StackLayout& _context, std::vector<VariableSlot> _currentFunctionReturnVariables);
+	StackLayoutGenerator(StackLayout& _context);
 
 	/// @returns the optimal entry stack layout, s.t. @a _operation can be applied to it and
 	/// the result can be transformed to @a _exitStack with minimal stack shuffling.
@@ -86,13 +96,16 @@ private:
 	/// stack shuffling when starting from the returned layout.
 	static Stack combineStack(Stack const& _stack1, Stack const& _stack2);
 
+	/// Walks through the CFG and reports and stack too deep errors that would occur when generating code for it
+	/// without countermeasures.
+	std::vector<StackTooDeep> reportStackTooDeep(CFG::BasicBlock const& _entry);
+
 	/// @returns a copy of @a _stack stripped of all duplicates and slots that can be freely generated.
 	/// Attempts to create a layout that requires a minimal amount of operations to reconstruct the original
 	/// stack @a _stack.
 	static Stack compressStack(Stack _stack);
 
 	StackLayout& m_layout;
-	std::vector<VariableSlot> const m_currentFunctionReturnVariables;
 };
 
 }

libyul/optimiser/Rematerialiser.cpp

@@ -32,39 +32,44 @@ using namespace std;
 using namespace solidity;
 using namespace solidity::yul;
 
-void Rematerialiser::run(Dialect const& _dialect, Block& _ast, set<YulString> _varsToAlwaysRematerialize)
+void Rematerialiser::run(Dialect const& _dialect, Block& _ast, set<YulString> _varsToAlwaysRematerialize, bool _onlySelectedVariables)
 {
-	Rematerialiser{_dialect, _ast, std::move(_varsToAlwaysRematerialize)}(_ast);
+	Rematerialiser{_dialect, _ast, std::move(_varsToAlwaysRematerialize), _onlySelectedVariables}(_ast);
 }
 
 void Rematerialiser::run(
 	Dialect const& _dialect,
 	FunctionDefinition& _function,
-	set<YulString> _varsToAlwaysRematerialize
+	set<YulString> _varsToAlwaysRematerialize,
+	bool _onlySelectedVariables
 )
 {
-	Rematerialiser{_dialect, _function, std::move(_varsToAlwaysRematerialize)}(_function);
+	Rematerialiser{_dialect, _function, std::move(_varsToAlwaysRematerialize), _onlySelectedVariables}(_function);
 }
 
 Rematerialiser::Rematerialiser(
 	Dialect const& _dialect,
 	Block& _ast,
-	set<YulString> _varsToAlwaysRematerialize
+	set<YulString> _varsToAlwaysRematerialize,
+	bool _onlySelectedVariables
 ):
 	DataFlowAnalyzer(_dialect),
 	m_referenceCounts(ReferencesCounter::countReferences(_ast)),
-	m_varsToAlwaysRematerialize(std::move(_varsToAlwaysRematerialize))
+	m_varsToAlwaysRematerialize(std::move(_varsToAlwaysRematerialize)),
+	m_onlySelectedVariables(_onlySelectedVariables)
 {
 }
 
 Rematerialiser::Rematerialiser(
 	Dialect const& _dialect,
 	FunctionDefinition& _function,
-	set<YulString> _varsToAlwaysRematerialize
+	set<YulString> _varsToAlwaysRematerialize,
+	bool _onlySelectedVariables
 ):
 	DataFlowAnalyzer(_dialect),
 	m_referenceCounts(ReferencesCounter::countReferences(_function)),
-	m_varsToAlwaysRematerialize(std::move(_varsToAlwaysRematerialize))
+	m_varsToAlwaysRematerialize(std::move(_varsToAlwaysRematerialize)),
+	m_onlySelectedVariables(_onlySelectedVariables)
 {
 }
 
@@ -81,10 +86,13 @@ void Rematerialiser::visit(Expression& _e)
 			size_t refs = m_referenceCounts[name];
 			size_t cost = CodeCost::codeCost(m_dialect, *value.value);
 			if (
+				(
+					!m_onlySelectedVariables && (
 						(refs <= 1 && value.loopDepth == m_loopDepth) ||
 						cost == 0 ||
-				(refs <= 5 && cost <= 1 && m_loopDepth == 0) ||
-				m_varsToAlwaysRematerialize.count(name)
+						(refs <= 5 && cost <= 1 && m_loopDepth == 0)
+					)
+				) || m_varsToAlwaysRematerialize.count(name)
 			)
 			{
 				assertThrow(m_referenceCounts[name] > 0, OptimizerException, "");

libyul/optimiser/Rematerialiser.h

@@ -50,24 +50,28 @@ public:
 	static void run(
 		Dialect const& _dialect,
 		Block& _ast,
-		std::set<YulString> _varsToAlwaysRematerialize = {}
+		std::set<YulString> _varsToAlwaysRematerialize = {},
+		bool _onlySelectedVariables = false
 	);
 	static void run(
 		Dialect const& _dialect,
 		FunctionDefinition& _function,
-		std::set<YulString> _varsToAlwaysRematerialize = {}
+		std::set<YulString> _varsToAlwaysRematerialize = {},
+		bool _onlySelectedVariables = false
 	);
 
 protected:
 	Rematerialiser(
 		Dialect const& _dialect,
 		Block& _ast,
-		std::set<YulString> _varsToAlwaysRematerialize = {}
+		std::set<YulString> _varsToAlwaysRematerialize = {},
+		bool _onlySelectedVariables = false
 	);
 	Rematerialiser(
 		Dialect const& _dialect,
 		FunctionDefinition& _function,
-		std::set<YulString> _varsToAlwaysRematerialize = {}
+		std::set<YulString> _varsToAlwaysRematerialize = {},
+		bool _onlySelectedVariables = false
 	);
 
 	using DataFlowAnalyzer::operator();
@@ -77,6 +81,7 @@ protected:
 
 	std::map<YulString, size_t> m_referenceCounts;
 	std::set<YulString> m_varsToAlwaysRematerialize;
+	bool m_onlySelectedVariables = false;
 };
 
 /**

libyul/optimiser/StackCompressor.cpp

@@ -27,6 +27,13 @@
 #include <libyul/optimiser/Metrics.h>
 #include <libyul/optimiser/Semantics.h>
 
+#include <libyul/backends/evm/ControlFlowGraphBuilder.h>
+#include <libyul/backends/evm/StackHelpers.h>
+#include <libyul/backends/evm/StackLayoutGenerator.h>
+
+#include <libyul/AsmAnalysis.h>
+#include <libyul/AsmAnalysisInfo.h>
+
 #include <libyul/CompilabilityChecker.h>
 
 #include <libyul/AST.h>
@@ -150,6 +157,40 @@ void eliminateVariables(
 	UnusedPruner::runUntilStabilised(_dialect, _node, _allowMSizeOptimization);
 }
 
+void eliminateVariables(
+	Dialect const& _dialect,
+	Block& _block,
+	vector<StackLayoutGenerator::StackTooDeep> const& _unreachables,
+	bool _allowMSizeOptimization
+)
+{
+	RematCandidateSelector selector{_dialect};
+	selector(_block);
+	std::map<YulString, size_t> candidates;
+	for (auto [cost, name, dependencies]: selector.candidates())
+		candidates[name] = cost;
+
+	set<YulString> varsToEliminate;
+
+	for (auto const& unreachable: _unreachables)
+	{
+		set<tuple<size_t, YulString>> suitableCandidates;
+		size_t neededSlots = unreachable.deficit;
+		for (auto varName: unreachable.variableChoices)
+		{
+			if (varsToEliminate.count(varName))
+				--neededSlots;
+			else if (size_t* cost = util::valueOrNullptr(candidates, varName))
+				suitableCandidates.insert(std::make_tuple(*cost, varName));
+		}
+
+		for (auto candidate: suitableCandidates | ranges::views::take(neededSlots))
+			varsToEliminate.emplace(get<1>(candidate));
+	}
+	Rematerialiser::run(_dialect, _block, std::move(varsToEliminate), true);
+	UnusedPruner::runUntilStabilised(_dialect, _block, _allowMSizeOptimization);
+}
+
 }
 
 bool StackCompressor::run(
@@ -164,7 +205,31 @@ bool StackCompressor::run(
 		_object.code->statements.size() > 0 && holds_alternative<Block>(_object.code->statements.at(0)),
 		"Need to run the function grouper before the stack compressor."
 	);
+	bool usesOptimizedCodeGenerator = false;
+	if (auto evmDialect = dynamic_cast<EVMDialect const*>(&_dialect))
+		usesOptimizedCodeGenerator = _optimizeStackAllocation && evmDialect->evmVersion() > langutil::EVMVersion::homestead();
 	bool allowMSizeOptimzation = !MSizeFinder::containsMSize(_dialect, *_object.code);
+	if (usesOptimizedCodeGenerator)
+	{
+		yul::AsmAnalysisInfo analysisInfo = yul::AsmAnalyzer::analyzeStrictAssertCorrect(_dialect, _object);
+		unique_ptr<CFG> cfg = ControlFlowGraphBuilder::build(analysisInfo, _dialect, *_object.code);
+		Block& mainBlock = std::get<Block>(_object.code->statements.at(0));
+		if (
+			auto stackTooDeepErrors = StackLayoutGenerator::reportStackTooDeep(*cfg, YulString{});
+			!stackTooDeepErrors.empty()
+		)
+			eliminateVariables(_dialect, mainBlock, stackTooDeepErrors, allowMSizeOptimzation);
+		for (size_t i = 1; i < _object.code->statements.size(); ++i)
+		{
+			auto& fun = std::get<FunctionDefinition>(_object.code->statements[i]);
+			if (
+				auto stackTooDeepErrors = StackLayoutGenerator::reportStackTooDeep(*cfg, fun.name);
+				!stackTooDeepErrors.empty()
+			)
+				eliminateVariables(_dialect, fun.body, stackTooDeepErrors, allowMSizeOptimzation);
+		}
+	}
+	else
 		for (size_t iterations = 0; iterations < _maxIterations; iterations++)
 		{
 			map<YulString, int> stackSurplus = CompilabilityChecker(_dialect, _object, _optimizeStackAllocation).stackDeficit;

libyul/optimiser/StackLimitEvader.cpp

@@ -21,14 +21,18 @@
 #include <libyul/optimiser/FunctionDefinitionCollector.h>
 #include <libyul/optimiser/NameDispenser.h>
 #include <libyul/optimiser/StackToMemoryMover.h>
+#include <libyul/backends/evm/ControlFlowGraphBuilder.h>
 #include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/AsmAnalysis.h>
 #include <libyul/AST.h>
+#include <libyul/CompilabilityChecker.h>
 #include <libyul/Exceptions.h>
 #include <libyul/Object.h>
 #include <libyul/Utilities.h>
 #include <libsolutil/Algorithms.h>
 #include <libsolutil/CommonData.h>
 
+#include <range/v3/range/conversion.hpp>
 #include <range/v3/view/concat.hpp>
 #include <range/v3/view/take.hpp>
 
@@ -114,6 +118,45 @@ u256 literalArgumentValue(FunctionCall const& _call)
 }
 }
 
+void StackLimitEvader::run(
+	OptimiserStepContext& _context,
+	Object& _object
+)
+{
+	auto const* evmDialect = dynamic_cast<EVMDialect const*>(&_context.dialect);
+	yulAssert(
+		evmDialect && evmDialect->providesObjectAccess(),
+		"StackLimitEvader can only be run on objects using the EVMDialect with object access."
+	);
+	if (evmDialect && evmDialect->evmVersion() > langutil::EVMVersion::homestead())
+	{
+		yul::AsmAnalysisInfo analysisInfo = yul::AsmAnalyzer::analyzeStrictAssertCorrect(*evmDialect, _object);
+		unique_ptr<CFG> cfg = ControlFlowGraphBuilder::build(analysisInfo, *evmDialect, *_object.code);
+		run(_context, _object, StackLayoutGenerator::reportStackTooDeep(*cfg));
+	}
+	else
+		run(_context, _object, CompilabilityChecker{
+			_context.dialect,
+			_object,
+			true
+		}.unreachableVariables);
+
+}
+
+void StackLimitEvader::run(
+	OptimiserStepContext& _context,
+	Object& _object,
+	map<YulString, vector<StackLayoutGenerator::StackTooDeep>> const& _stackTooDeepErrors
+)
+{
+	map<YulString, set<YulString>> unreachableVariables;
+	for (auto&& [function, stackTooDeepErrors]: _stackTooDeepErrors)
+		// TODO: choose wisely.
+		for (auto const& stackTooDeepError: stackTooDeepErrors)
+			unreachableVariables[function] += stackTooDeepError.variableChoices | ranges::views::take(stackTooDeepError.deficit) | ranges::to<set<YulString>>;
+	run(_context, _object, unreachableVariables);
+}
+
 void StackLimitEvader::run(
 	OptimiserStepContext& _context,
 	Object& _object,

libyul/optimiser/StackLimitEvader.h

@@ -22,6 +22,7 @@
 #pragma once
 
 #include <libyul/optimiser/OptimiserStep.h>
+#include <libyul/backends/evm/StackLayoutGenerator.h>
 
 namespace solidity::yul
 {
@@ -61,6 +62,25 @@ public:
 		Object& _object,
 		std::map<YulString, std::set<YulString>> const& _unreachableVariables
 	);
+	/// @a _stackTooDeepErrors can be determined by the StackLayoutGenerator.
+	/// Can only be run on the EVM dialect with objects.
+	/// Abort and do nothing, if no ``memoryguard`` call or several ``memoryguard`` calls
+	/// with non-matching arguments are found, or if any of the @a _stackTooDeepErrors
+	/// are contained in a recursive function.
+	static void run(
+		OptimiserStepContext& _context,
+		Object& _object,
+		std::map<YulString, std::vector<StackLayoutGenerator::StackTooDeep>> const& _stackTooDeepErrors
+	);
+	/// Determines stack too deep errors using the appropriate code generation backend.
+	/// Can only be run on the EVM dialect with objects.
+	/// Abort and do nothing, if no ``memoryguard`` call or several ``memoryguard`` calls
+	/// with non-matching arguments are found, or if any of the unreachable variables
+	/// are contained in a recursive function.
+	static void run(
+		OptimiserStepContext& _context,
+		Object& _object
+	);
 };
 
 }

libyul/optimiser/Suite.cpp

@@ -92,6 +92,11 @@ void OptimiserSuite::run(
 	set<YulString> const& _externallyUsedIdentifiers
 )
 {
+	EVMDialect const* evmDialect = dynamic_cast<EVMDialect const*>(&_dialect);
+	bool usesOptimizedCodeGenerator =
+		_optimizeStackAllocation &&
+		evmDialect &&
+		evmDialect->evmVersion() > langutil::EVMVersion::homestead();
 	set<YulString> reservedIdentifiers = _externallyUsedIdentifiers;
 	reservedIdentifiers += _dialect.fixedFunctionNames();
 
@@ -118,6 +123,7 @@ void OptimiserSuite::run(
 
 	// We ignore the return value because we will get a much better error
 	// message once we perform code generation.
+	if (!usesOptimizedCodeGenerator)
 		StackCompressor::run(
 			_dialect,
 			_object,
@@ -126,16 +132,23 @@ void OptimiserSuite::run(
 		);
 	suite.runSequence("fDnTOc g", ast);
 
-	if (EVMDialect const* dialect = dynamic_cast<EVMDialect const*>(&_dialect))
+	if (evmDialect)
 	{
 		yulAssert(_meter, "");
-		ConstantOptimiser{*dialect, *_meter}(ast);
-		if (dialect->providesObjectAccess() && _optimizeStackAllocation)
-			StackLimitEvader::run(suite.m_context, _object, CompilabilityChecker{
+		ConstantOptimiser{*evmDialect, *_meter}(ast);
+		if (usesOptimizedCodeGenerator)
+		{
+			StackCompressor::run(
 				_dialect,
 				_object,
-				_optimizeStackAllocation
-			}.unreachableVariables);
+				_optimizeStackAllocation,
+				stackCompressorMaxIterations
+			);
+			if (evmDialect->providesObjectAccess())
+				StackLimitEvader::run(suite.m_context, _object);
+		}
+		else if (evmDialect->providesObjectAccess() && _optimizeStackAllocation)
+			StackLimitEvader::run(suite.m_context, _object);
 	}
 	else if (dynamic_cast<WasmDialect const*>(&_dialect))
 	{

test/libyul/StackShufflingTest.cpp

@@ -29,6 +29,25 @@ using namespace std;
 namespace solidity::yul::test
 {
 
+namespace
+{
+bool triggersStackTooDeep(Stack _source, Stack const& _target)
+{
+	bool result = false;
+	createStackLayout(_source, _target, [&](unsigned _i) {
+		if (_i > 16)
+			result = true;
+	}, [&](StackSlot const& _slot) {
+		if (canBeFreelyGenerated(_slot))
+			return;
+		if (auto depth = util::findOffset(_source | ranges::views::reverse, _slot); depth && *depth >= 16)
+			if (*depth >= 16)
+				result = true;
+	}, [&]() {});
+	return result;
+}
+}
+
 BOOST_AUTO_TEST_SUITE(StackHelpers)
 
 BOOST_AUTO_TEST_CASE(avoid_deep_dup)
@@ -74,8 +93,7 @@ BOOST_AUTO_TEST_CASE(avoid_deep_dup)
 		VariableSlot{variableContainer[14]}, // While "optimal", bringing this slot up first will make the next unreachable.
 		VariableSlot{variableContainer[0]}
 	}};
-	auto unreachable = OptimizedEVMCodeTransform::tryCreateStackLayout(from, to, {});
-	BOOST_CHECK(unreachable.empty());
+	BOOST_CHECK(!triggersStackTooDeep(from, to));
 }
 
 BOOST_AUTO_TEST_SUITE_END()