eof: Enable constant optimizer for EOF.

Author: rodiazet

libevmasm/Assembly.cpp

@@ -940,13 +940,13 @@ std::map<u256, u256> const& Assembly::optimiseInternal(
 		}
 	}
 
-	// TODO: investigate for EOF
-	if (_settings.runConstantOptimiser && !m_eofVersion.has_value())
+	if (_settings.runConstantOptimiser)
 		ConstantOptimisationMethod::optimiseConstants(
 			isCreation(),
 			isCreation() ? 1 : _settings.expectedExecutionsPerDeployment,
 			m_evmVersion,
-			*this
+			*this,
+			m_eofVersion
 		);
 
 	m_tagReplacements = std::move(tagReplacements);
@@ -1601,7 +1601,8 @@ LinkerObject const& Assembly::assembleEOF() const
 	ret.bytecode = headerBytecode;
 
 	m_tagPositionsInBytecode = std::vector<size_t>(m_usedTags, std::numeric_limits<size_t>::max());
-	std::map<size_t, uint16_t> dataSectionRef;
+	std::map<size_t, uint16_t> staticAuxDataSectionRef;
+	std::map<h256, std::vector<size_t>> predeployDataSectionRef;
 	std::map<size_t, size_t> tagRef;
 
 	for (auto&& [codeSectionIndex, codeSection]: m_codeSections | ranges::views::enumerate)
@@ -1677,12 +1678,19 @@ LinkerObject const& Assembly::assembleEOF() const
 			case Tag:
 				ret.bytecode += assembleTag(item, ret.bytecode.size(), false);
 				break;
+			case DataLoadN:
+			{
+				ret.bytecode += assembleOperation(item);
+				predeployDataSectionRef[item.data()].push_back(ret.bytecode.size());
+				appendBigEndianUint16(ret.bytecode, 0u);
+				break;
+			}
 			case AuxDataLoadN:
 			{
 				// In findMaxAuxDataLoadNOffset we already verified that unsigned data value fits 2 bytes
 				solAssert(item.data() <= std::numeric_limits<uint16_t>::max(), "Invalid auxdataloadn position.");
 				ret.bytecode.push_back(uint8_t(Instruction::DATALOADN));
-				dataSectionRef[ret.bytecode.size()] = static_cast<uint16_t>(item.data());
+				staticAuxDataSectionRef[ret.bytecode.size()] = static_cast<uint16_t>(item.data());
 				appendBigEndianUint16(ret.bytecode, item.data());
 				break;
 			}
@@ -1765,7 +1773,14 @@ LinkerObject const& Assembly::assembleEOF() const
 	auto const dataStart = ret.bytecode.size();
 
 	for (auto const& dataItem: m_data)
+	{
+		for (auto const pos: predeployDataSectionRef[dataItem.first])
+		{
+			solAssert(dataItem.second.size() == 32);
+			setBigEndianUint16(ret.bytecode, pos, ret.bytecode.size() - dataStart);
+		}
 		ret.bytecode += dataItem.second;
+	}
 
 	ret.bytecode += m_auxiliaryData;
 
@@ -1784,7 +1799,7 @@ LinkerObject const& Assembly::assembleEOF() const
 
 	// If some data was already added to data section we need to update data section refs accordingly
 	if (preDeployDataSectionSize > 0)
-		for (auto [refPosition, staticAuxDataOffset] : dataSectionRef)
+		for (auto [refPosition, staticAuxDataOffset] : staticAuxDataSectionRef)
 		{
 			// staticAuxDataOffset + preDeployDataSectionSize value is already verified to fit 2 bytes because
 			// staticAuxDataOffset < staticAuxDataSize

libevmasm/Assembly.h

@@ -88,6 +88,7 @@ class Assembly
 	AssemblyItem newPushLibraryAddress(std::string const& _identifier);
 	AssemblyItem newPushImmutable(std::string const& _identifier);
 	AssemblyItem newImmutableAssignment(std::string const& _identifier);
+	AssemblyItem newDataLoadN(bytes const& _data) { util::h256 h(util::keccak256(util::asString(_data))); m_data[h] = _data; return AssemblyItem(DataLoadN, Instruction::DATALOADN, h); }
 	AssemblyItem newAuxDataLoadN(size_t offset) const;
 	AssemblyItem newSwapN(size_t _depth) const;
 	AssemblyItem newDupN(size_t _depth) const;

libevmasm/AssemblyItem.cpp

@@ -121,6 +121,8 @@ std::pair<std::string, std::string> AssemblyItem::nameAndData(langutil::EVMVersi
 		return {"PUSH data", toStringInHex(data())};
 	case VerbatimBytecode:
 		return {"VERBATIM", util::toHex(verbatimData())};
+	case DataLoadN:
+		return {"DATALOADN", util::toString(data())};
 	case AuxDataLoadN:
 		return {"AUXDATALOADN", util::toString(data())};
 	case UndefinedItem:
@@ -188,6 +190,7 @@ size_t AssemblyItem::bytesRequired(size_t _addressLength, langutil::EVMVersion _
 		return std::get<2>(*m_verbatimBytecode).size();
 	case RelativeJump:
 	case ConditionalRelativeJump:
+	case DataLoadN:
 	case AuxDataLoadN:
 	case JumpF:
 	case CallF:
@@ -260,6 +263,7 @@ size_t AssemblyItem::returnValues() const
 		return 0;
 	case VerbatimBytecode:
 		return std::get<1>(*m_verbatimBytecode);
+	case DataLoadN:
 	case AuxDataLoadN:
 		return 1;
 	case JumpF:
@@ -298,6 +302,7 @@ bool AssemblyItem::canBeFunctional() const
 	case PushLibraryAddress:
 	case PushDeployTimeAddress:
 	case PushImmutable:
+	case DataLoadN:
 	case AuxDataLoadN:
 		return true;
 	case Tag:
@@ -406,6 +411,9 @@ std::string AssemblyItem::toAssemblyText(Assembly const& _assembly) const
 		assertThrow(data() <= std::numeric_limits<size_t>::max(), AssemblyException, "Invalid auxdataloadn argument.");
 		text = "auxdataloadn{" +  std::to_string(static_cast<size_t>(data())) + "}";
 		break;
+	case DataLoadN:
+		text = "dataloadn{" +  util::toHex(toCompactBigEndian(data(), 1)) + "}";
+		break;
 	case EOFCreate:
 		text = "eofcreate{" +  std::to_string(static_cast<size_t>(data())) + "}";
 		break;
@@ -509,6 +517,9 @@ std::ostream& solidity::evmasm::operator<<(std::ostream& _out, AssemblyItem cons
 	case VerbatimBytecode:
 		_out << " Verbatim " << util::toHex(_item.verbatimData());
 		break;
+	case DataLoadN:
+		_out << " DataLoadN " << util::toString(_item.data());
+		break;
 	case AuxDataLoadN:
 		_out << " AuxDataLoadN " << util::toString(_item.data());
 		break;

libevmasm/AssemblyItem.h

@@ -52,6 +52,9 @@ enum AssemblyItemType
 	PushImmutable, ///< Push the currently unknown value of an immutable variable. The actual value will be filled in by the constructor.
 	AssignImmutable, ///< Assigns the current value on the stack to an immutable variable. Only valid during creation code.
 
+	/// Loads 32 bytes from static data of EOF data section.
+	/// More details here: https://github.com/ipsilon/eof/blob/main/spec/eof.md#data-section-lifecycle
+	DataLoadN,
 	/// Loads 32 bytes from static auxiliary data of EOF data section. The offset does *not* have to be always from the beginning
 	/// of the data EOF section. More details here: https://github.com/ipsilon/eof/blob/main/spec/eof.md#data-section-lifecycle
 	AuxDataLoadN,
@@ -200,6 +203,7 @@ class AssemblyItem
 			m_type == ReturnContract ||
 			m_type == RelativeJump ||
 			m_type == ConditionalRelativeJump ||
+			m_type == DataLoadN ||
 			m_type == CallF ||
 			m_type == JumpF ||
 			m_type == RetF ||

libevmasm/ConstantOptimiser.cpp

@@ -31,7 +31,8 @@ unsigned ConstantOptimisationMethod::optimiseConstants(
 	bool _isCreation,
 	size_t _runs,
 	langutil::EVMVersion _evmVersion,
-	Assembly& _assembly
+	Assembly& _assembly,
+	std::optional<uint8_t> _eofVersion
 )
 {
 	// TODO: design the optimiser in a way this is not needed
@@ -55,6 +56,7 @@ unsigned ConstantOptimisationMethod::optimiseConstants(
 			params.isCreation = _isCreation;
 			params.runs = _runs;
 			params.evmVersion = _evmVersion;
+			params.eofVersion = _eofVersion;
 			LiteralMethod lit(params, item.data());
 			bigint literalGas = lit.gasNeeded();
 			CodeCopyMethod copy(params, item.data());
@@ -161,73 +163,92 @@ AssemblyItems CodeCopyMethod::execute(Assembly& _assembly) const
 {
 	bytes data = toBigEndian(m_value);
 	assertThrow(data.size() == 32, OptimizerException, "Invalid number encoding.");
-	AssemblyItem newPushData = _assembly.newData(data);
-	return copyRoutine(&newPushData);
+
+	if (m_params.eofVersion.has_value())
+		return AssemblyItems {_assembly.newDataLoadN(data)};
+	else
+	{
+		AssemblyItem newPushData = _assembly.newData(data);
+		return copyRoutine(&newPushData);
+	}
 }
 
-AssemblyItems CodeCopyMethod::copyRoutine(AssemblyItem* _pushData) const
+AssemblyItems CodeCopyMethod::copyRoutine(AssemblyItem* _dataItem) const
 {
-	if (_pushData)
-		assertThrow(_pushData->type() == PushData, OptimizerException, "Invalid Assembly Item.");
-
-	AssemblyItem dataUsed = _pushData ? *_pushData : AssemblyItem(PushData, u256(1) << 16);
-
-	// PUSH0 is cheaper than PUSHn/DUP/SWAP.
-	if (m_params.evmVersion.hasPush0())
+	if (m_params.eofVersion.has_value())
 	{
-		// This costs ~29 gas.
+		// This case is used only for gas calculation.
+		solAssert(_dataItem == nullptr);
 		AssemblyItems copyRoutine{
-			// back up memory
-			// mload(0)
-			u256(0),
-			Instruction::MLOAD,
-
-			// codecopy(0, <offset>, 32)
-			u256(32),
-			dataUsed,
-			u256(0),
-			Instruction::CODECOPY,
-
-			// mload(0)
-			u256(0),
-			Instruction::MLOAD,
-
-			// restore original memory
-			// mstore(0, x)
-			Instruction::SWAP1,
-			u256(0),
-			Instruction::MSTORE
+			AssemblyItem(DataLoadN, Instruction::DATALOADN, u256(1) << 16)
 		};
 		return copyRoutine;
 	}
 	else
 	{
-		// This costs ~33 gas.
-		AssemblyItems copyRoutine{
-			// constant to be reused 3+ times
-			u256(0),
-
-			// back up memory
-			// mload(0)
-			Instruction::DUP1,
-			Instruction::MLOAD,
-
-			// codecopy(0, <offset>, 32)
-			u256(32),
-			dataUsed,
-			Instruction::DUP4,
-			Instruction::CODECOPY,
-
-			// mload(0)
-			Instruction::DUP2,
-			Instruction::MLOAD,
-
-			// restore original memory
-			// mstore(0, x)
-			Instruction::SWAP2,
-			Instruction::MSTORE
-		};
-		return copyRoutine;
+		AssemblyItem* _pushData = _dataItem;
+		if (_pushData)
+			assertThrow(_pushData->type() == PushData, OptimizerException, "Invalid Assembly Item.");
+
+		AssemblyItem dataUsed = _pushData ? *_pushData : AssemblyItem(PushData, u256(1) << 16);
+
+		// PUSH0 is cheaper than PUSHn/DUP/SWAP.
+		if (m_params.evmVersion.hasPush0())
+		{
+			// This costs ~29 gas.
+			AssemblyItems copyRoutine{
+				// back up memory
+				// mload(0)
+				u256(0),
+				Instruction::MLOAD,
+
+				// codecopy(0, <offset>, 32)
+				u256(32),
+				dataUsed,
+				u256(0),
+				Instruction::CODECOPY,
+
+				// mload(0)
+				u256(0),
+				Instruction::MLOAD,
+
+				// restore original memory
+				// mstore(0, x)
+				Instruction::SWAP1,
+				u256(0),
+				Instruction::MSTORE
+			};
+			return copyRoutine;
+		}
+		else
+		{
+			// This costs ~33 gas.
+			AssemblyItems copyRoutine{
+				// constant to be reused 3+ times
+				u256(0),
+
+				// back up memory
+				// mload(0)
+				Instruction::DUP1,
+				Instruction::MLOAD,
+
+				// codecopy(0, <offset>, 32)
+				u256(32),
+				dataUsed,
+				Instruction::DUP4,
+				Instruction::CODECOPY,
+
+				// mload(0)
+				Instruction::DUP2,
+				Instruction::MLOAD,
+
+				// restore original memory
+				// mstore(0, x)
+				Instruction::SWAP2,
+				Instruction::MSTORE
+			};
+			return copyRoutine;
+		}
 	}
 }
 

libevmasm/ConstantOptimiser.h

@@ -51,7 +51,8 @@ class ConstantOptimisationMethod
 		bool _isCreation,
 		size_t _runs,
 		langutil::EVMVersion _evmVersion,
-		Assembly& _assembly
+		Assembly& _assembly,
+		std::optional<uint8_t> _eofVersion
 	);
 
 protected:
@@ -63,6 +64,7 @@ class ConstantOptimisationMethod
 		size_t runs; ///< Estimated number of calls per opcode oven the lifetime of the contract.
 		size_t multiplicity; ///< Number of times the constant appears in the code.
 		langutil::EVMVersion evmVersion; ///< Version of the EVM
+		std::optional<uint8_t> eofVersion; ///< Version of EOF. Legacy EVM if not set.
 	};
 
 	explicit ConstantOptimisationMethod(Params const& _params, u256 const& _value):

test/libsolidity/syntaxTests/sizeLimits/eof/bytecode_too_large.sol

@@ -193,7 +193,9 @@ void FuzzerUtil::testConstantOptimizer(std::string const& _input, bool _quiet)
 				isCreation,
 				runs,
 				langutil::EVMVersion{},
-				tmp
+				tmp,
+				// TODO: Support EOF fuzzing
+				std::nullopt
 			);
 		}
 	}