English documentation updates up to v0.8.27-105-g256e95281 (2024-10-03)

liblangutil/EVMVersion.cpp

@@ -26,23 +26,26 @@ using namespace solidity;
 using namespace solidity::evmasm;
 using namespace solidity::langutil;
 
-bool EVMVersion::hasOpcode(Instruction _opcode) const
+bool EVMVersion::hasOpcode(Instruction _opcode, std::optional<uint8_t> _eofVersion) const
 {
+	// EOF version can be only defined since prague
+	assert(!_eofVersion.has_value() || this->m_version >= prague());
+
 	switch (_opcode)
 	{
 	case Instruction::RETURNDATACOPY:
 	case Instruction::RETURNDATASIZE:
 		return supportsReturndata();
 	case Instruction::STATICCALL:
-		return hasStaticCall();
+		return !_eofVersion.has_value() && hasStaticCall();
 	case Instruction::SHL:
 	case Instruction::SHR:
 	case Instruction::SAR:
 		return hasBitwiseShifting();
 	case Instruction::CREATE2:
-		return hasCreate2();
+		return !_eofVersion.has_value() && hasCreate2();
 	case Instruction::EXTCODEHASH:
-		return hasExtCodeHash();
+		return !_eofVersion.has_value() && hasExtCodeHash();
 	case Instruction::CHAINID:
 		return hasChainID();
 	case Instruction::SELFBALANCE:
@@ -58,6 +61,21 @@ bool EVMVersion::hasOpcode(Instruction _opcode) const
 	case Instruction::TSTORE:
 	case Instruction::TLOAD:
 		return supportsTransientStorage();
+	// Instructions below are deprecated in EOF
+	case Instruction::CALL:
+	case Instruction::CALLCODE:
+	case Instruction::DELEGATECALL:
+	case Instruction::SELFDESTRUCT:
+	case Instruction::JUMP:
+	case Instruction::JUMPI:
+	case Instruction::PC:
+	case Instruction::CREATE:
+	case Instruction::CODESIZE:
+	case Instruction::CODECOPY:
+	case Instruction::EXTCODESIZE:
+	case Instruction::EXTCODECOPY:
+	case Instruction::GAS:
+		return !_eofVersion.has_value();
 	default:
 		return true;
 	}

liblangutil/EVMVersion.h

@@ -124,7 +124,7 @@ class EVMVersion:
 	bool hasMcopy() const { return *this >= cancun(); }
 	bool supportsTransientStorage() const { return *this >= cancun(); }
 
-	bool hasOpcode(evmasm::Instruction _opcode) const;
+	bool hasOpcode(evmasm::Instruction _opcode, std::optional<uint8_t> _eofVersion) const;
 
 	/// Whether we have to retain the costs for the call opcode itself (false),
 	/// or whether we can just forward easily all remaining gas (true).

libsolidity/ast/ASTJsonExporter.cpp

@@ -664,12 +664,21 @@ bool ASTJsonExporter::visit(InlineAssembly const& _node)
 	for (Json& it: externalReferences | ranges::views::values)
 		externalReferencesJson.emplace_back(std::move(it));
 
+	auto const& evmDialect = dynamic_cast<solidity::yul::EVMDialect const&>(_node.dialect());
+
 	std::vector<std::pair<std::string, Json>> attributes = {
 		std::make_pair("AST", Json(yul::AsmJsonConverter(sourceIndexFromLocation(_node.location()))(_node.operations().root()))),
 		std::make_pair("externalReferences", std::move(externalReferencesJson)),
-		std::make_pair("evmVersion", dynamic_cast<solidity::yul::EVMDialect const&>(_node.dialect()).evmVersion().name())
+		std::make_pair("evmVersion", evmDialect.evmVersion().name())
 	};
 
+	// TODO: Add test in test/linsolidity/ASTJSON/assembly. This requires adding support for eofVersion in ASTJSONTest
+	if (evmDialect.eofVersion())
+	{
+		solAssert(*evmDialect.eofVersion() > 0);
+		attributes.push_back(std::make_pair("eofVersion", *evmDialect.eofVersion()));
+	}
+
 	if (_node.flags())
 	{
 		Json flags = Json::array();

libsolidity/ast/ASTJsonImporter.cpp

@@ -720,7 +720,16 @@ ASTPointer<InlineAssembly> ASTJsonImporter::createInlineAssembly(Json const& _no
 	astAssert(evmVersion.has_value(), "Invalid EVM version!");
 	astAssert(m_evmVersion == evmVersion, "Imported tree evm version differs from configured evm version!");
 
-	yul::Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(evmVersion.value());
+	// TODO: Add test in test/linsolidity/ASTJSON/assembly. This requires adding support for eofVersion in ASTJSONTest
+	std::optional<uint8_t> eofVersion;
+	if (auto const it = _node.find("eofVersion"); it != _node.end())
+	{
+		eofVersion = it->get<uint8_t>();
+		astAssert(eofVersion > 0);
+	}
+	astAssert(m_eofVersion == eofVersion, "Imported tree EOF version differs from configured EOF version!");
+
+	yul::Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(evmVersion.value(), eofVersion);
 	ASTPointer<std::vector<ASTPointer<ASTString>>> flags;
 	if (_node.contains("flags"))
 	{

libsolidity/ast/ASTJsonImporter.h

@@ -40,8 +40,8 @@ namespace solidity::frontend
 class ASTJsonImporter
 {
 public:
-	ASTJsonImporter(langutil::EVMVersion _evmVersion)
-		:m_evmVersion(_evmVersion)
+	ASTJsonImporter(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion)
+		:m_evmVersion(_evmVersion), m_eofVersion(_eofVersion)
 	{}
 
 	/// Converts the AST from JSON-format to ASTPointer
@@ -166,6 +166,8 @@ class ASTJsonImporter
 	std::set<int64_t> m_usedIDs;
 	/// Configured EVM version
 	langutil::EVMVersion m_evmVersion;
+	/// Configured EOF version. Equals std::nullopt if non-EOF
+	std::optional<uint8_t> m_eofVersion;
 };
 
 }

libsolidity/codegen/CompilerContext.cpp

@@ -436,7 +436,7 @@ void CompilerContext::appendInlineAssembly(
 	ErrorList errors;
 	ErrorReporter errorReporter(errors);
 	langutil::CharStream charStream(_assembly, _sourceName);
-	yul::EVMDialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion);
+	yul::EVMDialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion, std::nullopt);
 	std::optional<langutil::SourceLocation> locationOverride;
 	if (!_system)
 		locationOverride = m_asm->currentSourceLocation();
@@ -522,6 +522,7 @@ void CompilerContext::appendInlineAssembly(
 		analysisInfo,
 		*m_asm,
 		m_evmVersion,
+		std::nullopt,
 		identifierAccess.generateCode,
 		_system,
 		_optimiserSettings.optimizeStackAllocation

libsolidity/codegen/ContractCompiler.cpp

@@ -958,6 +958,7 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 		*analysisInfo,
 		*m_context.assemblyPtr(),
 		m_context.evmVersion(),
+		std::nullopt,
 		identifierAccessCodeGen,
 		false,
 		m_optimiserSettings.optimizeStackAllocation

libsolidity/interface/CompilerStack.cpp

@@ -357,7 +357,7 @@ bool CompilerStack::parse()
 
 	try
 	{
-		Parser parser{m_errorReporter, m_evmVersion};
+		Parser parser{m_errorReporter, m_evmVersion, m_eofVersion};
 
 		std::vector<std::string> sourcesToParse;
 		for (auto const& s: m_sources)
@@ -427,7 +427,8 @@ bool CompilerStack::parse()
 void CompilerStack::importASTs(std::map<std::string, Json> const& _sources)
 {
 	solAssert(m_stackState == Empty, "Must call importASTs only before the SourcesSet state.");
-	std::map<std::string, ASTPointer<SourceUnit>> reconstructedSources = ASTJsonImporter(m_evmVersion).jsonToSourceUnit(_sources);
+	std::map<std::string, ASTPointer<SourceUnit>> reconstructedSources =
+		ASTJsonImporter(m_evmVersion, m_eofVersion).jsonToSourceUnit(_sources);
 	for (auto& src: reconstructedSources)
 	{
 		solUnimplementedAssert(!src.second->experimentalSolidity());
@@ -896,7 +897,7 @@ Json CompilerStack::generatedSources(std::string const& _contractName, bool _run
 			ErrorList errors;
 			ErrorReporter errorReporter(errors);
 			CharStream charStream(source, sourceName);
-			yul::EVMDialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion);
+			yul::EVMDialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion, m_eofVersion);
 			std::shared_ptr<yul::AST> parserResult = yul::Parser{errorReporter, dialect}.parse(charStream);
 			solAssert(parserResult);
 			sources[0]["ast"] = yul::AsmJsonConverter{sourceIndex}(parserResult->root());

libsolidity/parsing/Parser.cpp

@@ -1448,7 +1448,7 @@ ASTPointer<InlineAssembly> Parser::parseInlineAssembly(ASTPointer<ASTString> con
 	SourceLocation location = currentLocation();
 
 	expectToken(Token::Assembly);
-	yul::Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion);
+	yul::Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion, m_eofVersion);
 	if (m_scanner->currentToken() == Token::StringLiteral)
 	{
 		if (m_scanner->currentLiteral() != "evmasm")

libsolidity/parsing/Parser.h

@@ -40,10 +40,12 @@ class Parser: public langutil::ParserBase
 public:
 	explicit Parser(
 		langutil::ErrorReporter& _errorReporter,
-		langutil::EVMVersion _evmVersion
+		langutil::EVMVersion _evmVersion,
+		std::optional<uint8_t> _eofVersion
 	):
 		ParserBase(_errorReporter),
-		m_evmVersion(_evmVersion)
+		m_evmVersion(_evmVersion),
+		m_eofVersion(_eofVersion)
 	{}
 
 	ASTPointer<SourceUnit> parse(langutil::CharStream& _charStream);
@@ -247,6 +249,7 @@ class Parser: public langutil::ParserBase
 	/// Flag that signifies whether '_' is parsed as a PlaceholderStatement or a regular identifier.
 	bool m_insideModifier = false;
 	langutil::EVMVersion m_evmVersion;
+	std::optional<uint8_t> m_eofVersion;
 	/// Counter for the next AST node ID
 	int64_t m_currentNodeID = 0;
 	/// Flag that indicates whether experimental mode is enabled in the current source unit

libyul/AsmAnalysis.cpp

@@ -625,7 +625,8 @@ void AsmAnalyzer::expectValidIdentifier(YulName _identifier, SourceLocation cons
 bool AsmAnalyzer::validateInstructions(std::string const& _instructionIdentifier, langutil::SourceLocation const& _location)
 {
 	// NOTE: This function uses the default EVM version instead of the currently selected one.
-	auto const builtin = EVMDialect::strictAssemblyForEVM(EVMVersion{}).builtin(YulName(_instructionIdentifier));
+	// TODO: Add EOF support
+	auto const builtin = EVMDialect::strictAssemblyForEVM(EVMVersion{}, std::nullopt).builtin(YulName(_instructionIdentifier));
 	if (builtin && builtin->instruction.has_value())
 		return validateInstructions(builtin->instruction.value(), _location);
 	else

libyul/ObjectOptimizer.cpp

@@ -43,13 +43,13 @@ using namespace solidity::util;
 using namespace solidity::yul;
 
 
-Dialect const& yul::languageToDialect(Language _language, EVMVersion _version)
+Dialect const& yul::languageToDialect(Language _language, EVMVersion _version, std::optional<uint8_t> _eofVersion)
 {
 	switch (_language)
 	{
 	case Language::Assembly:
 	case Language::StrictAssembly:
-		return EVMDialect::strictAssemblyForEVMObjects(_version);
+		return EVMDialect::strictAssemblyForEVMObjects(_version, _eofVersion);
 	}
 	util::unreachable();
 }
@@ -77,7 +77,7 @@ void ObjectOptimizer::optimize(Object& _object, Settings const& _settings, bool
 			);
 		}
 
-	Dialect const& dialect = languageToDialect(_settings.language, _settings.evmVersion);
+	Dialect const& dialect = languageToDialect(_settings.language, _settings.evmVersion, _settings.eofVersion);
 	std::unique_ptr<GasMeter> meter;
 	if (EVMDialect const* evmDialect = dynamic_cast<EVMDialect const*>(&dialect))
 		meter = std::make_unique<GasMeter>(*evmDialect, _isCreation, _settings.expectedExecutionsPerDeployment);
@@ -158,6 +158,8 @@ std::optional<h256> ObjectOptimizer::calculateCacheKey(
 	rawKey += h256(u256(_settings.expectedExecutionsPerDeployment)).asBytes();
 	rawKey += FixedHash<1>(uint8_t(_isCreation ? 0 : 1)).asBytes();
 	rawKey += keccak256(_settings.evmVersion.name()).asBytes();
+	yulAssert(!_settings.eofVersion.has_value() || *_settings.eofVersion > 0);
+	rawKey += FixedHash<1>(uint8_t(_settings.eofVersion ? 0 : *_settings.eofVersion)).asBytes();
 	rawKey += keccak256(_settings.yulOptimiserSteps).asBytes();
 	rawKey += keccak256(_settings.yulOptimiserCleanupSteps).asBytes();
 

libyul/ObjectOptimizer.h

@@ -38,7 +38,7 @@ enum class Language
 	StrictAssembly,
 };
 
-Dialect const& languageToDialect(Language _language, langutil::EVMVersion _version);
+Dialect const& languageToDialect(Language _language, langutil::EVMVersion _version, std::optional<uint8_t> _eofVersion);
 
 /// Encapsulates logic for applying @a yul::OptimiserSuite to a whole hierarchy of Yul objects.
 /// Also, acts as a transparent cache for optimized objects.
@@ -58,6 +58,7 @@ class ObjectOptimizer
 	{
 		Language language;
 		langutil::EVMVersion evmVersion;
+		std::optional<uint8_t> eofVersion;
 		bool optimizeStackAllocation;
 		std::string yulOptimiserSteps;
 		std::string yulOptimiserCleanupSteps;

libyul/YulStack.cpp

@@ -57,7 +57,7 @@ bool YulStack::parse(std::string const& _sourceName, std::string const& _source)
 	{
 		m_charStream = std::make_unique<CharStream>(_source, _sourceName);
 		std::shared_ptr<Scanner> scanner = std::make_shared<Scanner>(*m_charStream);
-		m_parserResult = ObjectParser(m_errorReporter, languageToDialect(m_language, m_evmVersion)).parse(scanner, false);
+		m_parserResult = ObjectParser(m_errorReporter, languageToDialect(m_language, m_evmVersion, m_eofVersion)).parse(scanner, false);
 	}
 	catch (UnimplementedFeatureError const& _error)
 	{
@@ -94,7 +94,7 @@ void YulStack::optimize()
 	{
 		if (
 			!m_optimiserSettings.runYulOptimiser &&
-			yul::MSizeFinder::containsMSize(languageToDialect(m_language, m_evmVersion), *m_parserResult)
+			yul::MSizeFinder::containsMSize(languageToDialect(m_language, m_evmVersion, m_eofVersion), *m_parserResult)
 		)
 			return;
 
@@ -130,6 +130,7 @@ void YulStack::optimize()
 			ObjectOptimizer::Settings{
 				m_language,
 				m_evmVersion,
+				m_eofVersion,
 				optimizeStackAllocation,
 				yulOptimiserSteps,
 				yulOptimiserCleanupSteps,
@@ -163,7 +164,7 @@ bool YulStack::analyzeParsed(Object& _object)
 	AsmAnalyzer analyzer(
 		*_object.analysisInfo,
 		m_errorReporter,
-		languageToDialect(m_language, m_evmVersion),
+		languageToDialect(m_language, m_evmVersion, m_eofVersion),
 		{},
 		_object.qualifiedDataNames()
 	);
@@ -196,7 +197,7 @@ void YulStack::compileEVM(AbstractAssembly& _assembly, bool _optimize) const
 	{
 		case Language::Assembly:
 		case Language::StrictAssembly:
-			dialect = &EVMDialect::strictAssemblyForEVMObjects(m_evmVersion);
+			dialect = &EVMDialect::strictAssemblyForEVMObjects(m_evmVersion, m_eofVersion);
 			break;
 		default:
 			yulAssert(false, "Invalid language.");
@@ -316,7 +317,7 @@ YulStack::assembleEVMWithDeployed(std::optional<std::string_view> _deployName)
 	// it with the minimal steps required to avoid "stack too deep".
 	bool optimize = m_optimiserSettings.optimizeStackAllocation || (
 		!m_optimiserSettings.runYulOptimiser &&
-		!yul::MSizeFinder::containsMSize(languageToDialect(m_language, m_evmVersion), *m_parserResult)
+		!yul::MSizeFinder::containsMSize(languageToDialect(m_language, m_evmVersion, m_eofVersion), *m_parserResult)
 	);
 	try
 	{
@@ -385,7 +386,7 @@ Json YulStack::cfgJson() const
 		// NOTE: The block Ids are reset for each object
 		std::unique_ptr<ControlFlow> controlFlow = SSAControlFlowGraphBuilder::build(
 			*_object.analysisInfo.get(),
-			languageToDialect(m_language, m_evmVersion),
+			languageToDialect(m_language, m_evmVersion, m_eofVersion),
 			_object.code()->root()
 		);
 		YulControlFlowGraphExporter exporter(*controlFlow);

libyul/backends/evm/AsmCodeGen.cpp

@@ -38,6 +38,7 @@ void CodeGenerator::assemble(
 	AsmAnalysisInfo& _analysisInfo,
 	evmasm::Assembly& _assembly,
 	langutil::EVMVersion _evmVersion,
+	std::optional<uint8_t> _eofVersion,
 	ExternalIdentifierAccess::CodeGenerator _identifierAccessCodeGen,
 	bool _useNamedLabelsForFunctions,
 	bool _optimizeStackAllocation
@@ -49,7 +50,7 @@ void CodeGenerator::assemble(
 		assemblyAdapter,
 		_analysisInfo,
 		_parsedData,
-		EVMDialect::strictAssemblyForEVM(_evmVersion),
+		EVMDialect::strictAssemblyForEVM(_evmVersion, _eofVersion),
 		builtinContext,
 		_optimizeStackAllocation,
 		_identifierAccessCodeGen,

libyul/backends/evm/AsmCodeGen.h

@@ -44,6 +44,7 @@ class CodeGenerator
 		AsmAnalysisInfo& _analysisInfo,
 		evmasm::Assembly& _assembly,
 		langutil::EVMVersion _evmVersion,
+		std::optional<uint8_t> _eofVersion,
 		ExternalIdentifierAccess::CodeGenerator _identifierAccess = {},
 		bool _useNamedLabelsForFunctions = false,
 		bool _optimizeStackAllocation = false

libyul/backends/evm/EVMDialect.cpp

@@ -177,7 +177,7 @@ std::set<YulName> createReservedIdentifiers(langutil::EVMVersion _evmVersion)
 	return reserved;
 }
 
-std::map<YulName, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _evmVersion, bool _objectAccess)
+std::map<YulName, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion, bool _objectAccess)
 {
 
 	// Exclude prevrandao as builtin for VMs before paris and difficulty for VMs after paris.
@@ -199,7 +199,7 @@ std::map<YulName, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _ev
 			opcode != evmasm::Instruction::JUMP &&
 			opcode != evmasm::Instruction::JUMPI &&
 			opcode != evmasm::Instruction::JUMPDEST &&
-			_evmVersion.hasOpcode(opcode) &&
+			_evmVersion.hasOpcode(opcode, _eofVersion) &&
 			!prevRandaoException(name)
 		)
 			builtins.emplace(createEVMFunction(_evmVersion, name, opcode));
@@ -235,113 +235,116 @@ std::map<YulName, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _ev
 			})
 		);
 
-		builtins.emplace(createFunction("datasize", 1, 1, SideEffects{}, {LiteralKind::String}, [](
-			FunctionCall const& _call,
-			AbstractAssembly& _assembly,
-			BuiltinContext& _context
-		) {
-			yulAssert(_context.currentObject, "No object available.");
-			yulAssert(_call.arguments.size() == 1, "");
-			Expression const& arg = _call.arguments.front();
-			YulName const dataName (formatLiteral(std::get<Literal>(arg)));
-			if (_context.currentObject->name == dataName.str())
-				_assembly.appendAssemblySize();
-			else
-			{
-			std::vector<size_t> subIdPath =
-					_context.subIDs.count(dataName.str()) == 0 ?
-						_context.currentObject->pathToSubObject(dataName.str()) :
-						std::vector<size_t>{_context.subIDs.at(dataName.str())};
-				yulAssert(!subIdPath.empty(), "Could not find assembly object <" + dataName.str() + ">.");
-				_assembly.appendDataSize(subIdPath);
-			}
-		}));
-		builtins.emplace(createFunction("dataoffset", 1, 1, SideEffects{}, {LiteralKind::String}, [](
-			FunctionCall const& _call,
-			AbstractAssembly& _assembly,
-			BuiltinContext& _context
-		) {
-			yulAssert(_context.currentObject, "No object available.");
-			yulAssert(_call.arguments.size() == 1, "");
-			Expression const& arg = _call.arguments.front();
-			YulName const dataName (formatLiteral(std::get<Literal>(arg)));
-			if (_context.currentObject->name == dataName.str())
-				_assembly.appendConstant(0);
-			else
-			{
-			std::vector<size_t> subIdPath =
-					_context.subIDs.count(dataName.str()) == 0 ?
-						_context.currentObject->pathToSubObject(dataName.str()) :
-						std::vector<size_t>{_context.subIDs.at(dataName.str())};
-				yulAssert(!subIdPath.empty(), "Could not find assembly object <" + dataName.str() + ">.");
-				_assembly.appendDataOffset(subIdPath);
-			}
-		}));
-		builtins.emplace(createFunction(
-			"datacopy",
-			3,
-			0,
-			SideEffects{
-				false,               // movable
-				true,                // movableApartFromEffects
-				false,               // canBeRemoved
-				false,               // canBeRemovedIfNotMSize
-				true,                // cannotLoop
-				SideEffects::None,   // otherState
-				SideEffects::None,   // storage
-				SideEffects::Write,  // memory
-				SideEffects::None    // transientStorage
-			},
-			{},
-			[](
-				FunctionCall const&,
-				AbstractAssembly& _assembly,
-				BuiltinContext&
-			) {
-				_assembly.appendInstruction(evmasm::Instruction::CODECOPY);
-			}
-		));
-		builtins.emplace(createFunction(
-			"setimmutable",
-			3,
-			0,
-			SideEffects{
-				false,               // movable
-				false,               // movableApartFromEffects
-				false,               // canBeRemoved
-				false,               // canBeRemovedIfNotMSize
-				true,                // cannotLoop
-				SideEffects::None,   // otherState
-				SideEffects::None,   // storage
-				SideEffects::Write,  // memory
-				SideEffects::None    // transientStorage
-			},
-			{std::nullopt, LiteralKind::String, std::nullopt},
-			[](
+		if (!_eofVersion.has_value())
+		{
+			builtins.emplace(createFunction("datasize", 1, 1, SideEffects{}, {LiteralKind::String}, [](
 				FunctionCall const& _call,
 				AbstractAssembly& _assembly,
-				BuiltinContext&
+				BuiltinContext& _context
 			) {
-				yulAssert(_call.arguments.size() == 3, "");
-				auto const identifier = (formatLiteral(std::get<Literal>(_call.arguments[1])));
-				_assembly.appendImmutableAssignment(identifier);
-			}
-		));
-		builtins.emplace(createFunction(
-			"loadimmutable",
-			1,
-			1,
-			SideEffects{},
-			{LiteralKind::String},
-			[](
+				yulAssert(_context.currentObject, "No object available.");
+				yulAssert(_call.arguments.size() == 1, "");
+				Expression const& arg = _call.arguments.front();
+				YulName const dataName (formatLiteral(std::get<Literal>(arg)));
+				if (_context.currentObject->name == dataName.str())
+					_assembly.appendAssemblySize();
+				else
+				{
+				std::vector<size_t> subIdPath =
+						_context.subIDs.count(dataName.str()) == 0 ?
+							_context.currentObject->pathToSubObject(dataName.str()) :
+							std::vector<size_t>{_context.subIDs.at(dataName.str())};
+					yulAssert(!subIdPath.empty(), "Could not find assembly object <" + dataName.str() + ">.");
+					_assembly.appendDataSize(subIdPath);
+				}
+			}));
+			builtins.emplace(createFunction("dataoffset", 1, 1, SideEffects{}, {LiteralKind::String}, [](
 				FunctionCall const& _call,
 				AbstractAssembly& _assembly,
-				BuiltinContext&
+				BuiltinContext& _context
 			) {
+				yulAssert(_context.currentObject, "No object available.");
 				yulAssert(_call.arguments.size() == 1, "");
-				_assembly.appendImmutable(formatLiteral(std::get<Literal>(_call.arguments.front())));
-			}
-		));
+				Expression const& arg = _call.arguments.front();
+				YulName const dataName (formatLiteral(std::get<Literal>(arg)));
+				if (_context.currentObject->name == dataName.str())
+					_assembly.appendConstant(0);
+				else
+				{
+				std::vector<size_t> subIdPath =
+						_context.subIDs.count(dataName.str()) == 0 ?
+							_context.currentObject->pathToSubObject(dataName.str()) :
+							std::vector<size_t>{_context.subIDs.at(dataName.str())};
+					yulAssert(!subIdPath.empty(), "Could not find assembly object <" + dataName.str() + ">.");
+					_assembly.appendDataOffset(subIdPath);
+				}
+			}));
+			builtins.emplace(createFunction(
+				"datacopy",
+				3,
+				0,
+				SideEffects{
+					false,               // movable
+					true,                // movableApartFromEffects
+					false,               // canBeRemoved
+					false,               // canBeRemovedIfNotMSize
+					true,                // cannotLoop
+					SideEffects::None,   // otherState
+					SideEffects::None,   // storage
+					SideEffects::Write,  // memory
+					SideEffects::None    // transientStorage
+				},
+				{},
+				[](
+					FunctionCall const&,
+					AbstractAssembly& _assembly,
+					BuiltinContext&
+				) {
+					_assembly.appendInstruction(evmasm::Instruction::CODECOPY);
+				}
+			));
+			builtins.emplace(createFunction(
+				"setimmutable",
+				3,
+				0,
+				SideEffects{
+					false,               // movable
+					false,               // movableApartFromEffects
+					false,               // canBeRemoved
+					false,               // canBeRemovedIfNotMSize
+					true,                // cannotLoop
+					SideEffects::None,   // otherState
+					SideEffects::None,   // storage
+					SideEffects::Write,  // memory
+					SideEffects::None    // transientStorage
+				},
+				{std::nullopt, LiteralKind::String, std::nullopt},
+				[](
+					FunctionCall const& _call,
+					AbstractAssembly& _assembly,
+					BuiltinContext&
+				) {
+					yulAssert(_call.arguments.size() == 3, "");
+					auto const identifier = (formatLiteral(std::get<Literal>(_call.arguments[1])));
+					_assembly.appendImmutableAssignment(identifier);
+				}
+			));
+			builtins.emplace(createFunction(
+				"loadimmutable",
+				1,
+				1,
+				SideEffects{},
+				{LiteralKind::String},
+				[](
+					FunctionCall const& _call,
+					AbstractAssembly& _assembly,
+					BuiltinContext&
+				) {
+					yulAssert(_call.arguments.size() == 1, "");
+					_assembly.appendImmutable(formatLiteral(std::get<Literal>(_call.arguments.front())));
+				}
+			));
+		}
 	}
 	return builtins;
 }
@@ -355,10 +358,11 @@ std::regex const& verbatimPattern()
 }
 
 
-EVMDialect::EVMDialect(langutil::EVMVersion _evmVersion, bool _objectAccess):
+EVMDialect::EVMDialect(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion, bool _objectAccess):
 	m_objectAccess(_objectAccess),
 	m_evmVersion(_evmVersion),
-	m_functions(createBuiltins(_evmVersion, _objectAccess)),
+	m_eofVersion(_eofVersion),
+	m_functions(createBuiltins(_evmVersion, _eofVersion, _objectAccess)),
 	m_reserved(createReservedIdentifiers(_evmVersion))
 {
 }
@@ -386,22 +390,22 @@ bool EVMDialect::reservedIdentifier(YulName _name) const
 	return m_reserved.count(_name) != 0;
 }
 
-EVMDialect const& EVMDialect::strictAssemblyForEVM(langutil::EVMVersion _version)
+EVMDialect const& EVMDialect::strictAssemblyForEVM(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion)
 {
-	static std::map<langutil::EVMVersion, std::unique_ptr<EVMDialect const>> dialects;
+	static std::map<std::pair<langutil::EVMVersion, std::optional<uint8_t>>, std::unique_ptr<EVMDialect const>> dialects;
 	static YulStringRepository::ResetCallback callback{[&] { dialects.clear(); }};
-	if (!dialects[_version])
-		dialects[_version] = std::make_unique<EVMDialect>(_version, false);
-	return *dialects[_version];
+	if (!dialects[{_evmVersion, _eofVersion}])
+		dialects[{_evmVersion, _eofVersion}] = std::make_unique<EVMDialect>(_evmVersion, _eofVersion, false);
+	return *dialects[{_evmVersion, _eofVersion}];
 }
 
-EVMDialect const& EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion _version)
+EVMDialect const& EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion)
 {
-	static std::map<langutil::EVMVersion, std::unique_ptr<EVMDialect const>> dialects;
+	static std::map<std::pair<langutil::EVMVersion, std::optional<uint8_t>>, std::unique_ptr<EVMDialect const>> dialects;
 	static YulStringRepository::ResetCallback callback{[&] { dialects.clear(); }};
-	if (!dialects[_version])
-		dialects[_version] = std::make_unique<EVMDialect>(_version, true);
-	return *dialects[_version];
+	if (!dialects[{_evmVersion, _eofVersion}])
+		dialects[{_evmVersion, _eofVersion}] = std::make_unique<EVMDialect>(_evmVersion, _eofVersion, true);
+	return *dialects[{_evmVersion, _eofVersion}];
 }
 
 SideEffects EVMDialect::sideEffectsOfInstruction(evmasm::Instruction _instruction)

libyul/backends/evm/EVMDialect.h

@@ -65,7 +65,7 @@ struct BuiltinFunctionForEVM: public BuiltinFunction
 struct EVMDialect: public Dialect
 {
 	/// Constructor, should only be used internally. Use the factory functions below.
-	EVMDialect(langutil::EVMVersion _evmVersion, bool _objectAccess);
+	EVMDialect(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion, bool _objectAccess);
 
 	/// @returns the builtin function of the given name or a nullptr if it is not a builtin function.
 	BuiltinFunctionForEVM const* builtin(YulName _name) const override;
@@ -82,10 +82,11 @@ struct EVMDialect: public Dialect
 	BuiltinFunctionForEVM const* storageLoadFunction() const override { return builtin("sload"_yulname); }
 	YulName hashFunction() const override { return "keccak256"_yulname; }
 
-	static EVMDialect const& strictAssemblyForEVM(langutil::EVMVersion _version);
-	static EVMDialect const& strictAssemblyForEVMObjects(langutil::EVMVersion _version);
+	static EVMDialect const& strictAssemblyForEVM(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion);
+	static EVMDialect const& strictAssemblyForEVMObjects(langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion);
 
 	langutil::EVMVersion evmVersion() const { return m_evmVersion; }
+	std::optional<uint8_t> eofVersion() const { return m_eofVersion; }
 
 	bool providesObjectAccess() const { return m_objectAccess; }
 
@@ -96,6 +97,7 @@ struct EVMDialect: public Dialect
 
 	bool const m_objectAccess;
 	langutil::EVMVersion const m_evmVersion;
+	std::optional<uint8_t> m_eofVersion;
 	std::map<YulName, BuiltinFunctionForEVM> m_functions;
 	std::map<std::pair<size_t, size_t>, std::shared_ptr<BuiltinFunctionForEVM const>> mutable m_verbatimFunctions;
 	std::set<YulName> m_reserved;

libyul/backends/evm/NoOutputAssembly.cpp

@@ -130,7 +130,7 @@ void NoOutputAssembly::appendImmutableAssignment(std::string const&)
 }
 
 NoOutputEVMDialect::NoOutputEVMDialect(EVMDialect const& _copyFrom):
-	EVMDialect(_copyFrom.evmVersion(), _copyFrom.providesObjectAccess())
+	EVMDialect(_copyFrom.evmVersion(), _copyFrom.eofVersion(), _copyFrom.providesObjectAccess())
 {
 	for (auto& fun: m_functions)
 	{

test/libsolidity/Assembly.cpp

@@ -56,7 +56,11 @@ evmasm::AssemblyItems compileContract(std::shared_ptr<CharStream> _sourceCode)
 {
 	ErrorList errors;
 	ErrorReporter errorReporter(errors);
-	Parser parser(errorReporter, solidity::test::CommonOptions::get().evmVersion());
+	Parser parser(
+		errorReporter,
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
+	);
 	ASTPointer<SourceUnit> sourceUnit;
 	BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(*_sourceCode));
 	BOOST_CHECK(!!sourceUnit);

test/libsolidity/MemoryGuardTest.cpp

@@ -62,7 +62,7 @@ TestCase::TestResult MemoryGuardTest::run(std::ostream& _stream, std::string con
 		ErrorList errors;
 		auto [object, analysisInfo] = yul::test::parse(
 			compiler().yulIR(contractName),
-			EVMDialect::strictAssemblyForEVMObjects(CommonOptions::get().evmVersion()),
+			EVMDialect::strictAssemblyForEVMObjects(CommonOptions::get().evmVersion(), CommonOptions::get().eofVersion()),
 			errors
 		);
 

test/libsolidity/SolidityExpressionCompiler.cpp

@@ -108,7 +108,11 @@ bytes compileFirstExpression(
 	{
 		ErrorList errors;
 		ErrorReporter errorReporter(errors);
-		sourceUnit = Parser(errorReporter, solidity::test::CommonOptions::get().evmVersion()).parse(stream);
+		sourceUnit = Parser(
+			errorReporter,
+			solidity::test::CommonOptions::get().evmVersion(),
+			solidity::test::CommonOptions::get().eofVersion()
+		).parse(stream);
 		if (!sourceUnit)
 			return bytes();
 	}

test/libsolidity/SolidityParser.cpp

@@ -44,7 +44,8 @@ ASTPointer<ContractDefinition> parseText(std::string const& _source, ErrorList&
 	auto charStream = CharStream(_source, "");
 	ASTPointer<SourceUnit> sourceUnit = Parser(
 		errorReporter,
-		solidity::test::CommonOptions::get().evmVersion()
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
 	).parse(charStream);
 	if (!sourceUnit)
 		return ASTPointer<ContractDefinition>();

test/libyul/Common.cpp

@@ -46,7 +46,10 @@ namespace
 {
 Dialect const& defaultDialect()
 {
-	return yul::EVMDialect::strictAssemblyForEVM(solidity::test::CommonOptions::get().evmVersion());
+	return yul::EVMDialect::strictAssemblyForEVM(
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
+	);
 }
 }
 
@@ -101,11 +104,11 @@ std::string yul::test::format(std::string const& _source)
 
 namespace
 {
-std::map<std::string const, yul::Dialect const& (*)(langutil::EVMVersion)> const validDialects = {
+std::map<std::string const, yul::Dialect const& (*)(langutil::EVMVersion, std::optional<uint8_t>)> const validDialects = {
 	{
 		"evm",
-		[](langutil::EVMVersion _evmVersion) -> yul::Dialect const&
-		{ return yul::EVMDialect::strictAssemblyForEVMObjects(_evmVersion); }
+		[](langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion) -> yul::Dialect const&
+		{ return yul::EVMDialect::strictAssemblyForEVMObjects(_evmVersion, _eofVersion); }
 	}
 };
 
@@ -118,7 +121,7 @@ std::map<std::string const, yul::Dialect const& (*)(langutil::EVMVersion)> const
 }
 }
 
-yul::Dialect const& yul::test::dialect(std::string const& _name, langutil::EVMVersion _evmVersion)
+yul::Dialect const& yul::test::dialect(std::string const& _name, langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion)
 {
 	if (!validDialects.count(_name))
 		BOOST_THROW_EXCEPTION(std::runtime_error{
@@ -129,5 +132,5 @@ yul::Dialect const& yul::test::dialect(std::string const& _name, langutil::EVMVe
 			"."
 		});
 
-	return validDialects.at(_name)(_evmVersion);
+	return validDialects.at(_name)(_evmVersion, _eofVersion);
 }

test/libyul/Common.h

@@ -54,6 +54,6 @@ parse(std::string const& _source, Dialect const& _dialect, langutil::ErrorList&
 Block disambiguate(std::string const& _source);
 std::string format(std::string const& _source);
 
-solidity::yul::Dialect const& dialect(std::string const& _name, langutil::EVMVersion _evmVersion);
+solidity::yul::Dialect const& dialect(std::string const& _name, langutil::EVMVersion _evmVersion, std::optional<uint8_t> _eofVersion);
 
 }

test/libyul/CompilabilityChecker.cpp

@@ -38,7 +38,11 @@ std::string check(std::string const& _input)
 	auto parsingResult = yul::test::parse(_input);
 	obj.setCode(parsingResult.first, parsingResult.second);
 	BOOST_REQUIRE(obj.hasCode());
-	auto functions = CompilabilityChecker(EVMDialect::strictAssemblyForEVM(solidity::test::CommonOptions::get().evmVersion()), obj, true).stackDeficit;
+	auto functions = CompilabilityChecker(
+		EVMDialect::strictAssemblyForEVM(
+			solidity::test::CommonOptions::get().evmVersion(),
+			solidity::test::CommonOptions::get().eofVersion()
+		), obj, true).stackDeficit;
 	std::string out;
 	for (auto const& function: functions)
 		out += function.first.str() + ": " + std::to_string(function.second) + " ";

test/libyul/ControlFlowGraphTest.cpp

@@ -45,7 +45,11 @@ ControlFlowGraphTest::ControlFlowGraphTest(std::string const& _filename):
 {
 	m_source = m_reader.source();
 	auto dialectName = m_reader.stringSetting("dialect", "evm");
-	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+	m_dialect = &dialect(
+		dialectName,
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
+	);
 	m_expectation = m_reader.simpleExpectations();
 }
 

test/libyul/ControlFlowSideEffectsTest.cpp

@@ -62,8 +62,9 @@ TestCase::TestResult ControlFlowSideEffectsTest::run(std::ostream& _stream, std:
 	if (!obj.hasCode())
 		BOOST_THROW_EXCEPTION(std::runtime_error("Parsing input failed."));
 
+	// TODO: Add EOF support
 	ControlFlowSideEffectsCollector sideEffects(
-		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion(), std::nullopt),
 		obj.code()->root()
 	);
 	m_obtainedResult.clear();

test/libyul/EVMCodeTransformTest.cpp

@@ -67,12 +67,14 @@ TestCase::TestResult EVMCodeTransformTest::run(std::ostream& _stream, std::strin
 		return TestResult::FatalError;
 	}
 
+	// TODO: Add EOF support
 	evmasm::Assembly assembly{solidity::test::CommonOptions::get().evmVersion(), false, std::nullopt, {}};
 	EthAssemblyAdapter adapter(assembly);
 	EVMObjectCompiler::compile(
 		*stack.parserResult(),
 		adapter,
-		EVMDialect::strictAssemblyForEVMObjects(EVMVersion{}),
+		// TODO: Make sure that why we cannot pass here solidity::test::CommonOptions::get().evmVersion() and assembly.eofVersion()
+		EVMDialect::strictAssemblyForEVMObjects(EVMVersion{}, std::nullopt),
 		m_stackOpt,
 		std::nullopt
 	);

test/libyul/FunctionSideEffects.cpp

@@ -88,8 +88,9 @@ TestCase::TestResult FunctionSideEffects::run(std::ostream& _stream, std::string
 	if (!obj.hasCode())
 		BOOST_THROW_EXCEPTION(std::runtime_error("Parsing input failed."));
 
+	// TODO: Add EOF support
 	std::map<YulName, SideEffects> functionSideEffects = SideEffectsPropagator::sideEffects(
-		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion(), std::nullopt),
 		CallGraphGenerator::callGraph(obj.code()->root())
 	);
 

test/libyul/KnowledgeBaseTest.cpp

@@ -63,7 +63,8 @@ class KnowledgeBaseTest
 		return KnowledgeBase([this](YulName _var) { return util::valueOrNullptr(m_values, _var); });
 	}
 
-	EVMDialect m_dialect{EVMVersion{}, true};
+	// TODO: Add EOF support
+	EVMDialect m_dialect{EVMVersion{}, std::nullopt, true};
 	std::shared_ptr<Object> m_object;
 	SSAValueTracker m_ssaValues;
 	std::map<YulName, AssignedValue> m_values;

test/libyul/ObjectParser.cpp

@@ -112,7 +112,8 @@ std::tuple<std::optional<SourceNameMap>, ErrorList> tryGetSourceLocationMapping(
 
 	ErrorList errors;
 	ErrorReporter reporter(errors);
-	Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(EVMVersion::berlin());
+	// TODO: Add EOF support
+	Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(EVMVersion{}, std::nullopt);
 	ObjectParser objectParser{reporter, dialect};
 	CharStream stream(std::move(source), "");
 	auto object = objectParser.parse(std::make_shared<Scanner>(stream), false);

test/libyul/SSAControlFlowGraphTest.cpp

@@ -48,7 +48,11 @@ SSAControlFlowGraphTest::SSAControlFlowGraphTest(std::string const& _filename):
 {
 	m_source = m_reader.source();
 	auto dialectName = m_reader.stringSetting("dialect", "evm");
-	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+	m_dialect = &dialect(
+		dialectName,
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
+	);
 	m_expectation = m_reader.simpleExpectations();
 }
 

test/libyul/StackLayoutGeneratorTest.cpp

@@ -49,7 +49,11 @@ StackLayoutGeneratorTest::StackLayoutGeneratorTest(std::string const& _filename)
 {
 	m_source = m_reader.source();
 	auto dialectName = m_reader.stringSetting("dialect", "evm");
-	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+	m_dialect = &dialect(
+		dialectName,
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
+	);
 	m_expectation = m_reader.simpleExpectations();
 }
 

test/libyul/SyntaxTest.cpp

@@ -75,5 +75,9 @@ SyntaxTest::SyntaxTest(std::string const& _filename, langutil::EVMVersion _evmVe
 	CommonSyntaxTest(_filename, _evmVersion)
 {
 	std::string dialectName = m_reader.stringSetting("dialect", "evm");
-	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+	m_dialect = &dialect(
+		dialectName,
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
+	);
 }

test/libyul/YulInterpreterTest.cpp

@@ -98,7 +98,7 @@ std::string YulInterpreterTest::interpret()
 	{
 		Interpreter::run(
 			state,
-			EVMDialect::strictAssemblyForEVMObjects(solidity::test::CommonOptions::get().evmVersion()),
+			EVMDialect::strictAssemblyForEVMObjects(solidity::test::CommonOptions::get().evmVersion(), std::nullopt),
 			m_ast->root(),
 			/*disableExternalCalls=*/ !m_simulateExternalCallsToSelf,
 			/*disableMemoryTracing=*/ false

test/libyul/YulOptimizerTest.cpp

@@ -56,7 +56,11 @@ YulOptimizerTest::YulOptimizerTest(std::string const& _filename):
 	m_source = m_reader.source();
 
 	auto dialectName = m_reader.stringSetting("dialect", "evm");
-	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+	m_dialect = &dialect(
+		dialectName,
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion()
+	);
 
 	m_expectation = m_reader.simpleExpectations();
 }

test/tools/ossfuzz/StackReuseCodegenFuzzer.cpp

@@ -105,8 +105,9 @@ DEFINE_PROTO_FUZZER(Program const& _input)
 		YulAssembler assembler{version, std::nullopt, settings, yul_source};
 		unoptimisedByteCode = assembler.assemble();
 		auto yulObject = assembler.object();
+		// TODO: Add EOF support
 		recursiveFunction = recursiveFunctionExists(
-			EVMDialect::strictAssemblyForEVMObjects(version),
+			EVMDialect::strictAssemblyForEVMObjects(version, std::nullopt),
 			*yulObject
 		);
 	}

test/tools/ossfuzz/strictasm_diff_ossfuzz.cpp

@@ -87,10 +87,11 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size)
 	// such as unused write to memory e.g.,
 	// { mstore(0, 1) }
 	// that would be removed by the redundant store eliminator.
+	// TODO: Add EOF support
 	yulFuzzerUtil::TerminationReason termReason = yulFuzzerUtil::interpret(
 		os1,
 		stack.parserResult()->code()->root(),
-		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion(), std::nullopt),
 		/*disableMemoryTracing=*/true
 	);
 	if (yulFuzzerUtil::resourceLimitsExceeded(termReason))
@@ -100,7 +101,7 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size)
 	termReason = yulFuzzerUtil::interpret(
 		os2,
 		stack.parserResult()->code()->root(),
-		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion(), std::nullopt),
 		/*disableMemoryTracing=*/true
 	);
 

test/tools/ossfuzz/yulProtoFuzzer.cpp

@@ -78,10 +78,11 @@ DEFINE_PROTO_FUZZER(Program const& _input)
 	)
 		yulAssert(false, "Proto fuzzer generated malformed program");
 
+	// TODO: Add EOF support
 	// Optimize
 	YulOptimizerTestCommon optimizerTest(
 		stack.parserResult(),
-		EVMDialect::strictAssemblyForEVMObjects(version)
+		EVMDialect::strictAssemblyForEVMObjects(version, std::nullopt)
 	);
 	optimizerTest.setStep(optimizerTest.randomOptimiserStep(_input.step()));
 	auto const* astRoot = optimizerTest.run();

test/tools/ossfuzz/yulProto_diff_ossfuzz.cpp

@@ -87,27 +87,30 @@ DEFINE_PROTO_FUZZER(Program const& _input)
 	// such as unused write to memory e.g.,
 	// { mstore(0, 1) }
 	// that would be removed by the redundant store eliminator.
+	// TODO: Add EOF support
 	yulFuzzerUtil::TerminationReason termReason = yulFuzzerUtil::interpret(
 		os1,
 		stack.parserResult()->code()->root(),
-		EVMDialect::strictAssemblyForEVMObjects(version),
+		EVMDialect::strictAssemblyForEVMObjects(version, std::nullopt),
 		/*disableMemoryTracing=*/true
 	);
 
 	if (yulFuzzerUtil::resourceLimitsExceeded(termReason))
 		return;
 
+	// TODO: Add EOF support
 	YulOptimizerTestCommon optimizerTest(
 		stack.parserResult(),
-		EVMDialect::strictAssemblyForEVMObjects(version)
+		EVMDialect::strictAssemblyForEVMObjects(version, std::nullopt)
 	);
 	optimizerTest.setStep(optimizerTest.randomOptimiserStep(_input.step()));
 	auto const* astRoot = optimizerTest.run();
 	yulAssert(astRoot != nullptr, "Optimiser error.");
+	// TODO: Add EOF support
 	termReason = yulFuzzerUtil::interpret(
 		os2,
 		*astRoot,
-		EVMDialect::strictAssemblyForEVMObjects(version),
+		EVMDialect::strictAssemblyForEVMObjects(version, std::nullopt),
 		true
 	);
 	if (yulFuzzerUtil::resourceLimitsExceeded(termReason))

test/tools/yulopti.cpp

@@ -242,7 +242,7 @@ class YulOpti
 
 private:
 	std::shared_ptr<yul::Block> m_astRoot;
-	Dialect const& m_dialect{EVMDialect::strictAssemblyForEVMObjects(EVMVersion{})};
+	Dialect const& m_dialect{EVMDialect::strictAssemblyForEVMObjects(EVMVersion{}, std::nullopt)};
 	std::unique_ptr<AsmAnalysisInfo> m_analysisInfo;
 	std::set<YulName> const m_reservedIdentifiers = {};
 	NameDispenser m_nameDispenser{m_dialect, m_reservedIdentifiers};

test/tools/yulrun.cpp

@@ -87,7 +87,7 @@ void interpret(std::string const& _source, bool _inspect, bool _disableExternalC
 	state.maxTraceSize = 10000;
 	try
 	{
-		Dialect const& dialect(EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion{}));
+		Dialect const& dialect(EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion{}, std::nullopt));
 
 		if (_inspect)
 			InspectedInterpreter::run(std::make_shared<Inspector>(_source, state), state, dialect, ast->root(), _disableExternalCalls, /*disableMemoryTracing=*/false);

tools/yulPhaser/Program.cpp

@@ -68,7 +68,8 @@ Program::Program(Program const& program):
 std::variant<Program, ErrorList> Program::load(CharStream& _sourceCode)
 {
 	// ASSUMPTION: parseSource() rewinds the stream on its own
-	Dialect const& dialect = EVMDialect::strictAssemblyForEVMObjects(EVMVersion{});
+	// TODO: Add support for EOF
+	Dialect const& dialect = EVMDialect::strictAssemblyForEVMObjects(EVMVersion{}, std::nullopt);
 
 	std::variant<std::unique_ptr<AST>, ErrorList> astOrErrors = parseObject(dialect, _sourceCode);
 	if (std::holds_alternative<ErrorList>(astOrErrors))