Merge pull request #15751 from ethereum/cpp20

clonker · web-flow · commit 96c8f383bafa · 2025-01-28T18:06:18.000+01:00
Switch from c++17 to c++20 and reactivate fully static builds
diff --git a/.circleci/config.yml b/.circleci/config.yml
@@ -1073,10 +1073,10 @@ jobs:
     # to avoid glibc incompatibilities.
     # See: https://github.com/ethereum/solidity/issues/13954
     # On large runs 2x faster than on medium. 3x on xlarge.
-    <<: *base_ubuntu2004_xlarge
+    <<: *base_ubuntu2404_xlarge
     environment:
-      <<: *base_ubuntu2004_xlarge_env
-      CMAKE_OPTIONS: -DCMAKE_BUILD_TYPE=Release -DSOLC_STATIC_STDLIBS=ON
+      <<: *base_ubuntu2404_xlarge_env
+      CMAKE_OPTIONS: -DCMAKE_BUILD_TYPE=Release -DSOLC_LINK_STATIC=ON
     steps:
       - checkout
       - run_build
@@ -1093,21 +1093,6 @@ jobs:
             - solc/solc-static-linux
       - matrix_notify_failure_unless_pr
 
-  # Builds in C++20 mode and uses debug build in order to speed up.
-  # Do *NOT* store any artifacts or workspace as we don't run tests on this build.
-  b_ubu_cxx20:
-    <<: *base_ubuntu2404_large
-    environment:
-      <<: *base_ubuntu2404_large_env
-      CMAKE_BUILD_TYPE: Debug
-      # gold is more memory-efficient than the default, allows us to stay with the "large" resource class without OOM errors
-      CMAKE_OPTIONS: -DCMAKE_CXX_STANDARD=20 -DCMAKE_CXX_FLAGS=-fuse-ld=gold
-      MAKEFLAGS: -j 6
-    steps:
-      - checkout
-      - run_build
-      - matrix_notify_failure_unless_pr
-
   b_ubu_2204:
     <<: *base_ubuntu2204_large
     steps:
@@ -1873,7 +1858,6 @@ workflows:
 
       # build-only
       - b_docs: *requires_nothing
-      - b_ubu_cxx20: *requires_nothing
       - b_ubu_ossfuzz: *requires_nothing
       - b_ubu_2204: *requires_nothing
       - b_ubu_2204_clang: *requires_nothing
diff --git a/.github/workflows/buildpack-deps.yml b/.github/workflows/buildpack-deps.yml
@@ -6,7 +6,6 @@ on:
     paths:
       - 'scripts/docker/buildpack-deps/Dockerfile.emscripten'
       - 'scripts/docker/buildpack-deps/Dockerfile.ubuntu.clang.ossfuzz'
-      - 'scripts/docker/buildpack-deps/Dockerfile.ubuntu2004'
       - 'scripts/docker/buildpack-deps/Dockerfile.ubuntu2204'
       - 'scripts/docker/buildpack-deps/Dockerfile.ubuntu2404'
       - 'scripts/docker/buildpack-deps/Dockerfile.ubuntu2404.clang'
diff --git a/Changelog.md b/Changelog.md
@@ -19,6 +19,10 @@ Bugfixes:
  * Yul: Fix internal compiler error when a code generation error should be reported instead.
 
 
+Build system:
+ * Linux release builds are fully static again and no longer depend on ``glibc``.
+ * Switch from C++17 to C++20 as the target standard.
+
 ### 0.8.28 (2024-10-09)
 
 Language Features:
diff --git a/ReleaseChecklist.md b/ReleaseChecklist.md
@@ -94,7 +94,8 @@ At least a day before the release:
        **SERIOUSLY: DO NOT PROCEED EARLIER!!!**
  - [ ] *After* the package with the static build is *published*, use it to create packages for older Ubuntu versions.
        Copy the static package to the [``~ethereum/ethereum`` PPA](https://launchpad.net/~ethereum/+archive/ubuntu/ethereum)
-       for the destination series ``Trusty``, ``Xenial`` and ``Bionic`` while selecting ``Copy existing binaries``.
+       for the destination series ``Trusty``, ``Xenial``, ``Bionic``, and ``Focal``
+       while selecting ``Copy existing binaries``.
 
 ### Release solc-js
  - [ ] Wait until solc-bin was properly deployed. You can test this via remix - a test run through remix is advisable anyway.
diff --git a/cmake/EthCompilerSettings.cmake b/cmake/EthCompilerSettings.cmake
@@ -89,21 +89,29 @@ if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MA
 
 	# Additional GCC-specific compiler settings.
 	if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-		# Check that we've got GCC 8.0 or newer.
-		if (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0))
-			message(FATAL_ERROR "${PROJECT_NAME} requires g++ 8.0 or greater.")
+		# Check that we've got GCC 11.0 or newer.
+		if (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0))
+			message(FATAL_ERROR "${PROJECT_NAME} requires g++ 11.0 or greater.")
+		endif ()
+
+		# GCC 12 emits warnings for string concatenations with operator+ under O3
+		# See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105651
+		if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.0)
+			add_compile_options(-Wno-error=restrict)
 		endif ()
 
 		# Use fancy colors in the compiler diagnostics
 		add_compile_options(-fdiagnostics-color)
 
 	# Additional Clang-specific compiler settings.
 	elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-		# Check that we've got clang 7.0 or newer.
-		if (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 7.0))
-			message(FATAL_ERROR "${PROJECT_NAME} requires clang++ 7.0 or greater.")
+		# Check that we've got clang 14.0 or newer.
+		if (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14.0))
+			message(FATAL_ERROR "${PROJECT_NAME} requires clang++ 14.0 or greater.")
 		endif ()
 
+		# use std::invoke_result, superseding std::result_of which has been removed in c++20
+		add_compile_definitions(BOOST_ASIO_HAS_STD_INVOKE_RESULT)
 		if ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
 			# Set stack size to 32MB - by default Apple's clang defines a stack size of 8MB.
 			# Normally 16MB is enough to run all tests, but it will exceed the stack, if -DSANITIZE=address is used.
diff --git a/cmake/EthToolchains.cmake b/cmake/EthToolchains.cmake
@@ -1,6 +1,6 @@
-# Require C++17.
+# Require C++20.
 if (NOT DEFINED CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17) # This requires at least CMake 3.8 to accept this C++17 flag.
+  set(CMAKE_CXX_STANDARD 20) # This requires at least CMake 3.12 to accept this C++20 flag.
 endif ()
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_CXX_EXTENSIONS OFF)
diff --git a/docs/installing-solidity.rst b/docs/installing-solidity.rst
@@ -372,8 +372,8 @@ Minimum Compiler Versions
 
 The following C++ compilers and their minimum versions can build the Solidity codebase:
 
-- `GCC <https://gcc.gnu.org>`_, version 8+
-- `Clang <https://clang.llvm.org/>`_, version 7+
+- `GCC <https://gcc.gnu.org>`_, version 11+
+- `Clang <https://clang.llvm.org/>`_, version 14+
 - `MSVC <https://visualstudio.microsoft.com/vs/>`_, version 2019+
 
 Prerequisites - macOS
diff --git a/libevmasm/ConstantOptimiser.cpp b/libevmasm/ConstantOptimiser.cpp
@@ -140,6 +140,11 @@ bigint LiteralMethod::gasNeeded() const
 	);
 }
 
+AssemblyItems LiteralMethod::execute(Assembly&) const
+{
+	return {};
+}
+
 bigint CodeCopyMethod::gasNeeded() const
 {
 	return combineGas(
@@ -226,6 +231,23 @@ AssemblyItems CodeCopyMethod::copyRoutine(AssemblyItem* _pushData) const
 	}
 }
 
+ComputeMethod::ComputeMethod(Params const& _params, u256 const& _value):
+	ConstantOptimisationMethod(_params, _value)
+{
+	m_routine = findRepresentation(m_value);
+	assertThrow(
+		checkRepresentation(m_value, m_routine),
+		OptimizerException,
+		"Invalid constant expression created."
+	);
+}
+ComputeMethod::~ComputeMethod() = default;
+
+AssemblyItems ComputeMethod::execute(Assembly&) const
+{
+	return m_routine;
+}
+
 AssemblyItems ComputeMethod::findRepresentation(u256 const& _value)
 {
 	if (_value < 0x10000)
diff --git a/libevmasm/ConstantOptimiser.h b/libevmasm/ConstantOptimiser.h
@@ -108,7 +108,7 @@ class LiteralMethod: public ConstantOptimisationMethod
 	explicit LiteralMethod(Params const& _params, u256 const& _value):
 		ConstantOptimisationMethod(_params, _value) {}
 	bigint gasNeeded() const override;
-	AssemblyItems execute(Assembly&) const override { return AssemblyItems{}; }
+	AssemblyItems execute(Assembly&) const override;
 };
 
 /**
@@ -132,22 +132,11 @@ class CodeCopyMethod: public ConstantOptimisationMethod
 class ComputeMethod: public ConstantOptimisationMethod
 {
 public:
-	explicit ComputeMethod(Params const& _params, u256 const& _value):
-		ConstantOptimisationMethod(_params, _value)
-	{
-		m_routine = findRepresentation(m_value);
-		assertThrow(
-			checkRepresentation(m_value, m_routine),
-			OptimizerException,
-			"Invalid constant expression created."
-		);
-	}
+	ComputeMethod(Params const& _params, u256 const& _value);
+	~ComputeMethod() override;
 
 	bigint gasNeeded() const override { return gasNeeded(m_routine); }
-	AssemblyItems execute(Assembly&) const override
-	{
-		return m_routine;
-	}
+	AssemblyItems execute(Assembly&) const override;
 
 protected:
 	/// Tries to recursively find a way to compute @a _value.
diff --git a/libevmasm/PeepholeOptimiser.cpp b/libevmasm/PeepholeOptimiser.cpp
@@ -709,6 +709,12 @@ size_t numberOfPops(AssemblyItems const& _items)
 
 }
 
+PeepholeOptimiser::PeepholeOptimiser(AssemblyItems& _items, langutil::EVMVersion const _evmVersion):
+	m_items(_items),
+	m_evmVersion(_evmVersion)
+{
+}
+
 bool PeepholeOptimiser::optimise()
 {
 	// Avoid referencing immutables too early by using approx. counting in bytesRequired()
diff --git a/libevmasm/PeepholeOptimiser.h b/libevmasm/PeepholeOptimiser.h
@@ -43,11 +43,7 @@ class PeepholeOptimisationMethod
 class PeepholeOptimiser
 {
 public:
-	explicit PeepholeOptimiser(AssemblyItems& _items, langutil::EVMVersion const _evmVersion):
-	m_items(_items),
-	m_evmVersion(_evmVersion)
-	{
-	}
+	explicit PeepholeOptimiser(AssemblyItems& _items, langutil::EVMVersion _evmVersion);
 	virtual ~PeepholeOptimiser() = default;
 
 	bool optimise();
diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
@@ -661,8 +661,12 @@ bool IntegerType::operator==(Type const& _other) const
 {
 	if (_other.category() != category())
 		return false;
-	IntegerType const& other = dynamic_cast<IntegerType const&>(_other);
-	return other.m_bits == m_bits && other.m_modifier == m_modifier;
+	return *this == dynamic_cast<IntegerType const&>(_other);
+}
+
+bool IntegerType::operator==(IntegerType const& _other) const
+{
+	return _other.m_bits == m_bits && _other.m_modifier == m_modifier;
 }
 
 std::string IntegerType::toString(bool) const
@@ -1699,17 +1703,21 @@ bool ArrayType::operator==(Type const& _other) const
 {
 	if (_other.category() != category())
 		return false;
-	ArrayType const& other = dynamic_cast<ArrayType const&>(_other);
+	return *this == dynamic_cast<ArrayType const&>(_other);
+}
+
+bool ArrayType::operator==(ArrayType const& _other) const
+{
 	if (
-		!equals(other) ||
-		other.isByteArray() != isByteArray() ||
-		other.isString() != isString() ||
-		other.isDynamicallySized() != isDynamicallySized()
+		!equals(_other) ||
+		_other.isByteArray() != isByteArray() ||
+		_other.isString() != isString() ||
+		_other.isDynamicallySized() != isDynamicallySized()
 	)
 		return false;
-	if (*other.baseType() != *baseType())
+	if (*_other.baseType() != *baseType())
 		return false;
-	return isDynamicallySized() || length() == other.length();
+	return isDynamicallySized() || length() == _other.length();
 }
 
 BoolResult ArrayType::validForLocation(DataLocation _loc) const
@@ -2704,7 +2712,12 @@ bool UserDefinedValueType::operator==(Type const& _other) const
 	if (_other.category() != category())
 		return false;
 	UserDefinedValueType const& other = dynamic_cast<UserDefinedValueType const&>(_other);
-	return other.definition() == definition();
+	return *this == other;
+}
+
+bool UserDefinedValueType::operator==(UserDefinedValueType const& _other) const
+{
+	return _other.definition() == definition();
 }
 
 std::string UserDefinedValueType::toString(bool /* _withoutDataLocation */) const
@@ -4058,6 +4071,11 @@ bool ModifierType::operator==(Type const& _other) const
 {
 	if (_other.category() != category())
 		return false;
+	return *this == dynamic_cast<ModifierType const&>(_other);
+}
+
+bool ModifierType::operator==(ModifierType const& _other) const
+{
 	ModifierType const& other = dynamic_cast<ModifierType const&>(_other);
 
 	if (m_parameterTypes.size() != other.m_parameterTypes.size())
diff --git a/libsolidity/ast/Types.h b/libsolidity/ast/Types.h
@@ -495,6 +495,7 @@ class IntegerType: public Type
 	TypeResult unaryOperatorResult(Token _operator) const override;
 	TypeResult binaryOperatorResult(Token _operator, Type const* _other) const override;
 
+	bool operator==(IntegerType const& _other) const;
 	bool operator==(Type const& _other) const override;
 
 	unsigned calldataEncodedSize(bool _padded = true) const override { return _padded ? 32 : m_bits / 8; }
@@ -854,6 +855,7 @@ class ArrayType: public ReferenceType
 	BoolResult isImplicitlyConvertibleTo(Type const& _convertTo) const override;
 	BoolResult isExplicitlyConvertibleTo(Type const& _convertTo) const override;
 	std::string richIdentifier() const override;
+	bool operator==(ArrayType const& _other) const;
 	bool operator==(Type const& _other) const override;
 	unsigned calldataEncodedSize(bool) const override;
 	unsigned calldataEncodedTailSize() const override;
@@ -1148,6 +1150,7 @@ class UserDefinedValueType: public Type
 	Declaration const* typeDefinition() const override;
 
 	std::string richIdentifier() const override;
+	bool operator==(UserDefinedValueType const& _other) const;
 	bool operator==(Type const& _other) const override;
 
 	unsigned calldataEncodedSize(bool _padded) const override { return underlyingType().calldataEncodedSize(_padded); }
@@ -1625,6 +1628,7 @@ class ModifierType: public Type
 	bool hasSimpleZeroValueInMemory() const override { solAssert(false, ""); }
 	std::string richIdentifier() const override;
 	bool operator==(Type const& _other) const override;
+	bool operator==(ModifierType const& _other) const;
 	std::string toString(bool _withoutDataLocation) const override;
 protected:
 	std::vector<std::tuple<std::string, Type const*>> makeStackItems() const override { return {}; }
diff --git a/libsolidity/experimental/ast/TypeSystem.cpp b/libsolidity/experimental/ast/TypeSystem.cpp
@@ -24,7 +24,8 @@
 
 #include <libsolutil/Visitor.h>
 
-#include <range/v3/to_container.hpp>
+#include <range/v3/range/conversion.hpp>
+
 #include <range/v3/view/drop_exactly.hpp>
 #include <range/v3/view/drop_last.hpp>
 #include <range/v3/view/reverse.hpp>
diff --git a/libsolidity/experimental/ast/TypeSystemHelper.cpp b/libsolidity/experimental/ast/TypeSystemHelper.cpp
@@ -26,7 +26,7 @@
 #include <libsolutil/Visitor.h>
 
 #include <range/v3/algorithm/any_of.hpp>
-#include <range/v3/to_container.hpp>
+#include <range/v3/range/conversion.hpp>
 #include <range/v3/view/drop_exactly.hpp>
 #include <range/v3/view/drop_last.hpp>
 #include <range/v3/view/reverse.hpp>
diff --git a/libsolidity/interface/GasEstimator.cpp b/libsolidity/interface/GasEstimator.cpp
@@ -109,7 +109,7 @@ std::set<ASTNode const*> GasEstimator::finestNodesAtLocation(
 {
 	std::map<SourceLocation, ASTNode const*> locations;
 	std::set<ASTNode const*> nodes;
-	SimpleASTVisitor visitor(std::function<bool(ASTNode const&)>(), [&](ASTNode const& _n)
+	SimpleASTVisitor visitor([](ASTNode const&) { return false; }, [&](ASTNode const& _n)
 	{
 		if (!locations.count(_n.location()))
 		{
diff --git a/libyul/optimiser/ExpressionSplitter.cpp b/libyul/optimiser/ExpressionSplitter.cpp
@@ -35,6 +35,13 @@ using namespace solidity::yul;
 using namespace solidity::util;
 using namespace solidity::langutil;
 
+ExpressionSplitter::ExpressionSplitter(Dialect const& _dialect, NameDispenser& _nameDispenser):
+	m_dialect(_dialect),
+	m_nameDispenser(_nameDispenser)
+{}
+
+ExpressionSplitter::~ExpressionSplitter() = default;
+
 void ExpressionSplitter::run(OptimiserStepContext& _context, Block& _ast)
 {
 	ExpressionSplitter{_context.dialect, _context.dispenser}(_ast);
diff --git a/libyul/optimiser/ExpressionSplitter.h b/libyul/optimiser/ExpressionSplitter.h
@@ -68,13 +68,11 @@ class ExpressionSplitter: public ASTModifier
 	void operator()(Block& _block) override;
 
 private:
-	explicit ExpressionSplitter(
+	ExpressionSplitter(
 		Dialect const& _dialect,
 		NameDispenser& _nameDispenser
-	):
-		m_dialect(_dialect),
-		m_nameDispenser(_nameDispenser)
-	{ }
+	);
+	~ExpressionSplitter() override;
 
 	/// Replaces the expression by a variable if it is a function call or functional
 	/// instruction. The declaration of the variable is appended to m_statementsToPrefix.
diff --git a/libyul/optimiser/FunctionHoister.cpp b/libyul/optimiser/FunctionHoister.cpp
@@ -30,6 +30,9 @@
 using namespace solidity;
 using namespace solidity::yul;
 
+FunctionHoister::FunctionHoister() = default;
+FunctionHoister::~FunctionHoister() = default;
+
 void FunctionHoister::operator()(Block& _block)
 {
 	bool topLevel = m_isTopLevel;
diff --git a/libyul/optimiser/FunctionHoister.h b/libyul/optimiser/FunctionHoister.h
diff --git a/scripts/deps-ppa/static_z3.sh b/scripts/deps-ppa/static_z3.sh
diff --git a/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004 b/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004
diff --git a/scripts/release_ppa.sh b/scripts/release_ppa.sh
diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp
diff --git a/solc/CommandLineParser.cpp b/solc/CommandLineParser.cpp
diff --git a/test/EVMHost.cpp b/test/EVMHost.cpp
diff --git a/test/tools/ossfuzz/CMakeLists.txt b/test/tools/ossfuzz/CMakeLists.txt
diff --git a/test/tools/ossfuzz/StackReuseCodegenFuzzer.cpp b/test/tools/ossfuzz/StackReuseCodegenFuzzer.cpp

Original file line number	Diff line number	Diff line change
`@@ -709,6 +709,12 @@ size_t numberOfPops(AssemblyItems const& _items)`
`709`	`709`
`710`	`710`	`}`
`711`	`711`
	`712`	`+PeepholeOptimiser::PeepholeOptimiser(AssemblyItems& _items, langutil::EVMVersion const _evmVersion):`
	`713`	`+ m_items(_items),`
	`714`	`+ m_evmVersion(_evmVersion)`
	`715`	`+{`
	`716`	`+}`
	`717`	`+`
`712`	`718`	`bool PeepholeOptimiser::optimise()`
`713`	`719`	`{`
`714`	`720`	`// Avoid referencing immutables too early by using approx. counting in bytesRequired()`