EVMDialect: add test that enforces builtin handle compatibility

Between current default dialect as well as latest dialect and all other dialects.

Author: clonker

libyul/backends/evm/EVMDialect.cpp

@@ -32,6 +32,7 @@
 
 #include <range/v3/algorithm/all_of.hpp>
 #include <range/v3/view/enumerate.hpp>
+#include <range/v3/view/map.hpp>
 
 #include <regex>
 #include <utility>
@@ -616,6 +617,11 @@ SideEffects EVMDialect::sideEffectsOfInstruction(evmasm::Instruction _instructio
 	};
 }
 
+std::set<std::string_view> EVMDialect::builtinFunctionNames() const
+{
+	return ranges::views::keys(m_builtinFunctionsByName) | ranges::to<std::set>;
+}
+
 BuiltinFunctionForEVM EVMDialect::createVerbatimFunctionFromHandle(BuiltinHandle const& _handle)
 {
 	return std::apply(createVerbatimFunction, verbatimIndexToArgsAndRets(_handle.id));

libyul/backends/evm/EVMDialect.h

@@ -113,6 +113,8 @@ class EVMDialect: public Dialect
 	static size_t constexpr verbatimMaxInputSlots = 100;
 	static size_t constexpr verbatimMaxOutputSlots = 100;
 
+	std::set<std::string_view> builtinFunctionNames() const;
+
 protected:
 	static bool constexpr isVerbatimHandle(BuiltinHandle const& _handle) { return _handle.id < verbatimIDOffset; }
 	static BuiltinFunctionForEVM createVerbatimFunctionFromHandle(BuiltinHandle const& _handle);

test/CMakeLists.txt

@@ -145,6 +145,8 @@ set(libyul_sources
     libyul/ControlFlowSideEffectsTest.h
     libyul/EVMCodeTransformTest.cpp
     libyul/EVMCodeTransformTest.h
+    libyul/EVMDialectCompatibility.h
+    libyul/EVMDialectCompatibility.cpp
     libyul/FunctionSideEffects.cpp
     libyul/FunctionSideEffects.h
     libyul/Inliner.cpp

test/libyul/EVMDialectCompatibility.cpp

@@ -0,0 +1,82 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/EVMDialectCompatibility.h>
+
+#include <boost/test/data/test_case.hpp>
+#include <boost/test/data/monomorphic.hpp>
+
+namespace bdata = boost::unit_test::data;
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+
+BOOST_AUTO_TEST_SUITE(EVMDialectCompatibility)
+
+BOOST_DATA_TEST_CASE(
+	builtin_function_handle_compatibility_non_eof,
+	bdata::make(generateEVMDialectConfigurationsToTest(std::nullopt)),
+	evmDialectConfigurationToTest
+)
+{
+	auto const& dialectToTestAgainst = evmDialectConfigurationToTest.dialect();
+	// no object access for current
+	{
+		auto const& currentDialect = EVMDialect::strictAssemblyForEVM({}, std::nullopt);
+		for (auto const& builtinFunctionName: currentDialect.builtinFunctionNames())
+			requireBuiltinCompatibility(currentDialect, dialectToTestAgainst, builtinFunctionName);
+	}
+	// object access for current
+	{
+		auto const& currentDialect = EVMDialect::strictAssemblyForEVMObjects({}, std::nullopt);
+		for (auto const& builtinFunctionName: currentDialect.builtinFunctionNames())
+			requireBuiltinCompatibility(currentDialect, dialectToTestAgainst, builtinFunctionName);
+	}
+}
+
+BOOST_DATA_TEST_CASE(
+	builtin_function_handle_compatibility_eof,
+	bdata::monomorphic::grid(
+		bdata::make(generateEVMDialectConfigurationsToTest(std::nullopt)) + bdata::make(generateEVMDialectConfigurationsToTest(1)),
+		bdata::make({false, true})
+	),
+	evmDialectConfigurationToTest,
+	withEOF
+)
+{
+	auto const& dialectToTestAgainst = evmDialectConfigurationToTest.dialect();
+	langutil::EVMVersion latestEVMVersion = langutil::EVMVersion::allVersions().back();
+	std::optional<uint8_t> eofVersion = std::nullopt;
+	if (withEOF)
+		eofVersion = 1;
+	// no object access for latest
+	{
+		auto const& latestDialect = EVMDialect::strictAssemblyForEVM(latestEVMVersion, eofVersion);
+		for (auto const& builtinFunctionName: latestDialect.builtinFunctionNames())
+			requireBuiltinCompatibility(latestDialect, dialectToTestAgainst, builtinFunctionName);
+	}
+	// object access for latest
+	{
+		auto const& latestDialect = EVMDialect::strictAssemblyForEVMObjects(latestEVMVersion, eofVersion);
+		for (auto const& builtinFunctionName: latestDialect.builtinFunctionNames())
+			requireBuiltinCompatibility(latestDialect, dialectToTestAgainst, builtinFunctionName);
+	}
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/libyul/EVMDialectCompatibility.h

@@ -0,0 +1,78 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <fmt/format.h>
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+
+namespace solidity::yul::test
+{
+
+inline void requireBuiltinCompatibility(EVMDialect const& _dialect1, EVMDialect const& _dialect2, std::string_view const _builtin)
+{
+	if (auto const currentHandle = _dialect1.findBuiltin(_builtin))
+		if (auto const handle = _dialect2.findBuiltin(_builtin))
+			BOOST_REQUIRE_MESSAGE(
+				*handle == *currentHandle,
+				fmt::format("Failed for \"{}\" with IDs {} =/= {}.", _builtin, currentHandle->id, handle->id)
+			);
+}
+
+struct EVMDialectConfigurationToTest
+{
+	EVMDialect const& dialect() const
+	{
+		return objectAccess ? EVMDialect::strictAssemblyForEVMObjects(evmVersion, eofVersion) : EVMDialect::strictAssemblyForEVM(evmVersion, eofVersion);
+	}
+
+	friend std::ostream& operator<<(std::ostream& _out, EVMDialectConfigurationToTest const& _config)
+	{
+		_out << fmt::format(
+			"EVMConfigurationToTest[{}, eof={}, objectAccess={}]",
+			_config.evmVersion.name(),
+			_config.eofVersion.has_value() ? std::to_string(*_config.eofVersion) : "null",
+			_config.objectAccess
+		);
+		return _out;
+	}
+
+	langutil::EVMVersion evmVersion;
+	std::optional<uint8_t> eofVersion;
+	bool objectAccess;
+};
+
+inline std::vector<EVMDialectConfigurationToTest> generateEVMDialectConfigurationsToTest(std::optional<uint8_t> _eofVersion)
+{
+	std::vector<EVMDialectConfigurationToTest> configs;
+	for (bool providesObjectAccess: {false, true})
+		for (auto evmVersion: langutil::EVMVersion::allVersions())
+			if (!_eofVersion || evmVersion >= langutil::EVMVersion::firstWithEOF())
+				configs.push_back(EVMDialectConfigurationToTest{evmVersion, _eofVersion, providesObjectAccess});
+	return configs;
+}
+
+}