Merge pull request #16498 from argotorg/ssa_cfg_codegen

Add SSA Yul CFG codegen

Author: clonker

libsolidity/interface/CompilerStack.cpp

@@ -235,6 +235,12 @@ void CompilerStack::setExperimental(bool _experimental)
 	m_experimental = _experimental;
 }
 
+void CompilerStack::setViaSSACFG(bool _viaSSACFG)
+{
+	solAssert(m_stackState < CompilationSuccessful, "Must set SSA CFG codegen before compilation.");
+	m_viaSSACFG = _viaSSACFG;
+}
+
 void CompilerStack::setEVMVersion(langutil::EVMVersion _version)
 {
 	solAssert(m_stackState < ParsedAndImported, "Must set EVM version before parsing.");
@@ -325,6 +331,7 @@ void CompilerStack::reset(bool _keepSettings)
 		m_importRemapper.clear();
 		m_libraries.clear();
 		m_viaIR = false;
+		m_viaSSACFG = false;
 		m_evmVersion = langutil::EVMVersion();
 		m_eofVersion.reset();
 		m_modelCheckerSettings = ModelCheckerSettings{};
@@ -773,6 +780,9 @@ CompilerStack::PipelineConfig CompilerStack::requestedPipelineConfig(ContractDef
 bool CompilerStack::compile(State _stopAfter)
 {
 	m_stopAfter = _stopAfter;
+
+	solAssert(!m_viaSSACFG || m_experimental, "SSA CFG code generation is an experimental feature. It requires experimental mode to be enabled.");
+
 	if (m_stackState < AnalysisSuccessful)
 		if (!parseAndAnalyze(_stopAfter))
 			return false;
@@ -1672,7 +1682,7 @@ void CompilerStack::generateEVMFromIR(ContractDefinition const& _contract)
 
 	std::string deployedName = IRNames::deployedObject(_contract);
 	solAssert(!deployedName.empty(), "");
-	tie(compiledContract.evmAssembly, compiledContract.evmRuntimeAssembly) = stack.assembleEVMWithDeployed(deployedName);
+	tie(compiledContract.evmAssembly, compiledContract.evmRuntimeAssembly) = stack.assembleEVMWithDeployed(deployedName, m_viaSSACFG);
 
 	if (stack.hasErrors())
 	{

libsolidity/interface/CompilerStack.h

@@ -223,6 +223,10 @@ class CompilerStack: public langutil::CharStreamProvider, public evmasm::Abstrac
 	/// Must be set before parsing.
 	void setViaIR(bool _viaIR);
 
+	/// Sets the pipeline to use the SSA CFG code generator instead of OptimizedEVMCodeTransform.
+	/// Must be set before compilation.
+	void setViaSSACFG(bool _viaSSACFG);
+
 	/// Sets the experimental toggle to allow usage of experimental features.
 	void setExperimental(bool _experimental);
 
@@ -610,6 +614,7 @@ class CompilerStack: public langutil::CharStreamProvider, public evmasm::Abstrac
 	RevertStrings m_revertStrings = RevertStrings::Default;
 	State m_stopAfter = State::CompilationSuccessful;
 	bool m_viaIR = false;
+	bool m_viaSSACFG = false;
 	bool m_experimental = false;
 	langutil::EVMVersion m_evmVersion;
 	std::optional<uint8_t> m_eofVersion;

libyul/CMakeLists.txt

@@ -74,6 +74,8 @@ add_library(yul
 	backends/evm/VariableReferenceCounter.h
 	backends/evm/VariableReferenceCounter.cpp
 	backends/evm/ssa/BridgeFinder.h
+	backends/evm/ssa/CodeTransform.cpp
+	backends/evm/ssa/CodeTransform.h
 	backends/evm/ssa/ControlFlow.cpp
 	backends/evm/ssa/ControlFlow.h
 	backends/evm/ssa/JunkAdmittingBlocksFinder.cpp

libyul/YulStack.cpp

@@ -192,9 +192,9 @@ bool YulStack::analyzeParsed(Object& _object)
 	return success;
 }
 
-void YulStack::compileEVM(AbstractAssembly& _assembly, bool _optimize) const
+void YulStack::compileEVM(AbstractAssembly& _assembly, bool _optimize, bool _viaSSACFG) const
 {
-	EVMObjectCompiler::compile(*m_parserResult, _assembly, _optimize);
+	EVMObjectCompiler::compile(*m_parserResult, _assembly, _optimize, _viaSSACFG);
 }
 
 void YulStack::reparse()
@@ -232,7 +232,7 @@ void YulStack::reparse()
 	// locations and fewer warnings.
 }
 
-MachineAssemblyObject YulStack::assemble(Machine _machine)
+MachineAssemblyObject YulStack::assemble(Machine _machine, bool _viaSSACFG)
 {
 	yulAssert(m_stackState >= AnalysisSuccessful);
 	yulAssert(m_parserResult, "");
@@ -242,17 +242,17 @@ MachineAssemblyObject YulStack::assemble(Machine _machine)
 	switch (_machine)
 	{
 	case Machine::EVM:
-		return assembleWithDeployed().first;
+		return assembleWithDeployed({}, _viaSSACFG).first;
 	}
 	unreachable();
 }
 
 std::pair<MachineAssemblyObject, MachineAssemblyObject>
-YulStack::assembleWithDeployed(std::optional<std::string_view> _deployName)
+YulStack::assembleWithDeployed(std::optional<std::string_view> _deployName, bool _viaSSACFG)
 {
 	yulAssert(m_charStream);
 
-	auto [creationAssembly, deployedAssembly] = assembleEVMWithDeployed(_deployName);
+	auto [creationAssembly, deployedAssembly] = assembleEVMWithDeployed(_deployName, _viaSSACFG);
 	if (!creationAssembly)
 	{
 		yulAssert(!deployedAssembly);
@@ -307,7 +307,7 @@ YulStack::assembleWithDeployed(std::optional<std::string_view> _deployName)
 }
 
 std::pair<std::shared_ptr<evmasm::Assembly>, std::shared_ptr<evmasm::Assembly>>
-YulStack::assembleEVMWithDeployed(std::optional<std::string_view> _deployName)
+YulStack::assembleEVMWithDeployed(std::optional<std::string_view> _deployName, bool _viaSSACFG)
 {
 	yulAssert(m_stackState >= AnalysisSuccessful);
 	yulAssert(m_parserResult, "");
@@ -326,7 +326,7 @@ YulStack::assembleEVMWithDeployed(std::optional<std::string_view> _deployName)
 	);
 	try
 	{
-		compileEVM(adapter, optimize);
+		compileEVM(adapter, optimize, _viaSSACFG);
 
 		assembly.optimise(evmasm::Assembly::OptimiserSettings::translateSettings(m_optimiserSettings));
 

libyul/YulStack.h

@@ -118,23 +118,25 @@ class YulStack: public langutil::CharStreamProvider
 	void optimize();
 
 	/// Run the assembly step (should only be called after parseAndAnalyze).
-	MachineAssemblyObject assemble(Machine _machine);
+	MachineAssemblyObject assemble(Machine _machine, bool _viaSSACFG = false);
 
 	/// Run the assembly step (should only be called after parseAndAnalyze).
 	/// In addition to the value returned by @a assemble, returns
 	/// a second object that is the runtime code.
 	/// Only available for EVM.
 	std::pair<MachineAssemblyObject, MachineAssemblyObject>
 	assembleWithDeployed(
-		std::optional<std::string_view> _deployName = {}
+		std::optional<std::string_view> _deployName = {},
+		bool _viaSSACFG = false
 	);
 
 	/// Run the assembly step (should only be called after parseAndAnalyze).
 	/// Similar to @a assemblyWithDeployed, but returns EVM assembly objects.
 	/// Only available for EVM.
 	std::pair<std::shared_ptr<evmasm::Assembly>, std::shared_ptr<evmasm::Assembly>>
 	assembleEVMWithDeployed(
-		std::optional<std::string_view> _deployName = {}
+		std::optional<std::string_view> _deployName = {},
+		bool _viaSSACFG = false
 	);
 
 	/// @returns the errors generated during parsing, analysis (and potentially assembly).
@@ -161,7 +163,7 @@ class YulStack: public langutil::CharStreamProvider
 	bool analyzeParsed();
 	bool analyzeParsed(yul::Object& _object);
 
-	void compileEVM(yul::AbstractAssembly& _assembly, bool _optimize) const;
+	void compileEVM(yul::AbstractAssembly& _assembly, bool _optimize, bool _viaSSACFG) const;
 
 	/// Prints the Yul object stored internally and parses it again.
 	/// This ensures that the debug info in the AST matches the source that printing would produce

libyul/backends/evm/EVMObjectCompiler.cpp

@@ -21,6 +21,10 @@
 
 #include <libyul/backends/evm/EVMObjectCompiler.h>
 
+#include <libyul/backends/evm/ssa/CodeTransform.h>
+#include <libyul/backends/evm/ssa/SSACFGBuilder.h>
+#include <libyul/backends/evm/ssa/ControlFlow.h>
+
 #include <libyul/backends/evm/EVMCodeTransform.h>
 #include <libyul/backends/evm/EVMDialect.h>
 #include <libyul/backends/evm/OptimizedEVMCodeTransform.h>
@@ -37,14 +41,15 @@ using namespace solidity::yul;
 void EVMObjectCompiler::compile(
 	Object const& _object,
 	AbstractAssembly& _assembly,
-	bool _optimize
+	bool _optimize,
+	bool _viaSSACFG
 )
 {
 	EVMObjectCompiler compiler(_assembly);
-	compiler.run(_object, _optimize);
+	compiler.run(_object, _optimize, _viaSSACFG);
 }
 
-void EVMObjectCompiler::run(Object const& _object, bool _optimize)
+void EVMObjectCompiler::run(Object const& _object, bool _optimize, bool _viaSSACFG)
 {
 	yulAssert(_object.dialect());
 	auto const* evmDialect = dynamic_cast<EVMDialect const*>(_object.dialect());
@@ -61,7 +66,7 @@ void EVMObjectCompiler::run(Object const& _object, bool _optimize)
 			auto subAssemblyAndID = m_assembly.createSubAssembly(isCreation, subObject->name);
 			context.subIDs[subObject->name] = subAssemblyAndID.second;
 			subObject->subId = subAssemblyAndID.second;
-			compile(*subObject, *subAssemblyAndID.first, _optimize);
+			compile(*subObject, *subAssemblyAndID.first, _optimize, _viaSSACFG);
 		}
 		else
 		{
@@ -82,33 +87,51 @@ void EVMObjectCompiler::run(Object const& _object, bool _optimize)
 	}
 	if (_optimize && evmDialect->evmVersion().canOverchargeGasForCall())
 	{
-		auto stackErrors = OptimizedEVMCodeTransform::run(
-			m_assembly,
-			*_object.analysisInfo,
-			_object.code()->root(),
-			*evmDialect,
-			context,
-			OptimizedEVMCodeTransform::UseNamedLabels::ForFirstFunctionOfEachName
-		);
-		if (!stackErrors.empty())
+		if (_viaSSACFG)
 		{
-			yulAssert(evmDialect->providesObjectAccess());
-			auto const memoryGuardHandle = evmDialect->findBuiltin("memoryguard");
-			yulAssert(memoryGuardHandle, "Compiling with object access, memoryguard should be available as builtin.");
-			std::vector<FunctionCall const*> memoryGuardCalls = findFunctionCalls(
+			std::unique_ptr<ssa::ControlFlow> controlFlow = ssa::SSACFGBuilder::build(
+				*_object.analysisInfo,
+				*_object.dialect(),
 				_object.code()->root(),
-				*memoryGuardHandle
+				false
 			);
-			auto stackError = stackErrors.front();
-			std::string msg = stackError.comment() ? *stackError.comment() : "";
-			if (memoryGuardCalls.empty())
-				msg += "\nNo memoryguard was present. "
-					"Consider using memory-safe assembly only and annotating it via "
-					"'assembly (\"memory-safe\") { ... }'.";
-			else
-				msg += "\nmemoryguard was present.";
-			stackError << util::errinfo_comment(msg);
-			BOOST_THROW_EXCEPTION(stackError);
+			ssa::ControlFlowLiveness const liveness(*controlFlow);
+			ssa::CodeTransform::run(
+				m_assembly,
+				liveness,
+				context
+			);
+		}
+		else
+		{
+			auto stackErrors = OptimizedEVMCodeTransform::run(
+				m_assembly,
+				*_object.analysisInfo,
+				_object.code()->root(),
+				*evmDialect,
+				context,
+				OptimizedEVMCodeTransform::UseNamedLabels::ForFirstFunctionOfEachName
+			);
+			if (!stackErrors.empty())
+			{
+				yulAssert(evmDialect->providesObjectAccess());
+				auto const memoryGuardHandle = evmDialect->findBuiltin("memoryguard");
+				yulAssert(memoryGuardHandle, "Compiling with object access, memoryguard should be available as builtin.");
+				std::vector<FunctionCall const*> memoryGuardCalls = findFunctionCalls(
+					_object.code()->root(),
+					*memoryGuardHandle
+				);
+				auto stackError = stackErrors.front();
+				std::string msg = stackError.comment() ? *stackError.comment() : "";
+				if (memoryGuardCalls.empty())
+					msg += "\nNo memoryguard was present. "
+						"Consider using memory-safe assembly only and annotating it via "
+						"'assembly (\"memory-safe\") { ... }'.";
+				else
+					msg += "\nmemoryguard was present.";
+				stackError << util::errinfo_comment(msg);
+				BOOST_THROW_EXCEPTION(stackError);
+			}
 		}
 	}
 	else

libyul/backends/evm/EVMObjectCompiler.h

@@ -36,12 +36,13 @@ class EVMObjectCompiler
 	static void compile(
 		Object const& _object,
 		AbstractAssembly& _assembly,
-		bool _optimize
+		bool _optimize,
+		bool _viaSSACFG = false
 	);
 private:
 	EVMObjectCompiler(AbstractAssembly& _assembly): m_assembly(_assembly) {}
 
-	void run(Object const& _object, bool _optimize);
+	void run(Object const& _object, bool _optimize, bool _viaSSACFG);
 
 	AbstractAssembly& m_assembly;
 };