Add experimental EOF options for CLI and Standard JSON.

Co-authored-by: Kamil Śliwak <[email protected]>

Author: ekpyron

libsolidity/codegen/ir/IRGenerator.cpp

@@ -97,6 +97,7 @@ pair<string, string> IRGenerator::run(
 
 	yul::YulStack asmStack(
 		m_evmVersion,
+		m_eofVersion,
 		yul::YulStack::Language::StrictAssembly,
 		m_optimiserSettings,
 		m_context.debugInfoSelection()

libsolidity/codegen/ir/IRGenerator.h

@@ -46,13 +46,15 @@ class IRGenerator
 
 	IRGenerator(
 		langutil::EVMVersion _evmVersion,
+		std::optional<uint8_t> _eofVersion,
 		RevertStrings _revertStrings,
 		OptimiserSettings _optimiserSettings,
 		std::map<std::string, unsigned> _sourceIndices,
 		langutil::DebugInfoSelection const& _debugInfoSelection,
 		langutil::CharStreamProvider const* _soliditySourceProvider
 	):
 		m_evmVersion(_evmVersion),
+		m_eofVersion(_eofVersion),
 		m_optimiserSettings(_optimiserSettings),
 		m_context(
 			_evmVersion,
@@ -138,6 +140,7 @@ class IRGenerator
 	std::string dispenseLocationComment(ASTNode const& _node);
 
 	langutil::EVMVersion const m_evmVersion;
+	std::optional<uint8_t> const m_eofVersion;
 	OptimiserSettings const m_optimiserSettings;
 
 	IRGenerationContext m_context;

libsolidity/interface/CompilerStack.cpp

@@ -225,6 +225,15 @@ void CompilerStack::setEVMVersion(langutil::EVMVersion _version)
 	m_evmVersion = _version;
 }
 
+void CompilerStack::setEOFVersion(std::optional<uint8_t> _version)
+{
+	if (m_stackState >= CompilationSuccessful)
+		solThrow(CompilerError, "Must set EOF version before compiling.");
+	if (_version && _version != 1)
+		solThrow(CompilerError, "Invalid EOF version.");
+	m_eofVersion = _version;
+}
+
 void CompilerStack::setModelCheckerSettings(ModelCheckerSettings _settings)
 {
 	if (m_stackState >= ParsedAndImported)
@@ -1299,6 +1308,7 @@ void CompilerStack::compileContract(
 )
 {
 	solAssert(!m_viaIR, "");
+	solUnimplementedAssert(!m_eofVersion.has_value(), "Experimental EOF support is only available for via-IR compilation.");
 	solAssert(m_stackState >= AnalysisPerformed, "");
 	if (m_hasError)
 		solThrow(CompilerError, "Called compile with errors.");
@@ -1364,7 +1374,15 @@ void CompilerStack::generateIR(ContractDefinition const& _contract)
 	for (auto const& pair: m_contracts)
 		otherYulSources.emplace(pair.second.contract, pair.second.yulIR);
 
-	IRGenerator generator(m_evmVersion, m_revertStrings, m_optimiserSettings, sourceIndices(), m_debugInfoSelection, this);
+	IRGenerator generator(
+		m_evmVersion,
+		m_eofVersion,
+		m_revertStrings,
+		m_optimiserSettings,
+		sourceIndices(),
+		m_debugInfoSelection,
+		this
+	);
 	tie(compiledContract.yulIR, compiledContract.yulIROptimized) = generator.run(
 		_contract,
 		createCBORMetadata(compiledContract, /* _forIR */ true),
@@ -1389,6 +1407,7 @@ void CompilerStack::generateEVMFromIR(ContractDefinition const& _contract)
 	// Re-parse the Yul IR in EVM dialect
 	yul::YulStack stack(
 		m_evmVersion,
+		m_eofVersion,
 		yul::YulStack::Language::StrictAssembly,
 		m_optimiserSettings,
 		m_debugInfoSelection
@@ -1421,6 +1440,7 @@ void CompilerStack::generateEwasm(ContractDefinition const& _contract)
 	// Re-parse the Yul IR in EVM dialect
 	yul::YulStack stack(
 		m_evmVersion,
+		m_eofVersion,
 		yul::YulStack::Language::StrictAssembly,
 		m_optimiserSettings,
 		m_debugInfoSelection
@@ -1571,6 +1591,8 @@ string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) con
 	if (_forIR)
 		meta["settings"]["viaIR"] = _forIR;
 	meta["settings"]["evmVersion"] = m_evmVersion.name();
+	if (m_eofVersion.has_value())
+		meta["settings"]["eofVersion"] = *m_eofVersion;
 	meta["settings"]["compilationTarget"][_contract.contract->sourceUnitName()] =
 		*_contract.contract->annotation().canonicalName;
 
@@ -1695,7 +1717,7 @@ bytes CompilerStack::createCBORMetadata(Contract const& _contract, bool _forIR)
 	else
 		solAssert(m_metadataHash == MetadataHash::None, "Invalid metadata hash");
 
-	if (experimentalMode)
+	if (experimentalMode || m_eofVersion.has_value())
 		encoder.pushBool("experimental", true);
 	if (m_metadataFormat == MetadataFormat::WithReleaseVersionTag)
 		encoder.pushBytes("solc", VersionCompactBytes);

libsolidity/interface/CompilerStack.h

@@ -181,6 +181,10 @@ class CompilerStack: public langutil::CharStreamProvider
 	/// Must be set before parsing.
 	void setEVMVersion(langutil::EVMVersion _version = langutil::EVMVersion{});
 
+	/// Set the EOF version used before running compile.
+	/// If set to std::nullopt (the default), legacy non-EOF bytecode is generated.
+	void setEOFVersion(std::optional<uint8_t> version);
+
 	/// Set model checker settings.
 	void setModelCheckerSettings(ModelCheckerSettings _settings);
 
@@ -498,6 +502,7 @@ class CompilerStack: public langutil::CharStreamProvider
 	State m_stopAfter = State::CompilationSuccessful;
 	bool m_viaIR = false;
 	langutil::EVMVersion m_evmVersion;
+	std::optional<uint8_t> m_eofVersion;
 	ModelCheckerSettings m_modelCheckerSettings;
 	std::map<std::string, std::set<std::string>> m_requestedContractNames;
 	bool m_generateEvmBytecode = true;

libsolidity/interface/StandardCompiler.cpp

@@ -800,6 +800,16 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 		ret.evmVersion = *version;
 	}
 
+	if (settings.isMember("eofVersion"))
+	{
+		if (!settings["eofVersion"].isUInt())
+			return formatFatalError(Error::Type::JSONError, "eofVersion must be an unsigned integer.");
+		auto eofVersion = settings["evmVersion"].asUInt();
+		if (eofVersion != 1)
+			return formatFatalError(Error::Type::JSONError, "Invalid EOF version requested.");
+		ret.eofVersion = 1;
+	}
+
 	if (settings.isMember("debug"))
 	{
 		if (auto result = checkKeys(settings["debug"], {"revertStrings", "debugInfo"}, "settings.debug"))
@@ -1413,6 +1423,7 @@ Json::Value StandardCompiler::compileYul(InputsAndSettings _inputsAndSettings)
 
 	YulStack stack(
 		_inputsAndSettings.evmVersion,
+		_inputsAndSettings.eofVersion,
 		YulStack::Language::StrictAssembly,
 		_inputsAndSettings.optimiserSettings,
 		_inputsAndSettings.debugInfoSelection.has_value() ?

libsolidity/interface/StandardCompiler.h

@@ -77,6 +77,7 @@ class StandardCompiler
 		std::map<std::string, std::string> sources;
 		std::map<util::h256, std::string> smtLib2Responses;
 		langutil::EVMVersion evmVersion;
+		std::optional<uint8_t> eofVersion;
 		std::vector<ImportRemapper::Remapping> remappings;
 		RevertStrings revertStrings = RevertStrings::Default;
 		OptimiserSettings optimiserSettings = OptimiserSettings::minimal();

libyul/YulStack.cpp

@@ -164,7 +164,7 @@ void YulStack::compileEVM(AbstractAssembly& _assembly, bool _optimize) const
 			break;
 	}
 
-	EVMObjectCompiler::compile(*m_parserResult, _assembly, *dialect, _optimize);
+	EVMObjectCompiler::compile(*m_parserResult, _assembly, *dialect, _optimize, m_eofVersion);
 }
 
 void YulStack::optimize(Object& _object, bool _isCreation)

libyul/YulStack.h

@@ -72,6 +72,7 @@ class YulStack: public langutil::CharStreamProvider
 	YulStack():
 		YulStack(
 			langutil::EVMVersion{},
+			std::nullopt,
 			Language::Assembly,
 			solidity::frontend::OptimiserSettings::none(),
 			langutil::DebugInfoSelection::Default()
@@ -80,12 +81,14 @@ class YulStack: public langutil::CharStreamProvider
 
 	YulStack(
 		langutil::EVMVersion _evmVersion,
+		std::optional<uint8_t> _eofVersion,
 		Language _language,
 		solidity::frontend::OptimiserSettings _optimiserSettings,
 		langutil::DebugInfoSelection const& _debugInfoSelection
 	):
 		m_language(_language),
 		m_evmVersion(_evmVersion),
+		m_eofVersion(_eofVersion),
 		m_optimiserSettings(std::move(_optimiserSettings)),
 		m_debugInfoSelection(_debugInfoSelection),
 		m_errorReporter(m_errors)
@@ -146,6 +149,7 @@ class YulStack: public langutil::CharStreamProvider
 
 	Language m_language = Language::Assembly;
 	langutil::EVMVersion m_evmVersion;
+	std::optional<uint8_t> m_eofVersion;
 	solidity::frontend::OptimiserSettings m_optimiserSettings;
 	langutil::DebugInfoSelection m_debugInfoSelection{};
 

libyul/backends/evm/EVMObjectCompiler.cpp

@@ -35,9 +35,15 @@
 using namespace solidity::yul;
 using namespace std;
 
-void EVMObjectCompiler::compile(Object& _object, AbstractAssembly& _assembly, EVMDialect const& _dialect, bool _optimize)
+void EVMObjectCompiler::compile(
+	Object& _object,
+	AbstractAssembly& _assembly,
+	EVMDialect const& _dialect,
+	bool _optimize,
+	std::optional<uint8_t> _eofVersion
+)
 {
-	EVMObjectCompiler compiler(_assembly, _dialect);
+	EVMObjectCompiler compiler(_assembly, _dialect, _eofVersion);
 	compiler.run(_object, _optimize);
 }
 
@@ -54,7 +60,7 @@ void EVMObjectCompiler::run(Object& _object, bool _optimize)
 			auto subAssemblyAndID = m_assembly.createSubAssembly(isCreation, subObject->name.str());
 			context.subIDs[subObject->name] = subAssemblyAndID.second;
 			subObject->subId = subAssemblyAndID.second;
-			compile(*subObject, *subAssemblyAndID.first, m_dialect, _optimize);
+			compile(*subObject, *subAssemblyAndID.first, m_dialect, _optimize, m_eofVersion);
 		}
 		else
 		{
@@ -68,6 +74,11 @@ void EVMObjectCompiler::run(Object& _object, bool _optimize)
 
 	yulAssert(_object.analysisInfo, "No analysis info.");
 	yulAssert(_object.code, "No code.");
+	if (m_eofVersion.has_value())
+		yulAssert(
+			_optimize && (m_dialect.evmVersion() == langutil::EVMVersion()),
+			"Experimental EOF support is only available for optimized via-IR compilation and the most recent EVM version."
+		);
 	if (_optimize && m_dialect.evmVersion().canOverchargeGasForCall())
 	{
 		auto stackErrors = OptimizedEVMCodeTransform::run(

libyul/backends/evm/EVMObjectCompiler.h

@@ -21,6 +21,9 @@
 
 #pragma once
 
+#include <optional>
+#include <cstdint>
+
 namespace solidity::yul
 {
 struct Object;
@@ -30,16 +33,23 @@ struct EVMDialect;
 class EVMObjectCompiler
 {
 public:
-	static void compile(Object& _object, AbstractAssembly& _assembly, EVMDialect const& _dialect, bool _optimize);
+	static void compile(
+		Object& _object,
+		AbstractAssembly& _assembly,
+		EVMDialect const& _dialect,
+		bool _optimize,
+		std::optional<uint8_t> _eofVersion
+	);
 private:
-	EVMObjectCompiler(AbstractAssembly& _assembly, EVMDialect const& _dialect):
-		m_assembly(_assembly), m_dialect(_dialect)
+	EVMObjectCompiler(AbstractAssembly& _assembly, EVMDialect const& _dialect, std::optional<uint8_t> _eofVersion):
+		m_assembly(_assembly), m_dialect(_dialect), m_eofVersion(_eofVersion)
 	{}
 
 	void run(Object& _object, bool _optimize);
 
 	AbstractAssembly& m_assembly;
 	EVMDialect const& m_dialect;
+	std::optional<uint8_t> m_eofVersion;
 };
 
 }