minor fixes

clonker · clonker · commit 6fd678fe83e3 · 2025-10-16T17:33:25.000+02:00
diff --git a/libsolutil/DisjointSet.cpp b/libsolutil/DisjointSet.cpp
@@ -24,7 +24,8 @@
 
 using namespace solidity::util;
 
-ContiguousDisjointSet::ContiguousDisjointSet(size_t const _numNodes):
+template<typename ValueType>
+ContiguousDisjointSet<ValueType>::ContiguousDisjointSet(size_t const _numNodes):
 	m_parents(_numNodes),
 	m_neighbors(_numNodes),
 	m_sizes(_numNodes, static_cast<value_type>(1)),
@@ -35,9 +36,11 @@ ContiguousDisjointSet::ContiguousDisjointSet(size_t const _numNodes):
 	std::iota(m_neighbors.begin(), m_neighbors.end(), 0);
 }
 
-size_t ContiguousDisjointSet::numSets() const { return m_numSets; }
+template<typename ValueType>
+size_t ContiguousDisjointSet<ValueType>::numSets() const { return m_numSets; }
 
-ContiguousDisjointSet::value_type ContiguousDisjointSet::find(value_type const _element) const
+template<typename ValueType>
+ContiguousDisjointSet<ValueType>::value_type ContiguousDisjointSet<ValueType>::find(value_type const _element) const
 {
 	solAssert(_element < m_parents.size());
 	// path halving
@@ -50,7 +53,8 @@ ContiguousDisjointSet::value_type ContiguousDisjointSet::find(value_type const _
 	return rootElement;
 }
 
-void ContiguousDisjointSet::merge(value_type const _x, value_type const _y, bool const _mergeBySize)
+template<typename ValueType>
+void ContiguousDisjointSet<ValueType>::merge(value_type const _x, value_type const _y, bool const _mergeBySize)
 {
 	auto xRoot = find(_x);
 	auto yRoot = find(_y);
@@ -69,17 +73,20 @@ void ContiguousDisjointSet::merge(value_type const _x, value_type const _y, bool
 	--m_numSets;
 }
 
-bool ContiguousDisjointSet::sameSubset(value_type const _x, value_type const _y) const
+template<typename ValueType>
+bool ContiguousDisjointSet<ValueType>::sameSubset(value_type const _x, value_type const _y) const
 {
 	return find(_x) == find(_y);
 }
 
-ContiguousDisjointSet::size_type ContiguousDisjointSet::sizeOfSubset(value_type const _x) const
+template<typename ValueType>
+ContiguousDisjointSet<ValueType>::size_type ContiguousDisjointSet<ValueType>::sizeOfSubset(value_type const _x) const
 {
 	return m_sizes[find(_x)];
 }
 
-std::set<ContiguousDisjointSet::value_type> ContiguousDisjointSet::subset(value_type const _x) const
+template<typename ValueType>
+std::set<typename ContiguousDisjointSet<ValueType>::value_type> ContiguousDisjointSet<ValueType>::subset(value_type const _x) const
 {
 	solAssert(_x < m_parents.size());
 	std::set<value_type> result{_x};
@@ -92,7 +99,8 @@ std::set<ContiguousDisjointSet::value_type> ContiguousDisjointSet::subset(value_
 	return result;
 }
 
-std::vector<std::set<ContiguousDisjointSet::value_type>> ContiguousDisjointSet::subsets() const
+template<typename ValueType>
+std::vector<std::set<typename ContiguousDisjointSet<ValueType>::value_type>> ContiguousDisjointSet<ValueType>::subsets() const
 {
 	std::vector<std::set<value_type>> result;
 	std::vector<std::uint8_t> visited(m_parents.size(), false);
@@ -107,3 +115,6 @@ std::vector<std::set<ContiguousDisjointSet::value_type>> ContiguousDisjointSet::
 	}
 	return result;
 }
+
+template class solidity::util::ContiguousDisjointSet<std::uint64_t>;
+template class solidity::util::ContiguousDisjointSet<std::uint32_t>;
diff --git a/libsolutil/DisjointSet.h b/libsolutil/DisjointSet.h
@@ -31,11 +31,12 @@ namespace solidity::util
 /// [1] https://en.wikipedia.org/wiki/Disjoint-set_data_structure
 /// [2] Tarjan, Robert E., and Jan Van Leeuwen. "Worst-case analysis of set union algorithms."
 ///     Journal of the ACM (JACM) 31.2 (1984): 245-281.
+template<typename ValueType>
 class ContiguousDisjointSet
 {
 public:
 	using size_type = size_t;
-	using value_type = size_t;
+	using value_type = ValueType;
 
 	/// Constructs a new disjoint set datastructure with `_numNodes` elements and each element in its own individual set
 	explicit ContiguousDisjointSet(size_t _numNodes);
diff --git a/libyul/backends/evm/SSACFGEVMCodeTransform.cpp b/libyul/backends/evm/SSACFGEVMCodeTransform.cpp
@@ -143,7 +143,6 @@ SSACFGEVMCodeTransform::SSACFGEVMCodeTransform
 	m_assembly(_assembly),
 	m_builtinContext(_builtinContext),
 	m_cfg(_cfg),
-	m_liveness(_liveness),
 	m_junkBlockFinder(_cfg, _liveness.topologicalSort()),
 	m_stackLayout(StackLayoutGenerator::generate(_liveness, m_junkBlockFinder)),
 	m_assemblyCallbacks{
@@ -193,7 +192,6 @@ void SSACFGEVMCodeTransform::operator()(SSACFG::BlockId const _block)
 	yulAssert(m_cfg.block(_block).operations.size() == blockLayout.operationIn.size(), "We need as many stack layouts as we have operations");
 
 	// for each op with respective live-out, descend into op
-	size_t operationIndex = 0;
 	for (auto const& [operation, operationStackIn]: ranges::views::zip( m_cfg.block(_block).operations, blockLayout.operationIn))
 	{
 		bool const hasReturnLabel = std::holds_alternative<SSACFG::Call>(operation.kind)
@@ -268,7 +266,6 @@ void SSACFGEVMCodeTransform::operator()(SSACFG::BlockId const _block)
 			static_cast<int>(m_stack.size()) == m_assembly.stackHeight(),
 			fmt::format("symbolic stack size = {} =/= {} = assembly stack height", m_stack.size(), m_assembly.stackHeight())
 		);
-		++operationIndex;
 	}
 
 	shuffleStack(m_stackLayout[_block].stackOut);
diff --git a/libyul/backends/evm/SSACFGEVMCodeTransform.h b/libyul/backends/evm/SSACFGEVMCodeTransform.h
@@ -151,7 +151,6 @@ class SSACFGEVMCodeTransform
 	BuiltinContext& m_builtinContext;
 	// ControlFlow const& m_controlFlow;
 	SSACFG const& m_cfg;
-	LivenessAnalysis const& m_liveness;
 	TerminationPathAnalysis m_junkBlockFinder;
 	SSACFGStackLayout const m_stackLayout;
 	std::vector<StackTooDeepError> m_stackErrors;
diff --git a/libyul/backends/evm/ssa/LivenessAnalysis.cpp b/libyul/backends/evm/ssa/LivenessAnalysis.cpp
@@ -285,7 +285,7 @@ void LivenessAnalysis::runLoopTreeDfs(SSACFG::BlockId::ValueType const _loopHead
 		// must be live out of header if live in of children
 		m_liveOuts[_loopHeader].maxUnion(liveLoop);
 		// for each blockId \in children(loopHeader)
-		for (size_t blockIdValue = 0; blockIdValue < m_cfg.numBlocks(); ++blockIdValue)
+		for (SSACFG::BlockId::ValueType blockIdValue = 0u; blockIdValue < m_cfg.numBlocks(); ++blockIdValue)
 			if (m_loopNestingForest.loopParents()[blockIdValue] == _loopHeader)
 			{
 				// propagate loop liveness information down to the loop header's children
diff --git a/libyul/backends/evm/ssa/OperationForwardShuffler.h b/libyul/backends/evm/ssa/OperationForwardShuffler.h
@@ -42,15 +42,14 @@ class OperationForwardShuffler
 		Stack& _stack,
 		std::vector<Slot> const& _args,
 		LivenessAnalysis::LivenessData const& _liveOut,
-		bool _generateJunk,
-		SSACFG const& _cfg
+		bool _generateJunk
 	)
 	{
 		yulAssert(ranges::none_of(_args, [](auto const& _slot) { return _slot.isJunk(); }));
 
 		constexpr std::size_t maxIterations = 1000;
 		std::size_t i = 0;
-		for (; i < maxIterations && shuffleStep(_stack, _args, _liveOut, _generateJunk, _cfg); ++i) {}
+		for (; i < maxIterations && shuffleStep(_stack, _args, _liveOut, _generateJunk); ++i) {}
 		yulAssert(i < maxIterations, fmt::format("Maximum iterations reached on {}", stackToString(_stack.data())));
 	}
 
@@ -122,7 +121,7 @@ class OperationForwardShuffler
 
 	struct Ops
 	{
-		Ops(Stack const& _stack, std::vector<Slot> const& _args, LivenessAnalysis::LivenessData const& _liveOut, SSACFG const& _cfg):
+		Ops(Stack const& _stack, std::vector<Slot> const& _args, LivenessAnalysis::LivenessData const& _liveOut):
 			stackStats(_stack, _args.size()),
 			targetMinCounts(detail::histogram(_args)),
 			stack(_stack),
@@ -304,11 +303,10 @@ class OperationForwardShuffler
 		Stack& _stack,
 		std::vector<Slot> const& _args,
 		LivenessAnalysis::LivenessData const& _liveOut,
-		bool const _generateJunk,
-		SSACFG const& _cfg
+		bool const _generateJunk
 	)
 	{
-		Ops const ops(_stack, _args, _liveOut, _cfg);
+		Ops const ops(_stack, _args, _liveOut);
 
 		// Check if we have the required top already
 		if (ops.argsRegionIsCorrect())
diff --git a/libyul/backends/evm/ssa/SSACFG.h b/libyul/backends/evm/ssa/SSACFG.h
@@ -264,7 +264,7 @@ class SSACFG
 		m_literals.emplace_back(std::move(_debugData), std::move(_value));
 		auto const value = m_literals.size() - 1;
 		yulAssert(value <= std::numeric_limits<ValueId::ValueType>::max());
-		auto const literalId = ValueId::makeLiteral(value);
+		auto const literalId = ValueId::makeLiteral(static_cast<ValueId::ValueType>(value));
 		m_literalMapping.emplace(_value, literalId);
 		return literalId;
 	}
diff --git a/libyul/backends/evm/ssa/SSACFGBuilder.h b/libyul/backends/evm/ssa/SSACFGBuilder.h
@@ -36,7 +36,7 @@
 
 namespace solidity::yul
 {
-class AsmAnalysisInfo;
+struct AsmAnalysisInfo;
 namespace ssa
 {
 
diff --git a/libyul/backends/evm/ssa/SSACFGLoopNestingForest.cpp b/libyul/backends/evm/ssa/SSACFGLoopNestingForest.cpp
@@ -18,6 +18,8 @@
 
 #include <libyul/backends/evm/ssa/SSACFGLoopNestingForest.h>
 
+#include <range/v3/algorithm/reverse.hpp>
+
 using namespace solidity::yul::ssa;
 
 SSACFGLoopNestingForest::SSACFGLoopNestingForest(ForwardSSACFGTopologicalSort const& _sort):
@@ -28,7 +30,7 @@ SSACFGLoopNestingForest::SSACFGLoopNestingForest(ForwardSSACFGTopologicalSort co
 {
 	auto dfsOrder = m_sort.preOrder();
 	// we go from innermost to outermost
-	std::reverse(dfsOrder.begin(), dfsOrder.end());
+	ranges::reverse(dfsOrder);
 
 	for (auto const& blockId: dfsOrder)
 		findLoop(blockId);
diff --git a/libyul/backends/evm/ssa/SSACFGLoopNestingForest.h b/libyul/backends/evm/ssa/SSACFGLoopNestingForest.h
@@ -54,7 +54,7 @@ class SSACFGLoopNestingForest
 	ForwardSSACFGTopologicalSort const& m_sort;
 	SSACFG const& m_cfg;
 
-	util::ContiguousDisjointSet m_vertexPartition;
+	util::ContiguousDisjointSet<BlockIdValue> m_vertexPartition;
 	std::vector<BlockIdValue> m_loopParents;
 	std::set<BlockIdValue> m_loopNodes;
 	std::set<BlockIdValue> m_loopRootNodes;
diff --git a/libyul/backends/evm/ssa/SSACFGTopologicalSort.cpp b/libyul/backends/evm/ssa/SSACFGTopologicalSort.cpp
@@ -38,7 +38,7 @@ ForwardSSACFGTopologicalSort::ForwardSSACFGTopologicalSort(SSACFG const& _cfg):
 void ForwardSSACFGTopologicalSort::dfs(SSACFG::BlockId::ValueType const _vertex) {
 	yulAssert(!m_explored[_vertex]);
 	m_explored[_vertex] = true;
-	m_blockWisePreOrder[_vertex] = m_preOrder.size();
+	m_blockWisePreOrder[_vertex] = static_cast<SSACFG::BlockId::ValueType>(m_preOrder.size());
 	m_blockWiseMaxSubtreePreOrder[_vertex] = m_blockWisePreOrder[_vertex];
 	m_preOrder.push_back(_vertex);
 
diff --git a/libyul/backends/evm/ssa/Stack.cpp b/libyul/backends/evm/ssa/Stack.cpp
@@ -59,7 +59,7 @@ std::string stackToString(Stack<>::Data const& _stackData)
 			fmt::join(_stackData | ranges::views::drop(numJunk) | ranges::views::transform([&](auto const& _slot) { return slotToString(_slot); }), ", ")
 		);
 
-	return format(
+	return fmt::format(
 		"[{}]",
 		fmt::join(_stackData | ranges::views::transform([&](auto const& _slot) { return slotToString(_slot); }), ", ")
 	);
@@ -69,13 +69,13 @@ std::string stackToString(Stack<>::Data const& _stackData, SSACFG const& _cfg)
 {
 	auto const numJunk = junkTailSize(_stackData);
 	if (numJunk > 0)
-		return format(
+		return fmt::format(
 			"[JUNK x {}, {}]",
 			numJunk,
 			fmt::join(_stackData | ranges::views::drop(numJunk) | ranges::views::transform([&](auto const& _slot) { return slotToString(_slot, _cfg); }), ", ")
 		);
 
-	return format(
+	return fmt::format(
 		"[{}]",
 		fmt::join(_stackData | ranges::views::transform([&](auto const& _slot) { return slotToString(_slot, _cfg); }), ", ")
 	);
diff --git a/libyul/backends/evm/ssa/Stack.h b/libyul/backends/evm/ssa/Stack.h
@@ -61,7 +61,7 @@ class CallSites
 			return *id;
 		yulAssert(_functionCall);
 		m_data.emplace_back(_functionCall);
-		return m_data.size() - 1;
+		return static_cast<CallSiteID>(m_data.size() - 1);
 	}
 private:
 	std::vector<FunctionCall const*> m_data;
@@ -103,8 +103,8 @@ class StackSlot
 	auto operator<=>(StackSlot const&) const = default;
 private:
 	constexpr StackSlot(std::uint32_t const _payload, Kind const _kind, SSACFG::ValueId::Kind const _valueIdKind = SSACFG::ValueId::Kind::Unreachable):
-		m_kind(_kind),
 		m_payload(_payload),
+		m_kind(_kind),
 		m_valueIdKind(_valueIdKind)
 	{}
 
diff --git a/libyul/backends/evm/ssa/StackLayoutGenerator.cpp b/libyul/backends/evm/ssa/StackLayoutGenerator.cpp
@@ -63,47 +63,6 @@ void declareJunk(StackLayoutGenerator::StackType& _stack, LivenessAnalysis::Live
 	}
 }
 
-void reduceStackToLiveness(StackLayoutGenerator::StackType& _stack, std::set<SSACFG::ValueId> const& _livenessPreImage, bool const _introduceJunk)
-{
-	// if we are allowed to introduce junk, we'll just declare everything in the stack tail that is not part of the liveness
-	// set as junk until we find something that has relevance. That way the stack closer to the top is kept compact
-	// and the end part can be safely discarded
-	if (_introduceJunk)
-		for (size_t i = 0; i < _stack.size(); ++i)
-		{
-			if (!_stack[i].isValueID() && !_stack[i].isJunk())
-				break;
-
-			if (auto const slot = _stack.slot(i); slot.isValueID())
-			{
-				if (_livenessPreImage.contains(slot.valueID()))
-					break;
-				_stack.declareJunk(_stack.size() - i - 1);
-			}
-		}
-
-	// pop everything not in the combined pre image
-	// we can ignore the phi function pre-image slots because they are definitely in the combined liveness
-	while (
-		_stack.size() > 0 &&
-		_stack.top().isValueID() &&
-		!_livenessPreImage.contains(_stack.top().valueID())
-	)
-		_stack.pop();
-	for (auto it = _stack.data().rbegin(); it != _stack.data().rend(); ++it)
-	{
-		if (it->isValueID() && !_livenessPreImage.contains(it->valueID()))
-		{
-			yulAssert(it != _stack.data().rbegin()); // this shouldn't happen as we have already popped everything up front
-			auto const depth = static_cast<std::size_t>(std::distance(_stack.data().rbegin(), it));
-			if (depth > 0)
-				_stack.swap(depth);
-			_stack.pop();
-		}
-	}
-}
-
-
 }
 
 StackLayoutGenerator::StackLayoutGenerator(LivenessAnalysis const& _liveness, TerminationPathAnalysis const& _junkBlockFinder):
@@ -124,7 +83,7 @@ SSACFGStackLayout StackLayoutGenerator::generate(LivenessAnalysis const& _cfgLiv
 				  << (_cfgLiveness.cfg().function ? _cfgLiveness.cfg().function->name.str() : "main graph") << '\n';
 	return StackLayoutGenerator{_cfgLiveness, _junkBlockFinder}.computeStackLayout();
 }
-void StackLayoutGenerator::handlePhiFunctions(StackData& _stackData, ReversePhiFunctionTransform const& _phiInverse, LivenessAnalysis::LivenessData const& _liveness, SSACFG const& _cfg)
+void StackLayoutGenerator::handlePhiFunctions(StackData& _stackData, ReversePhiFunctionTransform const& _phiInverse, LivenessAnalysis::LivenessData const& _liveness)
 {
 	// add any phi function values here that are not already contained in the stack
 	for (auto const& [phi, preImage]: _phiInverse.data())
@@ -233,7 +192,7 @@ void StackLayoutGenerator::defineStackIn(SSACFG::BlockId const& _blockId)
 		m_stackLayout[_blockId].stackIn = *parentExits[0].second;
 
 		if (!block.phis.empty())
-			handlePhiFunctions(m_stackLayout[_blockId].stackIn, ReversePhiFunctionTransform(m_cfg, parentExits[0].first, _blockId), m_liveness.liveIn(_blockId), m_cfg);
+			handlePhiFunctions(m_stackLayout[_blockId].stackIn, ReversePhiFunctionTransform(m_cfg, parentExits[0].first, _blockId), m_liveness.liveIn(_blockId));
 
 		/*StackType stackIn(m_stackLayout[_blockId].stackIn, {}, {&m_cfg});
 		declareJunk(stackIn, liveIn);
@@ -302,7 +261,7 @@ void StackLayoutGenerator::defineStackIn(SSACFG::BlockId const& _blockId)
 				StackType stack(referenceStackIn, {});
 				declareJunk(stack, liveIn);
 			}
-			handlePhiFunctions(referenceStackIn, ReversePhiFunctionTransform(m_cfg, parentExits[i].first, _blockId), liveIn, m_cfg);
+			handlePhiFunctions(referenceStackIn, ReversePhiFunctionTransform(m_cfg, parentExits[i].first, _blockId), liveIn);
 			for (size_t j = 0; j < parentExits.size(); ++j)
 			{
 				if (j != i)
@@ -324,7 +283,7 @@ void StackLayoutGenerator::defineStackIn(SSACFG::BlockId const& _blockId)
 		m_stackLayout[_blockId].stackIn = *parentExits[argMin].second;
 		StackType stack(m_stackLayout[_blockId].stackIn, {});
 		declareJunk(stack, liveIn);
-		handlePhiFunctions(m_stackLayout[_blockId].stackIn, ReversePhiFunctionTransform(m_cfg, parentExits[argMin].first, _blockId), liveIn, m_cfg);
+		handlePhiFunctions(m_stackLayout[_blockId].stackIn, ReversePhiFunctionTransform(m_cfg, parentExits[argMin].first, _blockId), liveIn);
 		//m_stackLayout[_blockId].stackIn = unifiedStack | ranges::views::reverse | ranges::to<std::vector>;
 	}
 
@@ -391,7 +350,7 @@ void StackLayoutGenerator::visitBlock(SSACFG::BlockId const& _blockId)
 		if constexpr(debugOutput)
 			std::cout << "{ " << stackToString(liveOutWithoutOutputs | ranges::views::transform(Slot::makeValueID) | ranges::to<std::vector>, m_cfg) << " } + " << stackToString(requiredStackTop, m_cfg) << ") -> " << std::flush;
 
-		OperationForwardShuffler<StackType>::shuffle(stack, requiredStackTop, opLiveOutWithoutOutputs, m_junkBlockFinder.blockAllowsAdditionOfJunk(_blockId), m_cfg);
+		OperationForwardShuffler<StackType>::shuffle(stack, requiredStackTop, opLiveOutWithoutOutputs, m_junkBlockFinder.blockAllowsAdditionOfJunk(_blockId));
 
 		m_stackLayout[_blockId].operationIn.push_back(currentStackData);
 
@@ -464,7 +423,7 @@ void StackLayoutGenerator::visitBlock(SSACFG::BlockId const& _blockId)
 		m_blockHasStackInDefined[cjump->nonZero.value] = true;
 		// same as nonzero stack in initially
 		m_stackLayout[cjump->zero].stackIn = m_stackLayout[cjump->nonZero].stackIn;
-		handlePhiFunctions(m_stackLayout[cjump->zero].stackIn, ReversePhiFunctionTransform(m_cfg, _blockId, cjump->zero), zeroLiveIn, m_cfg);
+		handlePhiFunctions(m_stackLayout[cjump->zero].stackIn, ReversePhiFunctionTransform(m_cfg, _blockId, cjump->zero), zeroLiveIn);
 		{
 			StackType zeroStack(m_stackLayout[cjump->zero].stackIn, {});
 			declareJunk(zeroStack, zeroLiveIn);
diff --git a/libyul/backends/evm/ssa/StackLayoutGenerator.h b/libyul/backends/evm/ssa/StackLayoutGenerator.h
@@ -52,7 +52,7 @@ class StackLayoutGenerator
 	static SSACFGStackLayout generate(LivenessAnalysis const& _cfgLiveness, TerminationPathAnalysis const& _junkBlockFinder);
 
 private:
-	static void handlePhiFunctions(StackData& _stackData, ReversePhiFunctionTransform const& _phiInverse, LivenessAnalysis::LivenessData const& _liveness, SSACFG const& _cfg);
+	static void handlePhiFunctions(StackData& _stackData, ReversePhiFunctionTransform const& _phiInverse, LivenessAnalysis::LivenessData const& _liveness);
 
 	explicit StackLayoutGenerator(LivenessAnalysis const& _liveness, TerminationPathAnalysis const& _junkBlockFinder);
 
diff --git a/test/libsolutil/DisjointSet.cpp b/test/libsolutil/DisjointSet.cpp
diff --git a/test/libyul/Misctest.cpp b/test/libyul/Misctest.cpp

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,8 @@`
`24`	`24`
`25`	`25`	`using namespace solidity::util;`
`26`	`26`
`27`		`-ContiguousDisjointSet::ContiguousDisjointSet(size_t const _numNodes):`
	`27`	`+template<typename ValueType>`
	`28`	`+ContiguousDisjointSet<ValueType>::ContiguousDisjointSet(size_t const _numNodes):`
`28`	`29`	`m_parents(_numNodes),`
`29`	`30`	`m_neighbors(_numNodes),`
`30`	`31`	`m_sizes(_numNodes, static_cast<value_type>(1)),`
`@@ -35,9 +36,11 @@ ContiguousDisjointSet::ContiguousDisjointSet(size_t const _numNodes):`
`35`	`36`	`std::iota(m_neighbors.begin(), m_neighbors.end(), 0);`
`36`	`37`	`}`
`37`	`38`
`38`		`-size_t ContiguousDisjointSet::numSets() const { return m_numSets; }`
	`39`	`+template<typename ValueType>`
	`40`	`+size_t ContiguousDisjointSet<ValueType>::numSets() const { return m_numSets; }`
`39`	`41`
`40`		`-ContiguousDisjointSet::value_type ContiguousDisjointSet::find(value_type const _element) const`
	`42`	`+template<typename ValueType>`
	`43`	`+ContiguousDisjointSet<ValueType>::value_type ContiguousDisjointSet<ValueType>::find(value_type const _element) const`
`41`	`44`	`{`
`42`	`45`	`solAssert(_element < m_parents.size());`
`43`	`46`	`// path halving`
`@@ -50,7 +53,8 @@ ContiguousDisjointSet::value_type ContiguousDisjointSet::find(value_type const _`
`50`	`53`	`return rootElement;`
`51`	`54`	`}`
`52`	`55`
`53`		`-void ContiguousDisjointSet::merge(value_type const _x, value_type const _y, bool const _mergeBySize)`
	`56`	`+template<typename ValueType>`
	`57`	`+void ContiguousDisjointSet<ValueType>::merge(value_type const _x, value_type const _y, bool const _mergeBySize)`
`54`	`58`	`{`
`55`	`59`	`auto xRoot = find(_x);`
`56`	`60`	`auto yRoot = find(_y);`
`@@ -69,17 +73,20 @@ void ContiguousDisjointSet::merge(value_type const _x, value_type const _y, bool`
`69`	`73`	`--m_numSets;`
`70`	`74`	`}`
`71`	`75`
`72`		`-bool ContiguousDisjointSet::sameSubset(value_type const _x, value_type const _y) const`
	`76`	`+template<typename ValueType>`
	`77`	`+bool ContiguousDisjointSet<ValueType>::sameSubset(value_type const _x, value_type const _y) const`
`73`	`78`	`{`
`74`	`79`	`return find(_x) == find(_y);`
`75`	`80`	`}`
`76`	`81`
`77`		`-ContiguousDisjointSet::size_type ContiguousDisjointSet::sizeOfSubset(value_type const _x) const`
	`82`	`+template<typename ValueType>`
	`83`	`+ContiguousDisjointSet<ValueType>::size_type ContiguousDisjointSet<ValueType>::sizeOfSubset(value_type const _x) const`
`78`	`84`	`{`
`79`	`85`	`return m_sizes[find(_x)];`
`80`	`86`	`}`
`81`	`87`
`82`		`-std::set<ContiguousDisjointSet::value_type> ContiguousDisjointSet::subset(value_type const _x) const`
	`88`	`+template<typename ValueType>`
	`89`	`+std::set<typename ContiguousDisjointSet<ValueType>::value_type> ContiguousDisjointSet<ValueType>::subset(value_type const _x) const`
`83`	`90`	`{`
`84`	`91`	`solAssert(_x < m_parents.size());`
`85`	`92`	`std::set<value_type> result{_x};`
`@@ -92,7 +99,8 @@ std::set<ContiguousDisjointSet::value_type> ContiguousDisjointSet::subset(value_`
`92`	`99`	`return result;`
`93`	`100`	`}`
`94`	`101`
`95`		`-std::vector<std::set<ContiguousDisjointSet::value_type>> ContiguousDisjointSet::subsets() const`
	`102`	`+template<typename ValueType>`
	`103`	`+std::vector<std::set<typename ContiguousDisjointSet<ValueType>::value_type>> ContiguousDisjointSet<ValueType>::subsets() const`
`96`	`104`	`{`
`97`	`105`	`std::vector<std::set<value_type>> result;`
`98`	`106`	`std::vector<std::uint8_t> visited(m_parents.size(), false);`
`@@ -107,3 +115,6 @@ std::vector<std::set<ContiguousDisjointSet::value_type>> ContiguousDisjointSet::`
`107`	`115`	`}`
`108`	`116`	`return result;`
`109`	`117`	`}`
	`118`	`+`
	`119`	`+template class solidity::util::ContiguousDisjointSet<std::uint64_t>;`
	`120`	`+template class solidity::util::ContiguousDisjointSet<std::uint32_t>;`
Original file line number	Diff line number	Diff line change
`@@ -285,7 +285,7 @@ void LivenessAnalysis::runLoopTreeDfs(SSACFG::BlockId::ValueType const _loopHead`
`285`	`285`	`// must be live out of header if live in of children`
`286`	`286`	`m_liveOuts[_loopHeader].maxUnion(liveLoop);`
`287`	`287`	`// for each blockId \in children(loopHeader)`
`288`		`- for (size_t blockIdValue = 0; blockIdValue < m_cfg.numBlocks(); ++blockIdValue)`
	`288`	`+ for (SSACFG::BlockId::ValueType blockIdValue = 0u; blockIdValue < m_cfg.numBlocks(); ++blockIdValue)`
`289`	`289`	`if (m_loopNestingForest.loopParents()[blockIdValue] == _loopHeader)`
`290`	`290`	`{`
`291`	`291`	`// propagate loop liveness information down to the loop header's children`
Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ class SSACFG`
`264`	`264`	`m_literals.emplace_back(std::move(_debugData), std::move(_value));`
`265`	`265`	`auto const value = m_literals.size() - 1;`
`266`	`266`	`yulAssert(value <= std::numeric_limits<ValueId::ValueType>::max());`
`267`		`- auto const literalId = ValueId::makeLiteral(value);`
	`267`	`+ auto const literalId = ValueId::makeLiteral(static_cast<ValueId::ValueType>(value));`
`268`	`268`	`m_literalMapping.emplace(_value, literalId);`
`269`	`269`	`return literalId;`
`270`	`270`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@`
`36`	`36`
`37`	`37`	`namespace solidity::yul`
`38`	`38`	`{`
`39`		`-class AsmAnalysisInfo;`
	`39`	`+struct AsmAnalysisInfo;`
`40`	`40`	`namespace ssa`
`41`	`41`	`{`
`42`	`42`