Stack layout generator for new code generation.

libyul/CMakeLists.txt

@@ -68,6 +68,9 @@ add_library(yul
 	backends/evm/EVMMetrics.h
 	backends/evm/NoOutputAssembly.h
 	backends/evm/NoOutputAssembly.cpp
+	backends/evm/StackHelpers.h
+	backends/evm/StackLayoutGenerator.h
+	backends/evm/StackLayoutGenerator.cpp
 	backends/evm/VariableReferenceCounter.h
 	backends/evm/VariableReferenceCounter.cpp
 	backends/wasm/EVMToEwasmTranslator.cpp

libyul/backends/evm/StackHelpers.h

@@ -0,0 +1,283 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libyul/backends/evm/ControlFlowGraph.h>
+#include <libyul/Exceptions.h>
+
+#include <libsolutil/Visitor.h>
+
+#include <range/v3/algorithm/all_of.hpp>
+#include <range/v3/view/enumerate.hpp>
+#include <range/v3/view/iota.hpp>
+#include <range/v3/view/reverse.hpp>
+#include <range/v3/view/take.hpp>
+
+namespace solidity::yul
+{
+
+inline std::string stackSlotToString(StackSlot const& _slot)
+{
+	return std::visit(util::GenericVisitor{
+		[](FunctionCallReturnLabelSlot const& _ret) -> std::string { return "RET[" + _ret.call.get().functionName.name.str() + "]"; },
+		[](FunctionReturnLabelSlot const&) -> std::string { return "RET"; },
+		[](VariableSlot const& _var) { return _var.variable.get().name.str(); },
+		[](LiteralSlot const& _lit) { return util::toCompactHexWithPrefix(_lit.value); },
+		[](TemporarySlot const& _tmp) -> std::string { return "TMP[" + _tmp.call.get().functionName.name.str() + ", " + std::to_string(_tmp.index) + "]"; },
+		[](JunkSlot const&) -> std::string { return "JUNK"; }
+	}, _slot);
+}
+
+inline std::string stackToString(Stack const& _stack)
+{
+	std::string result("[ ");
+	for (auto const& slot: _stack)
+		result += stackSlotToString(slot) + ' ';
+	result += ']';
+	return result;
+}
+
+template<typename ShuffleOperations>
+class Shuffler
+{
+public:
+	template<typename... Args>
+	static void shuffle(Args&&... args)
+	{
+		bool needsMoreShuffling = true;
+		size_t iterationCount = 0;
+		while (iterationCount < 1000 && (needsMoreShuffling = shuffleStep(std::forward<Args>(args)...)))
+			++iterationCount;
+		yulAssert(!needsMoreShuffling, "Could not create stack layout after 1000 iterations.");
+	}
+private:
+	template<typename... Args>
+	static bool shuffleStep(Args&&... args)
+	{
+		ShuffleOperations ops{std::forward<Args>(args)...};
+
+		if (ranges::all_of(
+			ranges::views::iota(0u, ops.sourceSize()),
+			[&](size_t _index) { return ops.isCompatible(_index, _index); }
+		))
+			return false;
+
+		size_t sourceTop = ops.sourceSize() - 1;
+		// If we no longer need the current stack top, we pop it, unless we need an arbitrary slot at this position
+		// in the target.
+		if (
+			ops.sourceMultiplicity(sourceTop) < 0 &&
+			!(ops.targetSize() >= ops.sourceSize() && ops.targetIsArbitrary(sourceTop))
+		)
+		{
+			ops.pop();
+			return true;
+		}
+
+		yulAssert(ops.targetSize() > 0, "");
+
+		// If the top is not supposed to be exactly what is on top right now, try to find a lower position to swap it to.
+		if (!ops.isCompatible(sourceTop, sourceTop) || ops.targetIsArbitrary(sourceTop))
+			for (size_t offset: ranges::views::iota(0u, std::min(ops.sourceSize(), ops.targetSize())))
+				// It makes sense to swap to a lower position, if
+				if (
+					!ops.isCompatible(offset, offset) && // The lower slot is not already in position.
+					!ops.sourceIsSame(offset, sourceTop) && // We would not just swap identical slots.
+					ops.isCompatible(sourceTop, offset) // The lower position wants to have this slot.
+				)
+				{
+					ops.swap(ops.sourceSize() - offset - 1);
+					return true;
+				}
+
+		auto bringUpTargetSlot = [&](size_t _targetOffset) {
+			std::list<size_t> toVisit{_targetOffset};
+			std::set<size_t> visited;
+
+			while (!toVisit.empty())
+			{
+				auto offset = *toVisit.begin();
+				toVisit.erase(toVisit.begin());
+				visited.emplace(offset);
+				if (ops.targetMultiplicity(offset) > 0)
+				{
+					ops.pushOrDupTarget(offset);
+					return;
+				}
+				// The desired target slot must already be somewhere else on stack right now.
+				for (auto nextOffset: ranges::views::iota(0u, std::min(ops.sourceSize(), ops.targetSize())))
+					if (
+						!ops.isCompatible(nextOffset, nextOffset) &&
+						ops.isCompatible(nextOffset, offset)
+					)
+					if (!visited.count(nextOffset))
+						toVisit.emplace_back(nextOffset);
+			}
+			yulAssert(false, "");
+		};
+
+		// If a lower slot should be removed, try to bring up the slot that should end up there and bring it up.
+		// Note that after the cases above, there will always be a target slot to duplicate in this case.
+		for (size_t offset: ranges::views::iota(0u, ops.sourceSize()))
+			if (
+				!ops.isCompatible(offset, offset) && // The lower slot is not already in position.
+				ops.sourceMultiplicity(offset) < 0 && // We have too many copies of this slot.
+				offset <= ops.targetSize() && // There is a target slot at this position.
+				!ops.targetIsArbitrary(offset) // And that target slot is not arbitrary.
+			)
+			{
+				bringUpTargetSlot(offset);
+				return true;
+			}
+
+		// At this point we want to keep all slots.
+		for (size_t i = 0; i < ops.sourceSize(); ++i)
+			yulAssert(ops.sourceMultiplicity(i) >= 0, "");
+		yulAssert(ops.sourceSize() <= ops.targetSize(), "");
+
+		// If the top is not in position, try to find a slot that wants to be at the top and swap it up.
+		if (!ops.isCompatible(sourceTop, sourceTop))
+			for (size_t sourceOffset: ranges::views::iota(0u, ops.sourceSize()))
+				if (
+					!ops.isCompatible(sourceOffset, sourceOffset) &&
+					ops.isCompatible(sourceOffset, sourceTop)
+				)
+				{
+					ops.swap(ops.sourceSize() - sourceOffset - 1);
+					return true;
+				}
+
+		// If we still need more slots, produce a suitable one.
+		if (ops.sourceSize() < ops.targetSize())
+		{
+			bringUpTargetSlot(ops.sourceSize());
+			return true;
+		}
+
+		// The stack has the correct size, each slot has the correct number of copies and the top is in position.
+		yulAssert(ops.sourceSize() == ops.targetSize(), "");
+		size_t size = ops.sourceSize();
+		for (size_t i = 0; i < ops.sourceSize(); ++i)
+			yulAssert(ops.sourceMultiplicity(i) == 0 && (ops.targetIsArbitrary(i) || ops.targetMultiplicity(i) == 0), "");
+		yulAssert(ops.isCompatible(sourceTop, sourceTop), "");
+
+		// If we find a lower slot that is out of position, but also compatible with the top, swap that up.
+		for (size_t offset: ranges::views::iota(0u, size))
+			if (!ops.isCompatible(offset, offset) && ops.isCompatible(sourceTop, offset))
+			{
+				ops.swap(size - offset - 1);
+				return true;
+			}
+		// Swap up any slot that is still out of position.
+		for (size_t offset: ranges::views::iota(0u, size))
+			if (!ops.isCompatible(offset, offset) && !ops.sourceIsSame(offset, sourceTop))
+			{
+				ops.swap(size - offset - 1);
+				return true;
+			}
+		yulAssert(false, "");
+	}
+};
+
+template<typename Swap, typename PushOrDup, typename Pop>
+void createStackLayout(Stack& _currentStack, Stack const& _targetStack, Swap _swap, PushOrDup _pushOrDup, Pop _pop)
+{
+	struct ShuffleOperations
+	{
+		Stack& currentStack;
+		Stack const& targetStack;
+		Swap swapCallback;
+		PushOrDup pushOrDupCallback;
+		Pop popCallback;
+		std::map<StackSlot, int> multiplicity;
+		ShuffleOperations(
+			Stack& _currentStack,
+			Stack const& _targetStack,
+			Swap _swap,
+			PushOrDup _pushOrDup,
+			Pop _pop
+		):
+			currentStack(_currentStack),
+			targetStack(_targetStack),
+			swapCallback(_swap),
+			pushOrDupCallback(_pushOrDup),
+			popCallback(_pop)
+		{
+			for (auto const& slot: currentStack)
+				--multiplicity[slot];
+			for (auto&& [offset, slot]: targetStack | ranges::views::enumerate)
+				if (std::holds_alternative<JunkSlot>(slot) && offset < currentStack.size())
+					++multiplicity[currentStack.at(offset)];
+				else
+					++multiplicity[slot];
+		}
+		bool isCompatible(size_t _source, size_t _target)
+		{
+			return
+				_source < currentStack.size() &&
+				_target < targetStack.size() &&
+				(
+					std::holds_alternative<JunkSlot>(targetStack.at(_target)) ||
+					currentStack.at(_source) == targetStack.at(_target)
+				);
+		}
+		bool sourceIsSame(size_t _lhs, size_t _rhs) { return currentStack.at(_lhs) == currentStack.at(_rhs); }
+		int sourceMultiplicity(size_t _offset) { return multiplicity.at(currentStack.at(_offset)); }
+		int targetMultiplicity(size_t _offset) { return multiplicity.at(targetStack.at(_offset)); }
+		bool targetIsArbitrary(size_t offset)
+		{
+			return offset < targetStack.size() && std::holds_alternative<JunkSlot>(targetStack.at(offset));
+		}
+		void swap(size_t _i)
+		{
+			swapCallback(static_cast<unsigned>(_i));
+			std::swap(currentStack.at(currentStack.size() -  _i - 1), currentStack.back());
+		}
+		size_t sourceSize() { return currentStack.size(); }
+		size_t targetSize() { return targetStack.size(); }
+		void pop()
+		{
+			popCallback();
+			currentStack.pop_back();
+		}
+		void pushOrDupTarget(size_t _offset)
+		{
+			auto const& targetSlot = targetStack.at(_offset);
+			pushOrDupCallback(targetSlot);
+			currentStack.push_back(targetSlot);
+		}
+	};
+
+	Shuffler<ShuffleOperations>::shuffle(_currentStack, _targetStack, _swap, _pushOrDup, _pop);
+
+	while (_currentStack.size() < _targetStack.size())
+	{
+		_pushOrDup(_targetStack.at(_currentStack.size()));
+		_currentStack.push_back(_targetStack.at(_currentStack.size()));
+	}
+
+	yulAssert(_currentStack.size() == _targetStack.size(), "");
+	for (auto&& [current, target]: ranges::zip_view(_currentStack, _targetStack))
+		if (std::holds_alternative<JunkSlot>(target))
+			current = JunkSlot{};
+		else
+			yulAssert(current == target, "");
+}
+
+}

libyul/backends/evm/StackLayoutGenerator.cpp

@@ -0,0 +1,529 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Stack layout generator for Yul to EVM code generation.
+ */
+
+#include <libyul/backends/evm/StackLayoutGenerator.h>
+
+#include <libyul/backends/evm/StackHelpers.h>
+
+#include <libsolutil/Algorithms.h>
+#include <libsolutil/cxx20.h>
+#include <libsolutil/Visitor.h>
+
+#include <range/v3/algorithm/any_of.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/view/all.hpp>
+#include <range/v3/view/concat.hpp>
+#include <range/v3/view/drop.hpp>
+#include <range/v3/view/drop_last.hpp>
+#include <range/v3/view/filter.hpp>
+#include <range/v3/view/iota.hpp>
+#include <range/v3/view/map.hpp>
+#include <range/v3/view/reverse.hpp>
+#include <range/v3/view/take.hpp>
+#include <range/v3/view/transform.hpp>
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace std;
+
+StackLayoutGenerator::StackLayoutGenerator(StackLayout& _layout): m_layout(_layout)
+{
+}
+
+namespace
+{
+struct PreviousSlot { size_t slot; };
+
+template<typename Callable>
+Stack createIdealLayout(Stack const& _post, vector<variant<PreviousSlot, StackSlot>> _layout, Callable _generateSlotOnTheFly)
+{
+	if (_layout.empty())
+		return Stack{};
+
+	struct ShuffleOperations
+	{
+		vector<variant<PreviousSlot, StackSlot>>& layout;
+		Stack const& post;
+		std::set<StackSlot> outputs;
+		std::map<StackSlot, int> multiplicity;
+		Callable generateSlotOnTheFly;
+		ShuffleOperations(
+			vector<variant<PreviousSlot, StackSlot>>& _layout,
+			Stack const& _post,
+			Callable _generateSlotOnTheFly
+		): layout(_layout), post(_post), generateSlotOnTheFly(_generateSlotOnTheFly)
+		{
+			for (auto const& layoutSlot: layout)
+				if (StackSlot const* slot = get_if<StackSlot>(&layoutSlot))
+					outputs.insert(*slot);
+
+			for (auto const& layoutSlot: layout)
+				if (StackSlot const* slot = get_if<StackSlot>(&layoutSlot))
+					--multiplicity[*slot];
+			for (auto&& slot: post)
+				if (outputs.count(slot) || generateSlotOnTheFly(slot))
+					++multiplicity[slot];
+		}
+		bool isCompatible(size_t _source, size_t _target)
+		{
+			return
+				_source < layout.size() &&
+				_target < post.size() &&
+				(
+					std::holds_alternative<JunkSlot>(post.at(_target)) ||
+					std::visit(util::GenericVisitor{
+						[&](PreviousSlot const&) {
+							return !outputs.count(post.at(_target)) && !generateSlotOnTheFly(post.at(_target));
+						},
+						[&](StackSlot const& _s) { return _s == post.at(_target); }
+					}, layout.at(_source))
+				);
+		}
+		bool sourceIsSame(size_t _lhs, size_t _rhs)
+		{
+			return std::visit(util::GenericVisitor{
+				[&](PreviousSlot const&, PreviousSlot const&) { return true; },
+				[&](StackSlot const& _lhs, StackSlot const& _rhs) { return _lhs == _rhs; },
+				[&](auto const&, auto const&) { return false; }
+			}, layout.at(_lhs), layout.at(_rhs));
+		}
+		int sourceMultiplicity(size_t _offset)
+		{
+			return std::visit(util::GenericVisitor{
+				[&](PreviousSlot const&) { return 0; },
+				[&](StackSlot const& _s) { return multiplicity.at(_s); }
+			}, layout.at(_offset));
+		}
+		int targetMultiplicity(size_t _offset)
+		{
+			if (!outputs.count(post.at(_offset)) && !generateSlotOnTheFly(post.at(_offset)))
+				return 0;
+			return multiplicity.at(post.at(_offset));
+		}
+		bool targetIsArbitrary(size_t _offset)
+		{
+			return _offset < post.size() && std::holds_alternative<JunkSlot>(post.at(_offset));
+		}
+		void swap(size_t _i)
+		{
+			yulAssert(!holds_alternative<PreviousSlot>(layout.at(layout.size() - _i - 1)) || !holds_alternative<PreviousSlot>(layout.back()), "");
+			std::swap(layout.at(layout.size() -  _i - 1), layout.back());
+		}
+		size_t sourceSize() { return layout.size(); }
+		size_t targetSize() { return post.size(); }
+		void pop() { layout.pop_back(); }
+		void pushOrDupTarget(size_t _offset) { layout.push_back(post.at(_offset)); }
+	};
+
+	Shuffler<ShuffleOperations>::shuffle(_layout, _post, _generateSlotOnTheFly);
+
+	// Now we can construct the ideal layout before the operation.
+	// "layout" has the declared variables in the desired position and
+	// for any PreviousSlot{x}, x yields the ideal place of the slot before the declaration.
+	vector<optional<StackSlot>> idealLayout(_post.size(), nullopt);
+	for (auto const& [slot, idealPosition]: ranges::zip_view(_post, _layout))
+		if (PreviousSlot* previousSlot = std::get_if<PreviousSlot>(&idealPosition))
+			idealLayout.at(previousSlot->slot) = slot;
+
+	while (!idealLayout.empty() && !idealLayout.back())
+		idealLayout.pop_back();
+
+	return idealLayout | ranges::views::transform([](optional<StackSlot> s) {
+		yulAssert(s, "");
+		return *s;
+	}) | ranges::to<Stack>;
+}
+}
+
+Stack StackLayoutGenerator::propagateStackThroughOperation(Stack _exitStack, CFG::Operation const& _operation)
+{
+	Stack& stack = _exitStack;
+
+	// This is a huge tradeoff between code size, gas cost and stack size.
+	auto generateSlotOnTheFly = [&](StackSlot const&) {
+		//return stack.size() > 12 && canBeFreelyGenerated(_slot);
+		// return canBeFreelyGenerated(_slot);
+		return false;
+	};
+
+	size_t previousLayoutSize = stack.size();
+	for (auto const& slot: stack)
+		if (util::findOffset(_operation.output, slot) || generateSlotOnTheFly(slot))
+				--previousLayoutSize;
+
+	auto layout = ranges::views::iota(0u, previousLayoutSize) |
+		ranges::views::transform([](size_t _index) { return PreviousSlot{_index}; }) |
+		ranges::to<vector<variant<PreviousSlot, StackSlot>>>;
+	// The call produces a known sequence of values.
+	layout += _operation.output;
+
+	stack = createIdealLayout(stack, layout, generateSlotOnTheFly);
+
+	if (auto const* assignment = get_if<CFG::Assignment>(&_operation.operation))
+		for (auto& stackSlot: stack)
+			if (auto const* varSlot = get_if<VariableSlot>(&stackSlot))
+				yulAssert(!util::findOffset(assignment->variables, *varSlot), "");
+
+	for (StackSlot const& input: _operation.input)
+		stack.emplace_back(input);
+
+	m_layout.operationEntryLayout[&_operation] = stack;
+
+	// Remove anything from the stack top that can be freely generated or dupped from deeper on the stack.
+	while (!stack.empty())
+	{
+		if (canBeFreelyGenerated(stack.back()))
+			stack.pop_back();
+		else if (auto offset = util::findOffset(stack | ranges::views::reverse | ranges::views::drop(1), stack.back()))
+		{
+			if (*offset + 2 < 16)
+				stack.pop_back();
+			else
+				break;
+		}
+		else
+			break;
+	}
+
+	// TODO: there may be a better criterion than overall stack size.
+	if (stack.size() > 12)
+		// Deduplicate and remove slots that can be freely generated.
+		stack = compressStack(move(stack));
+	return stack;
+}
+
+Stack StackLayoutGenerator::compressStack(Stack _stack)
+{
+	optional<size_t> firstDupOffset;
+	do
+	{
+		if (firstDupOffset)
+		{
+			if (_stack.size() - *firstDupOffset - 1 > 1)
+				std::swap(_stack.at(*firstDupOffset + 1), _stack.back());
+			std::swap(_stack.at(*firstDupOffset), _stack.back());
+			_stack.pop_back();
+			firstDupOffset.reset();
+		}
+		for (auto&& [offset, slot]: _stack | ranges::views::enumerate)
+			if (canBeFreelyGenerated(slot) || util::findOffset(_stack | ranges::views::take(offset), slot))
+				firstDupOffset = offset;
+	}
+	while (firstDupOffset);
+	return _stack;
+}
+
+Stack StackLayoutGenerator::propagateStackThroughBlock(Stack _exitStack, CFG::BasicBlock const& _block)
+{
+	Stack stack = std::move(_exitStack);
+	for (auto& operation: _block.operations | ranges::views::reverse)
+		stack = propagateStackThroughOperation(stack, operation);
+	return stack;
+}
+
+void StackLayoutGenerator::processEntryPoint(CFG::BasicBlock const& _entry)
+{
+	std::list<CFG::BasicBlock const*> toVisit{&_entry};
+	std::set<CFG::BasicBlock const*> visited;
+
+	while (!toVisit.empty())
+	{
+		// TODO: calculate backwardsJumps only once.
+		std::list<std::pair<CFG::BasicBlock const*, CFG::BasicBlock const*>> backwardsJumps;
+		while (!toVisit.empty())
+		{
+			CFG::BasicBlock const *block = *toVisit.begin();
+			toVisit.pop_front();
+
+			if (visited.count(block))
+				continue;
+
+			if (std::optional<Stack> exitLayout = std::visit(util::GenericVisitor{
+				[&](CFG::BasicBlock::MainExit const&) -> std::optional<Stack>
+				{
+					visited.emplace(block);
+					return Stack{};
+				},
+				[&](CFG::BasicBlock::Jump const& _jump) -> std::optional<Stack>
+				{
+					if (_jump.backwards)
+					{
+						visited.emplace(block);
+						backwardsJumps.emplace_back(block, _jump.target);
+						if (auto* info = util::valueOrNullptr(m_layout.blockInfos, _jump.target))
+							return info->entryLayout;
+						return Stack{};
+					}
+					if (visited.count(_jump.target))
+					{
+						visited.emplace(block);
+						return m_layout.blockInfos.at(_jump.target).entryLayout;
+					}
+					toVisit.emplace_front(_jump.target);
+					return nullopt;
+				},
+				[&](CFG::BasicBlock::ConditionalJump const& _conditionalJump) -> std::optional<Stack>
+				{
+					bool zeroVisited = visited.count(_conditionalJump.zero);
+					bool nonZeroVisited = visited.count(_conditionalJump.nonZero);
+					if (zeroVisited && nonZeroVisited)
+					{
+						Stack stack = combineStack(
+							m_layout.blockInfos.at(_conditionalJump.zero).entryLayout,
+							m_layout.blockInfos.at(_conditionalJump.nonZero).entryLayout
+						);
+						stack.emplace_back(_conditionalJump.condition);
+						visited.emplace(block);
+						return stack;
+					}
+					if (!zeroVisited)
+						toVisit.emplace_front(_conditionalJump.zero);
+					if (!nonZeroVisited)
+						toVisit.emplace_front(_conditionalJump.nonZero);
+					return nullopt;
+				},
+				[&](CFG::BasicBlock::FunctionReturn const& _functionReturn) -> std::optional<Stack>
+				{
+					visited.emplace(block);
+					yulAssert(_functionReturn.info, "");
+					Stack stack = _functionReturn.info->returnVariables | ranges::views::transform([](auto const& _varSlot){
+						return StackSlot{_varSlot};
+					}) | ranges::to<Stack>;
+					stack.emplace_back(FunctionReturnLabelSlot{});
+					return stack;
+				},
+				[&](CFG::BasicBlock::Terminated const&) -> std::optional<Stack>
+				{
+					visited.emplace(block);
+					return Stack{};
+				},
+			}, block->exit))
+			{
+				// We can skip the visit, if we have seen this precise exit layout already last time.
+				// Note: if the entire graph is revisited in the backwards jump check below, doing
+				//       this seems to break things; not sure why.
+				// Note: since I don't quite understand why doing this can break things, I comment
+				//       it out for now, since not aborting in those cases should always be safe.
+				// if (auto* previousInfo = util::valueOrNullptr(m_layout.blockInfos, block))
+				//	if (previousInfo->exitLayout == *exitLayout)
+				//		continue;
+				auto& info = m_layout.blockInfos[block];
+				info.exitLayout = *exitLayout;
+				info.entryLayout = propagateStackThroughBlock(info.exitLayout, *block);
+
+				for (auto entry: block->entries)
+					toVisit.emplace_back(entry);
+			}
+			else
+				continue;
+		}
+
+		for (auto [block, target]: backwardsJumps)
+			if (ranges::any_of(
+				m_layout.blockInfos[target].entryLayout,
+				[exitLayout = m_layout.blockInfos[block].exitLayout](StackSlot const& _slot) {
+					return !util::findOffset(exitLayout, _slot);
+				}
+			))
+			{
+				// This block jumps backwards, but does not provide all slots required by the jump target on exit.
+				// Therefore we need to visit the subgraph between ``target`` and ``block`` again.
+				// In particular we can visit backwards starting from ``block`` and mark all entries to-be-visited-
+				// again until we hit ``target``.
+				toVisit.emplace_front(block);
+				// Since we are likely to change the entry layout of ``target``, we also visit its entries again.
+				for (CFG::BasicBlock const* entry: target->entries)
+					visited.erase(entry);
+				util::BreadthFirstSearch<CFG::BasicBlock const*>{{block}}.run(
+					[&visited, target = target](CFG::BasicBlock const* _block, auto _addChild) {
+						visited.erase(_block);
+						if (_block == target)
+							return;
+						for (auto const* entry: _block->entries)
+							_addChild(entry);
+					}
+				);
+				// TODO: while the above is enough, the layout of ``target`` might change in the process.
+				// While the shuffled layout for ``target`` will be compatible, it can be worthwhile propagating
+				// it further up once more.
+				// This would mean not stopping at _block == target above or even doing visited.clear() here, revisiting the entire graph.
+				// This is a tradeoff between the runtime of this process and the optimality of the result.
+				// Also note that while visiting the entire graph again *can* be helpful, it can also be detrimental.
+				// Also note that for some reason using visited.clear() is incompatible with skipping the revisit
+				// of already seen exit layouts above, I'm not sure yet why.
+			}
+	}
+
+	stitchConditionalJumps(_entry);
+	fixStackTooDeep(_entry);
+}
+
+Stack StackLayoutGenerator::combineStack(Stack const& _stack1, Stack const& _stack2)
+{
+	// TODO: there is probably a better way than brute-forcing. This has n! complexity or worse, so
+	// we can't keep it like this.
+
+	Stack commonPrefix;
+	for (auto&& [slot1, slot2]: ranges::zip_view(_stack1, _stack2))
+	{
+		if (!(slot1 == slot2))
+			break;
+		commonPrefix.emplace_back(slot1);
+	}
+
+	Stack stack1Tail = _stack1 | ranges::views::drop(commonPrefix.size()) | ranges::to<Stack>;
+	Stack stack2Tail = _stack2 | ranges::views::drop(commonPrefix.size()) | ranges::to<Stack>;
+
+	if (stack1Tail.empty())
+		return commonPrefix + compressStack(stack2Tail);
+	if (stack2Tail.empty())
+		return commonPrefix + compressStack(stack1Tail);
+
+	Stack candidate;
+	for (auto slot: stack1Tail)
+		if (!util::findOffset(candidate, slot))
+			candidate.emplace_back(slot);
+	for (auto slot: stack2Tail)
+		if (!util::findOffset(candidate, slot))
+			candidate.emplace_back(slot);
+	cxx20::erase_if(candidate, [](StackSlot const& slot) {
+		return holds_alternative<LiteralSlot>(slot) || holds_alternative<FunctionCallReturnLabelSlot>(slot);
+	});
+
+	std::map<size_t, Stack> sortedCandidates;
+
+	// TODO: surprisingly this works for rather comparably large candidate size, but we should probably
+	// set up some limit, since this will quickly explode otherwise.
+	// Ideally we would then have a better fallback mechanism - although returning any naive union of both stacks
+	// like ``candidate`` itself may just be fine.
+	//	if (candidate.size() > 8)
+	//		return candidate;
+
+	auto evaluate = [&](Stack const& _candidate) -> size_t {
+		size_t numOps = 0;
+		Stack testStack = _candidate;
+		auto swap = [&](unsigned _swapDepth) { ++numOps; if (_swapDepth > 16) numOps += 1000; };
+		auto dupOrPush = [&](StackSlot const& _slot)
+		{
+			if (canBeFreelyGenerated(_slot))
+				return;
+			auto depth = util::findOffset(ranges::concat_view(commonPrefix, testStack) | ranges::views::reverse, _slot);
+			if (depth && *depth >= 16)
+				numOps += 1000;
+		};
+		createStackLayout(testStack, stack1Tail, swap, dupOrPush, [&](){} );
+		testStack = _candidate;
+		createStackLayout(testStack, stack2Tail, swap, dupOrPush, [&](){});
+		return numOps;
+	};
+
+	// See https://en.wikipedia.org/wiki/Heap's_algorithm
+	size_t n = candidate.size();
+	sortedCandidates.insert(std::make_pair(evaluate(candidate), candidate));
+	std::vector<size_t> c(n, 0);
+	size_t i = 1;
+	while (i < n)
+	{
+		if (c[i] < i)
+		{
+			if (i & 1)
+				std::swap(candidate.front(), candidate[i]);
+			else
+				std::swap(candidate[c[i]], candidate[i]);
+			sortedCandidates.insert(std::make_pair(evaluate(candidate), candidate));
+			++c[i];
+			++i;
+		}
+		else
+		{
+			c[i] = 0;
+			++i;
+		}
+	}
+
+	return commonPrefix + sortedCandidates.begin()->second;
+}
+
+void StackLayoutGenerator::stitchConditionalJumps(CFG::BasicBlock const& _block)
+{
+	util::BreadthFirstSearch<CFG::BasicBlock const*> breadthFirstSearch{{&_block}};
+	breadthFirstSearch.run([&](CFG::BasicBlock const* _block, auto _addChild) {
+		auto& info = m_layout.blockInfos.at(_block);
+		std::visit(util::GenericVisitor{
+			[&](CFG::BasicBlock::MainExit const&) {},
+			[&](CFG::BasicBlock::Jump const& _jump)
+			{
+				if (!_jump.backwards)
+					_addChild(_jump.target);
+			},
+			[&](CFG::BasicBlock::ConditionalJump const& _conditionalJump)
+			{
+				auto& zeroTargetInfo = m_layout.blockInfos.at(_conditionalJump.zero);
+				auto& nonZeroTargetInfo = m_layout.blockInfos.at(_conditionalJump.nonZero);
+				Stack exitLayout = info.exitLayout;
+
+				// The last block must have produced the condition at the stack top.
+				yulAssert(!exitLayout.empty(), "");
+				yulAssert(exitLayout.back() == _conditionalJump.condition, "");
+				// The condition is consumed by the jump.
+				exitLayout.pop_back();
+
+				auto fixJumpTargetEntry = [&](Stack const& _originalEntryLayout) -> Stack {
+					Stack newEntryLayout = exitLayout;
+					// Whatever the block being jumped to does not actually require, can be marked as junk.
+					for (auto& slot: newEntryLayout)
+						if (!util::findOffset(_originalEntryLayout, slot))
+							slot = JunkSlot{};
+					// Make sure everything the block being jumped to requires is actually present or can be generated.
+					for (auto const& slot: _originalEntryLayout)
+						yulAssert(canBeFreelyGenerated(slot) || util::findOffset(newEntryLayout, slot), "");
+					return newEntryLayout;
+				};
+				zeroTargetInfo.entryLayout = fixJumpTargetEntry(zeroTargetInfo.entryLayout);
+				nonZeroTargetInfo.entryLayout = fixJumpTargetEntry(nonZeroTargetInfo.entryLayout);
+				_addChild(_conditionalJump.zero);
+				_addChild(_conditionalJump.nonZero);
+			},
+			[&](CFG::BasicBlock::FunctionReturn const&)	{},
+			[&](CFG::BasicBlock::Terminated const&) { },
+		}, _block->exit);
+	});
+}
+
+void StackLayoutGenerator::fixStackTooDeep(CFG::BasicBlock const&)
+{
+	// TODO
+}
+
+StackLayout StackLayoutGenerator::run(CFG const& _cfg)
+{
+	StackLayout stackLayout;
+	StackLayoutGenerator stackLayoutGenerator{stackLayout};
+
+	stackLayoutGenerator.processEntryPoint(*_cfg.entry);
+	for (auto& functionInfo: _cfg.functionInfo | ranges::views::values)
+	{
+		stackLayoutGenerator.m_currentFunctionReturnVariables = functionInfo.returnVariables;
+		stackLayoutGenerator.processEntryPoint(*functionInfo.entry);
+	}
+
+	return stackLayout;
+}

libyul/backends/evm/StackLayoutGenerator.h

@@ -0,0 +1,87 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Stack layout generator for Yul to EVM code generation.
+ */
+
+#pragma once
+
+#include <libyul/backends/evm/ControlFlowGraph.h>
+
+#include <map>
+
+namespace solidity::yul
+{
+
+struct StackLayout
+{
+	struct BlockInfo
+	{
+		/// Complete stack layout that is required for entering a block.
+		Stack entryLayout;
+		/// The resulting stack layout after executing the block.
+		Stack exitLayout;
+	};
+	std::map<CFG::BasicBlock const*, BlockInfo> blockInfos;
+	/// For each operation the complete stack layout that:
+	/// - has the slots required for the operation at the stack top.
+	/// - will have the operation result in a layout that makes it easy to achieve the next desired layout.
+	std::map<CFG::Operation const*, Stack> operationEntryLayout;
+};
+
+class StackLayoutGenerator
+{
+public:
+	static StackLayout run(CFG const& _cfg);
+
+private:
+	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.
+	Stack propagateStackThroughOperation(Stack _exitStack, CFG::Operation const& _operation);
+
+	/// @returns the desired stack layout at the entry of @a _block, assuming the layout after
+	/// executing the block should be @a _exitStack.
+	Stack propagateStackThroughBlock(Stack _exitStack, CFG::BasicBlock const& _block);
+
+	/// Main algorithm walking the graph from entry to exit and propagating back the stack layouts to the entries.
+	/// Iteratively reruns itself along backwards jumps until the layout is stabilized.
+	void processEntryPoint(CFG::BasicBlock const& _entry);
+
+	/// After the main algorithms, layouts at conditional jumps are merely compatible, i.e. the exit layout of the
+	/// jumping block is a superset of the entry layout of the target block. This function modifies the entry layouts
+	/// of conditional jump targets, s.t. the entry layout of target blocks match the exit layout of the jumping block
+	/// exactly, except that slots not required after the jump are marked as `JunkSlot`s.
+	void stitchConditionalJumps(CFG::BasicBlock const& _block);
+
+	/// Calculates the ideal stack layout, s.t. both @a _stack1 and @a _stack2 can be achieved with minimal
+	/// stack shuffling when starting from the returned layout.
+	static Stack combineStack(Stack const& _stack1, Stack const& _stack2);
+
+	/// Tries to detect stack layout transitions that are bound to cause stack too deep errors and
+	/// attempts to reorganize the layout to avoid those cases.
+	void fixStackTooDeep(CFG::BasicBlock const& _entry);
+
+	static Stack compressStack(Stack _stack);
+
+	StackLayout& m_layout;
+	std::vector<VariableSlot> m_currentFunctionReturnVariables;
+};
+
+}