wip

Author: clonker

libyul/backends/evm/SSACFGEVMCodeTransform.h

@@ -43,7 +43,6 @@ class LivenessAnalysis;
 
 struct AssemblyCallbacks
 {
-	using Slot = StackSlot;
 	void swap(size_t const _depth)
 	{
 		assembly->appendInstruction(evmasm::swapInstruction(static_cast<unsigned>(_depth)));
@@ -56,31 +55,39 @@ struct AssemblyCallbacks
 
 	void push(StackSlot const& _slot)
 	{
-		std::visit(util::GenericVisitor{
-			[&](SSACFG::ValueId const& _id)
+		switch (_slot.kind())
+		{
+			case StackSlot::Kind::ValueID:
 			{
-				auto const& info = cfg->valueInfo(_id);
-				yulAssert(std::holds_alternative<SSACFG::LiteralValue>(info), fmt::format("Tried bringing up v{}", _id.value));
+				auto const id = _slot.valueID();
+				auto const& info = cfg->valueInfo(id);
+				yulAssert(
+					std::holds_alternative<SSACFG::LiteralValue>(info),
+					fmt::format("Tried bringing up v{}", id.value));
 				assembly->appendConstant(std::get<SSACFG::LiteralValue>(info).value);
-			},
-			[&](AbstractAssembly::LabelID const _label)
-			{
-				assembly->appendLabelReference(_label);
-			},
-			[&](FunctionReturnLabel const& _label)
-			{
-				auto const* maybeLabel = util::valueOrNullptr(*returnLabels, _label.functionCall);
-				yulAssert(maybeLabel);
-				assembly->appendLabelReference(*maybeLabel);
-			},
-			[&](JunkSlot const&)
+				return;
+			}
+			case StackSlot::Kind::Junk:
 			{
 				if (assembly->evmVersion().hasPush0())
 					assembly->appendConstant(0);
 				else
 					assembly->appendInstruction(evmasm::Instruction::CODESIZE);
+				return;
+			}
+			case StackSlot::Kind::AssemblyLabelID:
+			{
+				assembly->appendLabelReference(_slot.assemblyLabelID());
+				return;
+			}
+			case StackSlot::Kind::FunctionReturnLabel:
+			{
+				auto const* maybeLabel = util::valueOrNullptr(*returnLabels, _label.functionCall);
+				yulAssert(maybeLabel);
+				assembly->appendLabelReference(*maybeLabel);
+				return;
 			}
-		}, _slot);
+		}
 	}
 
 	void dup(size_t const _depth)
@@ -92,12 +99,12 @@ struct AssemblyCallbacks
 	AbstractAssembly* assembly;
 	std::map<FunctionCall const*, AbstractAssembly::LabelID> const* returnLabels;
 };
-static_assert(StackManipulationCallbackConcept<AssemblyCallbacks, StackSlot>);
+static_assert(StackManipulationCallbackConcept<AssemblyCallbacks>);
 
 class SSACFGEVMCodeTransform
 {
 public:
-	using SSACFGStack = Stack<StackSlot, AssemblyCallbacks>;
+	using SSACFGStack = Stack<AssemblyCallbacks>;
 	using Slot = SSACFGStack::Slot;
 	/// Use named labels for functions 1) Yes and check that the names are unique
 	/// 2) For none of the functions 3) for the first function of each name.

libyul/backends/evm/SSACFGStackShuffler.h

@@ -19,7 +19,8 @@
 #pragma once
 
 #include <libyul/backends/evm/StackHelpers.h>
-#include <libyul/backends/evm/SSACFGStack.h>
+
+#include <libyul/backends/evm/ssa/Stack.h>
 
 #include <range/v3/algorithm/find.hpp>
 #include <range/v3/algorithm/find_end.hpp>
@@ -127,12 +128,12 @@ struct BubbleShuffler
 
 template<
 	typename StackType,
-	auto SlotIsCompatible = [](typename StackType::Slot const& _source, typename StackType::Slot const& _target) { return std::holds_alternative<ssa::JunkSlot>(_target) || _source == _target; }
+	auto SlotIsCompatible = [](StackSlot const& _source, typename StackType::Slot const& _target) { return _target.isJunk() || _source == _target; }
 >
 struct DanielShuffler
 {
 	using Stack = StackType;
-	using StackSlot = typename Stack::Slot;
+	using StackSlot = ssa::StackSlot;
 	static void shuffle(Stack& _stack, std::set<StackSlot> const& _targetStackTail, std::vector<StackSlot> const& _targetStackTop)
 	{
 		struct ShuffleOperations
@@ -151,7 +152,7 @@ struct DanielShuffler
 				for (auto const& x: currentStack)
 					++sourceCounts[x];
 				for (auto const [i, x]: ranges::views::enumerate(targetStack))
-					if (i < currentStack.size() && std::holds_alternative<ssa::JunkSlot>(targetStack[i]))
+					if (i < currentStack.size() && targetStack[i].isJunk())
 						++targetCounts[currentStack[i]];
 					else
 						++targetCounts[x];
@@ -183,7 +184,7 @@ struct DanielShuffler
 
 			bool targetIsArbitrary(size_t _targetOffset) const
 			{
-				return _targetOffset < targetStack.size() && std::holds_alternative<ssa::JunkSlot>(targetStack.at(_targetOffset));
+				return _targetOffset < targetStack.size() && targetStack[_targetOffset].isJunk();
 			}
 
 			size_t sourceSize() const { return currentStack.size(); }
@@ -335,7 +336,7 @@ struct GreedyForwardShuffler
 {
 	using Stack = StackType;
 	using StackSlot = typename Stack::Slot;
-	
+
 	/// Simple, correct forward shuffler (INTENTIONALLY does NOT conform to SSACFGStackShuffler concept)
 	/// Key insight: handle values that are both consumed AND live-out properly
 	static Stack shuffle(
@@ -345,19 +346,19 @@ struct GreedyForwardShuffler
 	)
 	{
 		Stack result = _sourceStack;
-		
+
 		// Safety check: don't create overly deep stacks
 		if (result.size() + _requiredTop.size() > 1000) {
 			// Fall back to Daniel shuffler for very deep stacks
 			return DanielShuffler<Stack>::shuffle(_sourceStack, std::set<StackSlot>(_liveOut.begin(), _liveOut.end()), _requiredTop);
 		}
-		
+
 		// Phase 1: Ensure extra copies for values that are both consumed and live-out (with constraints)
 		ensureExtraCopiesForConsumedLiveOuts(result, _liveOut, _requiredTop);
-		
+
 		// Phase 2: Build required top in correct order (simple approach)
 		buildRequiredTop(result, _requiredTop);
-		
+
 		return result;
 	}
 
@@ -371,17 +372,17 @@ struct GreedyForwardShuffler
 		for (auto const& requiredValue : _requiredTop) {
 			// Is this value also live-out? (will be consumed but must survive)
 			bool isAlsoLiveOut = ranges::find(_liveOut, requiredValue) != _liveOut.end();
-			
+
 			if (isAlsoLiveOut) {
 				// Count how many copies we have on stack
 				auto copyCount = std::count(_stack.data().begin(), _stack.data().end(), requiredValue);
-				
+
 				if (copyCount < 2) {
 					// Find the value's position from top of stack
 					auto stackData = _stack.data();
 					auto reverseView = stackData | ranges::views::reverse;
 					auto it = ranges::find(reverseView, requiredValue);
-					
+
 					if (it != reverseView.end()) {
 						auto distance = std::distance(reverseView.begin(), it);
 						// Only dup if within EVM's 16-element reach
@@ -394,14 +395,14 @@ struct GreedyForwardShuffler
 			}
 		}
 	}
-	
+
 	/// Phase 2: Build required top - respecting EVM depth constraints
 	static void buildRequiredTop(Stack& _stack, std::vector<StackSlot> const& _requiredTop) {
 		if (_requiredTop.empty()) return;
-		
+
 		// Fast path: check if already correct
 		if (isTopAlreadyCorrect(_stack, _requiredTop)) return;
-		
+
 		// Build top from bottom to top (iterate requiredTop in reverse)
 		// Example: requiredTop=[v0,64] means final stack=[...,64,v0] (v0 at top)
 		// So push 64 first (ends up deeper), then v0 (ends up at top)
@@ -410,16 +411,16 @@ struct GreedyForwardShuffler
 			_stack.pushOrDup(*it);
 		}
 	}
-	
+
 	/// Check if required top is already correct (optimization)
 	static bool isTopAlreadyCorrect(Stack const& _stack, std::vector<StackSlot> const& _requiredTop) {
 		if (_requiredTop.size() > _stack.size()) return false;
-		
+
 		// Check if top of stack matches required top exactly
 		for (size_t i = 0; i < _requiredTop.size(); ++i) {
 			size_t stackIndex = _stack.size() - 1 - i;  // Stack top = size-1
 			size_t requiredIndex = _requiredTop.size() - 1 - i;  // Required top = size-1
-			
+
 			if (_stack[stackIndex] != _requiredTop[requiredIndex]) {
 				return false;
 			}

libyul/backends/evm/ssa/AStarShuffler.h

@@ -25,8 +25,6 @@
 #include "range/v3/algorithm/equal.hpp"
 #include "range/v3/view/concat.hpp"
 
-#include <libyul/backends/evm/SSACFGStack.h>
-
 #include <algorithm>
 #include <queue>
 #include <unordered_set>
@@ -266,7 +264,7 @@ class BlockForwardAStarShuffler
 	static Cost heuristicCost(State const& _from, State const& _to)
 	{
 		Cost cost{};
-		
+
 		// 1. Histogram difference (count constraints)
 		auto it_a = _from.histogram.begin();
 		auto it_b = _to.histogram.begin();
@@ -301,7 +299,7 @@ class BlockForwardAStarShuffler
 		// 2. Head accessibility penalty
 		/*for (size_t i = 0; i < _to.numHead; ++i) {
 			auto targetSlot = _to.stackData[_to.stackData.size() - 1 - i];
-			
+
 			// Find the first occurrence of this slot in the current stack
 			auto it = std::find(_from.stackData.rbegin(), _from.stackData.rend(), targetSlot);
 			if (it != _from.stackData.rend()) {
@@ -311,7 +309,7 @@ class BlockForwardAStarShuffler
 				}
 			}
 		}*/
-		
+
 		return cost;
 	}
 

libyul/backends/evm/ssa/OperationForwardShuffler.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <libyul/backends/evm/ssa/LivenessAnalysis.h>
-#include <libyul/backends/evm/SSACFGStack.h>
 
 #include <range/v3/algorithm/equal.hpp>
 #include <range/v3/algorithm/find.hpp>

libyul/backends/evm/ssa/Stack.h

@@ -67,6 +67,14 @@ class StackSlot
 	static constexpr StackSlot makeFunctionReturnLabelSlot(std::uint32_t const _index) { return {Kind::FunctionReturnLabel, _index}; }
 	static constexpr StackSlot makeAssemblyLabelIDSlot(AbstractAssembly::LabelID const _labelID) { return {Kind::AssemblyLabelID, _labelID}; }
 
+	bool operator<(StackSlot const& _other) const
+	{
+		if (m_kind != _other.m_kind)
+			return m_kind < _other.m_kind;
+
+		return m_payload < _other.m_payload;
+	}
+
 private:
 	constexpr StackSlot(Kind const _kind, std::uint32_t const _payload):
 		m_kind(_kind),