eof: Enable peephole optimizer for EOF.

Author: rodiazet

libevmasm/Assembly.cpp

@@ -843,8 +843,7 @@ std::map<u256, u256> const& Assembly::optimiseInternal(
 			}
 		}
 
-		// TODO: verify this for EOF.
-		if (_settings.runPeephole && !m_eofVersion.has_value())
+		if (_settings.runPeephole)
 		{
 			for (auto& codeSection: m_codeSections)
 			{

libevmasm/AssemblyItem.h

@@ -244,7 +244,7 @@ class AssemblyItem
 	/// Shortcut that avoids constructing an AssemblyItem just to perform the comparison.
 	bool operator==(Instruction _instr) const
 	{
-		return type() == Operation && instruction() == _instr;
+		return hasInstruction() && instruction() == _instr;
 	}
 	bool operator!=(Instruction _instr) const { return !operator==(_instr); }
 

libevmasm/PeepholeOptimiser.cpp

@@ -563,7 +563,9 @@ struct TruthyAnd: SimplePeepholeOptimizerMethod<TruthyAnd>
 	}
 };
 
-/// Removes everything after a JUMP (or similar) until the next JUMPDEST.
+/// Removes everything after an non-continuing instruction until the next Tag.
+/// Note: JUMPF can return but to the caller's parent call frame.
+/// So it won't continue from the next to the JUMPF instruction
 struct UnreachableCode
 {
 	static bool apply(OptimiserState& _state)
@@ -572,14 +574,18 @@ struct UnreachableCode
 		auto end = _state.items.end();
 		if (it == end)
 			return false;
+
 		if (
 			it[0] != Instruction::JUMP &&
-			it[0] != Instruction::RJUMP &&
 			it[0] != Instruction::RETURN &&
 			it[0] != Instruction::STOP &&
 			it[0] != Instruction::INVALID &&
 			it[0] != Instruction::SELFDESTRUCT &&
-			it[0] != Instruction::REVERT
+			it[0] != Instruction::REVERT &&
+			it[0] != Instruction::RJUMP &&
+			it[0] != Instruction::JUMPF &&
+			it[0] != Instruction::RETF &&
+			it[0] != Instruction::RETURNCONTRACT
 		)
 			return false;
 

test/Common.cpp

@@ -313,6 +313,13 @@ boost::unit_test::precondition::predicate_t nonEOF()
 	};
 }
 
+boost::unit_test::precondition::predicate_t onEOF()
+{
+	return [](boost::unit_test::test_unit_id) {
+		return solidity::test::CommonOptions::get().eofVersion().has_value();
+	};
+}
+
 boost::unit_test::precondition::predicate_t minEVMVersionCheck(langutil::EVMVersion _minEVMVersion)
 {
 	return [_minEVMVersion](boost::unit_test::test_unit_id) {

test/Common.h

@@ -116,6 +116,10 @@ boost::unit_test::precondition::predicate_t minEVMVersionCheck(langutil::EVMVers
 /// @return A predicate (function) that can be passed into @a boost::unit_test::precondition().
 boost::unit_test::precondition::predicate_t nonEOF();
 
+/// Helper that can be used to skip tests when the legacy bytecode is not supported by the test case.
+/// @return A predicate (function) that can be passed into @a boost::unit_test::precondition().
+boost::unit_test::precondition::predicate_t onEOF();
+
 bool loadVMs(CommonOptions const& _options);
 
 /**

test/libevmasm/Optimiser.cpp

@@ -1009,6 +1009,46 @@ BOOST_AUTO_TEST_CASE(clear_unreachable_code)
 	);
 }
 
+BOOST_AUTO_TEST_CASE(clear_unreachable_code_eof, *boost::unit_test::precondition(onEOF()))
+{
+	for (auto const& blockTerminatingItem:
+		 {
+			AssemblyItem::relativeJumpTo(AssemblyItem(Tag, 1)),
+			AssemblyItem::jumpToFunction(1, 0, 0),
+			AssemblyItem::functionReturn(),
+			AssemblyItem::returnContract(0),
+		}
+ 	)
+	{
+		AssemblyItems items{
+			blockTerminatingItem,
+			u256(0),
+			Instruction::SLOAD,
+			AssemblyItem(Tag, 2),
+			u256(5),
+			u256(6),
+			Instruction::SSTORE,
+			blockTerminatingItem,
+			u256(5),
+			u256(6)
+		};
+		AssemblyItems expectation{
+			blockTerminatingItem,
+			AssemblyItem(Tag, 2),
+			u256(5),
+			u256(6),
+			Instruction::SSTORE,
+			blockTerminatingItem,
+		};
+		PeepholeOptimiser peepOpt(items, solidity::test::CommonOptions::get().evmVersion());
+		BOOST_REQUIRE(peepOpt.optimise());
+		BOOST_CHECK_EQUAL_COLLECTIONS(
+			items.begin(), items.end(),
+			expectation.begin(), expectation.end()
+		);
+	}
+}
+
 BOOST_AUTO_TEST_CASE(deduplicateNextTagBlockSize3)
 {
 	AssemblyItems items{