SSACFG: Use tagged union for ValueId

Author: clonker

libyul/backends/evm/ssa/ControlFlow.cpp

@@ -24,8 +24,7 @@ using namespace solidity::yul::ssa;
 
 ControlFlowLiveness::ControlFlowLiveness(ControlFlow const& _controlFlow):
 	controlFlow(_controlFlow),
-	mainLiveness(std::make_unique<LivenessAnalysis>(*_controlFlow.mainGraph)),
-	functionLiveness(_controlFlow.functionGraphs | ranges::views::transform([](auto const& _cfg) { return std::make_unique<LivenessAnalysis>(*_cfg); }) | ranges::to<std::vector>)
+	cfgLiveness(_controlFlow.functionGraphs | ranges::views::transform([](auto const& _cfg) { return std::make_unique<LivenessAnalysis>(*_cfg); }) | ranges::to<std::vector>)
 { }
 
 std::string ControlFlowLiveness::toDot() const

libyul/backends/evm/ssa/ControlFlow.h

@@ -24,6 +24,8 @@
 #include <libyul/AST.h>
 #include <libyul/Scope.h>
 
+#include <range/v3/algorithm/find_if.hpp>
+
 namespace solidity::yul::ssa
 {
 
@@ -33,44 +35,52 @@ struct ControlFlowLiveness{
 	explicit ControlFlowLiveness(ControlFlow const& _controlFlow);
 
 	std::reference_wrapper<ControlFlow const> controlFlow;
-	std::unique_ptr<LivenessAnalysis> mainLiveness;
-	std::vector<std::unique_ptr<LivenessAnalysis>> functionLiveness;
+	std::vector<std::unique_ptr<LivenessAnalysis>> cfgLiveness;
 
 	std::string toDot() const;
 };
 
 struct ControlFlow
 {
-	std::unique_ptr<SSACFG> mainGraph{std::make_unique<SSACFG>()};
-	std::vector<std::unique_ptr<SSACFG>> functionGraphs{};
-	std::vector<std::tuple<Scope::Function const*, SSACFG const*>> functionGraphMapping{};
+	using FunctionGraphID = std::uint32_t;
 
-	SSACFG const* functionGraph(Scope::Function const* _function)
+	static FunctionGraphID constexpr mainGraphID() noexcept { return 0; }
+
+	SSACFG const* mainGraph() const { return functionGraph(mainGraphID()); }
+
+	SSACFG const* functionGraph(Scope::Function const* _function) const
 	{
-		auto it = std::find_if(functionGraphMapping.begin(), functionGraphMapping.end(), [_function](auto const& tup) { return _function == std::get<0>(tup); });
+		auto it = ranges::find_if(functionGraphMapping, [_function](auto const& tup) { return _function == std::get<0>(tup); });
 		if (it != functionGraphMapping.end())
 			return std::get<1>(*it);
 		return nullptr;
 	}
 
+	SSACFG const* functionGraph(FunctionGraphID const _id) const
+	{
+		return functionGraphs.at(_id).get();
+	}
+
 	std::string toDot(ControlFlowLiveness const* _liveness=nullptr) const
 	{
 		if (_liveness)
 			yulAssert(&_liveness->controlFlow.get() == this);
 		std::ostringstream output;
 		output << "digraph SSACFG {\nnodesep=0.7;\ngraph[fontname=\"DejaVu Sans\"]\nnode[shape=box,fontname=\"DejaVu Sans\"];\n\n";
-		output << mainGraph->toDot(false, std::nullopt, _liveness ? _liveness->mainLiveness.get() : nullptr);
 
 		for (size_t index=0; index < functionGraphs.size(); ++index)
 			output << functionGraphs[index]->toDot(
 				false,
-				index+1,
-				_liveness ? _liveness->functionLiveness[index].get() : nullptr
+				index,
+				_liveness ? _liveness->cfgLiveness[index].get() : nullptr
 			);
 
 		output << "}\n";
 		return output.str();
 	}
+
+	std::vector<std::unique_ptr<SSACFG>> functionGraphs{};
+	std::vector<std::tuple<Scope::Function const*, SSACFG const*>> functionGraphMapping{};
 };
 
 }

libyul/backends/evm/ssa/LivenessAnalysis.cpp

@@ -31,18 +31,11 @@ using namespace solidity::yul::ssa;
 
 namespace
 {
-constexpr auto excludingLiteralsFilter(SSACFG const& _cfg)
+constexpr auto excludingLiteralsFilter()
 {
-	return [&_cfg](LivenessAnalysis::LivenessData::Value const& _valueId) -> bool
+	return [](LivenessAnalysis::LivenessData::Value const& _valueId) -> bool
 	{
-		return !std::holds_alternative<SSACFG::LiteralValue>(_cfg.valueInfo(_valueId));
-	};
-}
-constexpr auto unreachableFilter(SSACFG const& _cfg)
-{
-	return [&_cfg](LivenessAnalysis::LivenessData::Value const& _valueId) -> bool
-	{
-		return std::holds_alternative<SSACFG::UnreachableValue>(_cfg.valueInfo(_valueId));
+		return !_valueId.isLiteral();
 	};
 }
 }
@@ -149,18 +142,18 @@ LivenessAnalysis::LivenessData LivenessAnalysis::blockExitValues(SSACFG::BlockId
 		[](SSACFG::BasicBlock::MainExit const&) {},
 		[&](SSACFG::BasicBlock::FunctionReturn const& _functionReturn)
 		{
-			for (auto const& valueId: _functionReturn.returnValues | ranges::views::filter(excludingLiteralsFilter(m_cfg)))
+			for (auto const& valueId: _functionReturn.returnValues | ranges::views::filter(excludingLiteralsFilter()))
 				result.insert(valueId);
 		},
 		[&](SSACFG::BasicBlock::JumpTable const& _jt)
 		{
-			if (excludingLiteralsFilter(m_cfg)(_jt.value))
+			if (excludingLiteralsFilter()(_jt.value))
 				result.insert(_jt.value);
 		},
 		[](SSACFG::BasicBlock::Jump const&) {},
 		[&](SSACFG::BasicBlock::ConditionalJump const& _conditionalJump)
 		{
-			if (excludingLiteralsFilter(m_cfg)(_conditionalJump.condition))
+			if (excludingLiteralsFilter()(_conditionalJump.condition))
 				result.insert(_conditionalJump.condition);
 		},
 		[](SSACFG::BasicBlock::Terminated const&) {}};
@@ -218,12 +211,11 @@ void LivenessAnalysis::runDagDfs()
 			{
 				for (auto const& phi: m_cfg.block(_successor).phis)
 				{
-					auto const& info = m_cfg.valueInfo(phi);
-					yulAssert(std::holds_alternative<SSACFG::PhiValue>(info), "value info of phi wasn't PhiValue");
-					auto const argIndex = m_cfg.phiArgumentIndex(blockId, _successor);
-					yulAssert(argIndex < std::get<SSACFG::PhiValue>(info).arguments.size());
-					auto const arg = std::get<SSACFG::PhiValue>(info).arguments.at(argIndex);
-					if (!std::holds_alternative<SSACFG::LiteralValue>(m_cfg.valueInfo(arg)))
+					auto const& info = m_cfg.phiInfo(phi);
+					auto const& argIndex = m_cfg.phiArgumentIndex(blockId, _successor);
+					yulAssert(argIndex < info.arguments.size());
+					auto const& arg = info.arguments.at(argIndex);
+					if (!arg.isLiteral())
 						live.insert(arg);
 				}
 			});
@@ -242,11 +234,11 @@ void LivenessAnalysis::runDagDfs()
 			});
 
 		if (std::holds_alternative<SSACFG::BasicBlock::FunctionReturn>(block.exit))
-			for (auto const& returnValue: std::get<SSACFG::BasicBlock::FunctionReturn>(block.exit).returnValues | ranges::views::filter(excludingLiteralsFilter(m_cfg)))
+			for (auto const& returnValue: std::get<SSACFG::BasicBlock::FunctionReturn>(block.exit).returnValues | ranges::views::filter(excludingLiteralsFilter()))
 				live.insert(returnValue);
 
 		// clean out unreachables
-		live.eraseIf([&](auto const& _entry) { return unreachableFilter(m_cfg)(_entry.first); });
+		live.eraseIf([&](auto const& _entry) { return _entry.first.isUnreachable(); });
 
 		// LiveOut(B) <- live
 		m_liveOuts[blockId.value] = live;
@@ -259,9 +251,9 @@ void LivenessAnalysis::runDagDfs()
 			for (auto const& op: block.operations | ranges::views::reverse)
 			{
 				// remove variables defined at p from live
-				live.eraseAll(op.outputs | ranges::views::filter(excludingLiteralsFilter(m_cfg)) | ranges::to<std::vector>);
+				live.eraseAll(op.outputs | ranges::views::filter(excludingLiteralsFilter()) | ranges::to<std::vector>);
 				// add uses at p to live
-				live.insertAll(op.inputs | ranges::views::filter(excludingLiteralsFilter(m_cfg)) | ranges::to<std::vector>);
+				live.insertAll(op.inputs | ranges::views::filter(excludingLiteralsFilter()) | ranges::to<std::vector>);
 			}
 		}
 
@@ -272,7 +264,7 @@ void LivenessAnalysis::runDagDfs()
 	}
 }
 
-void LivenessAnalysis::runLoopTreeDfs(size_t const _loopHeader)
+void LivenessAnalysis::runLoopTreeDfs(SSACFG::BlockId::ValueType const _loopHeader)
 {
 	// SSA Book, Algorithm 9.3
 	if (m_loopNestingForest.loopNodes().contains(_loopHeader))
@@ -286,7 +278,7 @@ void LivenessAnalysis::runLoopTreeDfs(size_t const _loopHeader)
 		// 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
@@ -313,9 +305,9 @@ void LivenessAnalysis::fillOperationsLiveOut()
 			for (auto const& op: operations | ranges::views::reverse)
 			{
 				*rit = live;
-				for (auto const& output: op.outputs | ranges::views::filter(excludingLiteralsFilter(m_cfg)))
+				for (auto const& output: op.outputs | ranges::views::filter(excludingLiteralsFilter()))
 					live.erase(output);
-				for (auto const& input: op.inputs | ranges::views::filter(excludingLiteralsFilter(m_cfg)))
+				for (auto const& input: op.inputs | ranges::views::filter(excludingLiteralsFilter()))
 					live.insert(input);
 				++rit;
 			}

libyul/backends/evm/ssa/LivenessAnalysis.h

@@ -42,8 +42,7 @@ class LivenessAnalysis
 
 		LivenessData() = default;
 		template<std::input_iterator Iter, std::sentinel_for<Iter> Sentinel>
-		LivenessData(Iter begin, Sentinel end): m_liveCounts(begin, end) {
-		}
+		LivenessData(Iter begin, Sentinel end): m_liveCounts(begin, end) {}
 		explicit LivenessData(LiveCounts&& _liveCounts): m_liveCounts(std::move(_liveCounts)) {}
 
 		bool contains(Value const& _valueId) const;
@@ -113,7 +112,7 @@ class LivenessAnalysis
 
 private:
 	void runDagDfs();
-	void runLoopTreeDfs(std::size_t _loopHeader);
+	void runLoopTreeDfs(SSACFG::BlockId::ValueType _loopHeader);
 	void fillOperationsLiveOut();
 	LivenessData blockExitValues(SSACFG::BlockId const& _blockId) const;
 

libyul/backends/evm/ssa/SSACFG.cpp

@@ -28,6 +28,8 @@
 #include <fmt/ranges.h>
 #pragma GCC diagnostic pop
 
+#include <libyul/backends/evm/ssa/JunkAdmittingBlocksFinder.h>
+
 #include <range/v3/view/zip.hpp>
 
 using namespace solidity;
@@ -43,41 +45,23 @@ class SSACFGPrinter
 	SSACFGPrinter(SSACFG const& _cfg, SSACFG::BlockId _blockId, LivenessAnalysis const* _liveness):
 		m_cfg(_cfg), m_functionIndex(0), m_liveness(_liveness)
 	{
+		if (_liveness)
+			m_junkAdmittingBlocks = std::make_unique<JunkAdmittingBlocksFinder>(_cfg, _liveness->topologicalSort());
 		printBlock(_blockId);
 	}
 	SSACFGPrinter(SSACFG const& _cfg, size_t _functionIndex, Scope::Function const& _function, LivenessAnalysis const* _liveness):
 		m_cfg(_cfg), m_functionIndex(_functionIndex), m_liveness(_liveness)
 	{
+		if (_liveness)
+			m_junkAdmittingBlocks = std::make_unique<JunkAdmittingBlocksFinder>(_cfg, _liveness->topologicalSort());
 		printFunction(_function);
 	}
 	friend std::ostream& operator<<(std::ostream& stream, SSACFGPrinter const& printer) {
 		stream << printer.m_result.str();
 		return stream;
 	}
-private:
-	static std::string varToString(SSACFG const& _cfg, SSACFG::ValueId _var) {
-		if (_var.value == std::numeric_limits<size_t>::max())
-			return "INVALID";
-		auto const& info = _cfg.valueInfo(_var);
-		return std::visit(
-			GenericVisitor{
-				[&](SSACFG::UnreachableValue const&) -> std::string {
-					return "[unreachable]";
-				},
-				[&](SSACFG::PhiValue const&) -> std::string {
-					return fmt::format("v{}", _var.value);
-				},
-				[&](SSACFG::VariableValue const&) -> std::string {
-					return fmt::format("v{}", _var.value);
-				},
-				[&](SSACFG::LiteralValue const& _literal) -> std::string {
-					return formatNumberReadable(_literal.value);
-				}
-			},
-			info
-		);
-	}
 
+private:
 	static std::string escape(std::string_view const str)
 	{
 		using namespace std::literals;
@@ -113,7 +97,7 @@ class SSACFGPrinter
 
 	static std::string formatPhi(SSACFG const& _cfg, SSACFG::PhiValue const& _phiValue)
 	{
-		auto const transform = [&](SSACFG::ValueId const& valueId) { return varToString(_cfg, valueId); };
+		auto const transform = [&](SSACFG::ValueId const& valueId) { return valueId.str(_cfg); };
 		std::vector<std::string> formattedArgs;
 		formattedArgs.reserve(_phiValue.arguments.size());
 		for (auto const& [arg, entry]: ranges::zip_view(_phiValue.arguments | ranges::views::transform(transform), _cfg.block(_phiValue.block).entries))
@@ -126,19 +110,23 @@ class SSACFGPrinter
 
 	void writeBlock(SSACFG::BlockId const& _id, SSACFG::BasicBlock const& _block)
 	{
-		auto const valueToString = [&](SSACFG::ValueId const& valueId) { return varToString(m_cfg, valueId); };
+		auto const valueToString = [&](SSACFG::ValueId const& valueId) { return valueId.str(m_cfg); };
 		bool entryBlock = _id.value == 0 && m_functionIndex == 0;
 		if (entryBlock)
 		{
 			m_result << fmt::format("Entry{} [label=\"Entry\"];\n", m_functionIndex);
 			m_result << fmt::format("Entry{} -> {};\n", m_functionIndex, formatBlockHandle(_id));
 		}
 		{
+			std::string revertPathInfo;
+			if (m_junkAdmittingBlocks)
+				revertPathInfo = m_junkAdmittingBlocks->allowsAdditionOfJunk(_id) ? "fillcolor=\"#FF746C\", style=filled, " : "";
 			if (m_liveness)
 			{
 				m_result << fmt::format(
-					"{} [label=\"\\\nBlock {}; ({}, max {})\\n",
+					"{} [{}label=\"\\\nBlock {}; ({}, max {})\\n",
 					formatBlockHandle(_id),
+					revertPathInfo,
 					_id.value,
 					m_liveness->topologicalSort().preOrderIndexOf(_id.value),
 					m_liveness->topologicalSort().maxSubtreePreOrderIndexOf(_id.value)
@@ -151,14 +139,19 @@ class SSACFGPrinter
 					"LiveOut: {}\\l\\n",
 					fmt::join(m_liveness->liveOut(_id) | ranges::views::transform([&](auto const& liveOut) { return valueToString(SSACFG::ValueId{liveOut.first}) + fmt::format("[{}]", liveOut.second); }), ", ")
 				);
+				auto const usedVariables = m_liveness->used(_id);
+				m_result << fmt::format(
+					"Used: {}\\l\\n",
+					fmt::join(usedVariables | ranges::views::transform([&](auto const& used) { return valueToString(SSACFG::ValueId{used.first}) + fmt::format("[{}]", used.second); }), ", ")
+				);
 			}
 			else
-				m_result << fmt::format("{} [label=\"\\\nBlock {}\\n", formatBlockHandle(_id), _id.value);
+				m_result << fmt::format("{} [{}label=\"\\\nBlock {}\\n", formatBlockHandle(_id), revertPathInfo, _id.value);
+
 			for (auto const& phi: _block.phis)
 			{
-				auto const* phiValue = std::get_if<SSACFG::PhiValue>(&m_cfg.valueInfo(phi));
-				solAssert(phiValue);
-				m_result << fmt::format("v{} := {}\\l\\\n", phi.value, formatPhi(m_cfg, *phiValue));
+				auto const& phiInfo = m_cfg.phiInfo(phi);
+				m_result << fmt::format("phi{} := {}\\l\\\n", phi.value(), formatPhi(m_cfg, phiInfo));
 			}
 			for (auto const& operation: _block.operations)
 			{
@@ -172,7 +165,7 @@ class SSACFGPrinter
 					[&](SSACFG::LiteralAssignment const&)
 					{
 						yulAssert(operation.inputs.size() == 1);
-						return varToString(m_cfg, operation.inputs.back());
+						return operation.inputs.back().str(m_cfg);
 					}
 				}, operation.kind);
 				if (!operation.outputs.empty())
@@ -210,7 +203,7 @@ class SSACFGPrinter
 					m_result << fmt::format("{} -> {}Exit;\n", formatBlockHandle(_id), formatBlockHandle(_id));
 					m_result << fmt::format(
 						"{}Exit [label=\"{{ If {} | {{ <0> Zero | <1> NonZero }}}}\" shape=Mrecord];\n",
-						formatBlockHandle(_id), varToString(m_cfg, _conditionalJump.condition)
+						formatBlockHandle(_id), _conditionalJump.condition.str(m_cfg)
 					);
 					m_result << formatEdge(_id, _conditionalJump.zero, "0");
 					m_result << formatEdge(_id, _conditionalJump.nonZero, "1");
@@ -279,7 +272,7 @@ class SSACFGPrinter
 	void printFunction(Scope::Function const& _fun)
 	{
 		static auto constexpr returnsTransform = [](auto const& functionReturnValue) { return escape(functionReturnValue.get().name.str()); };
-		static auto constexpr argsTransform = [](auto const& arg) { return fmt::format("v{}", std::get<1>(arg).value); };
+		static auto constexpr argsTransform = [](auto const& arg) { return fmt::format("v{}", std::get<1>(arg).value()); };
 		m_result << "FunctionEntry_" << escape(_fun.name.str()) << "_" << m_cfg.entry.value << " [label=\"";
 		if (!m_cfg.returns.empty())
 			m_result << fmt::format("function {0}:\n {1} := {0}({2})", escape(_fun.name.str()), fmt::join(m_cfg.returns | ranges::views::transform(returnsTransform), ", "), fmt::join(m_cfg.arguments | ranges::views::transform(argsTransform), ", "));
@@ -291,12 +284,28 @@ class SSACFGPrinter
 	}
 
 	SSACFG const& m_cfg;
+	std::unique_ptr<JunkAdmittingBlocksFinder> m_junkAdmittingBlocks;
 	size_t m_functionIndex;
 	LivenessAnalysis const* m_liveness;
 	std::stringstream m_result{};
 };
 }
 
+std::string SSACFG::ValueId::str(SSACFG const& _cfg) const
+{
+	if (!hasValue())
+		return "INVALID";
+	switch (kind())
+	{
+		case Kind::Literal:  return toCompactHexWithPrefix(_cfg.literalInfo(*this).value);
+		case Kind::Variable: return fmt::format("v{}", value());
+		case Kind::Phi: return fmt::format("phi{}", value());
+		case Kind::Unreachable: return "[unreachable]";
+	}
+	unreachable();
+}
+
+
 std::string SSACFG::toDot(
 	bool _includeDiGraphDefinition,
 	std::optional<size_t> _functionIndex,
@@ -305,7 +314,7 @@ std::string SSACFG::toDot(
 {
 	std::ostringstream output;
 	if (_includeDiGraphDefinition)
-		output << "digraph SSACFG {\nnodesep=0.7;\ngraph[fontname=\"DejaVu Sans\"]\nnode[shape=box,fontname=\"DejaVu Sans\"];\n\n";
+		output << "digraph SSACFG {\nnodesep=0.7;\ngraph[fontname=\"DejaVu Sans\", rankdir=LR]\nnode[shape=box,fontname=\"DejaVu Sans\"];\n\n";
 	if (function)
 		output << SSACFGPrinter(*this, _functionIndex ? *_functionIndex : static_cast<size_t>(1), *function, _liveness);
 	else