Merge pull request #13571 from ethereum/explicit-fixedhash

axic · web-flow · commit 5f8b48793cdf · 2022-09-27T22:30:34.000+02:00
Drop implicit alignment argument from FixedHash (and improve FunctionSelector helpers)
diff --git a/libsolidity/analysis/PostTypeChecker.cpp b/libsolidity/analysis/PostTypeChecker.cpp
@@ -411,7 +411,7 @@ struct ReservedErrorSelector: public PostTypeChecker::Checker
 			);
 		else
 		{
-			uint32_t selector = util::selectorFromSignature32(_error.functionType(true)->externalSignature());
+			uint32_t selector = util::selectorFromSignatureU32(_error.functionType(true)->externalSignature());
 			if (selector == 0 || ~selector == 0)
 				m_errorReporter.syntaxError(
 					2855_error,
diff --git a/libsolidity/analysis/PostTypeContractLevelChecker.cpp b/libsolidity/analysis/PostTypeContractLevelChecker.cpp
@@ -52,7 +52,7 @@ bool PostTypeContractLevelChecker::check(ContractDefinition const& _contract)
 	for (ErrorDefinition const* error: _contract.interfaceErrors())
 	{
 		string signature = error->functionType(true)->externalSignature();
-		uint32_t hash = util::selectorFromSignature32(signature);
+		uint32_t hash = util::selectorFromSignatureU32(signature);
 		// Fail if there is a different signature for the same hash.
 		if (!errorHashes[hash].empty() && !errorHashes[hash].count(signature))
 		{
diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
@@ -27,6 +27,7 @@
 #include <libsolidity/ast/ASTVisitor.h>
 #include <libsolidity/ast/AST_accept.h>
 #include <libsolidity/ast/TypeProvider.h>
+#include <libsolutil/FunctionSelector.h>
 #include <libsolutil/Keccak256.h>
 
 #include <range/v3/view/tail.hpp>
@@ -281,8 +282,7 @@ vector<pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition:
 				if (signaturesSeen.count(functionSignature) == 0)
 				{
 					signaturesSeen.insert(functionSignature);
-					util::FixedHash<4> hash(util::keccak256(functionSignature));
-					interfaceFunctionList.emplace_back(hash, fun);
+					interfaceFunctionList.emplace_back(util::selectorFromSignatureH32(functionSignature), fun);
 				}
 			}
 		}
diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
@@ -3583,12 +3583,12 @@ string FunctionType::externalSignature() const
 
 u256 FunctionType::externalIdentifier() const
 {
-	return util::selectorFromSignature32(externalSignature());
+	return util::selectorFromSignatureU32(externalSignature());
 }
 
 string FunctionType::externalIdentifierHex() const
 {
-	return util::FixedHash<4>(util::keccak256(externalSignature())).hex();
+	return util::selectorFromSignatureH32(externalSignature()).hex();
 }
 
 bool FunctionType::isPure() const
diff --git a/libsolidity/codegen/ArrayUtils.cpp b/libsolidity/codegen/ArrayUtils.cpp
@@ -889,7 +889,7 @@ void ArrayUtils::popStorageArrayElement(ArrayType const& _type) const
 			}
 			sstore(ref, slot_value)
 		})");
-		code("panicSelector", util::selectorFromSignature("Panic(uint256)").str());
+		code("panicSelector", util::selectorFromSignatureU256("Panic(uint256)").str());
 		code("emptyArrayPop", to_string(unsigned(util::PanicCode::EmptyArrayPop)));
 		m_context.appendInlineAssembly(code.render(), {"ref", "slot_value", "length"});
 		m_context << Instruction::POP << Instruction::POP << Instruction::POP;
diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
@@ -95,7 +95,7 @@ void CompilerUtils::revertWithStringData(Type const& _argumentType)
 {
 	solAssert(_argumentType.isImplicitlyConvertibleTo(*TypeProvider::fromElementaryTypeName("string memory")));
 	fetchFreeMemoryPointer();
-	m_context << util::selectorFromSignature("Error(string)");
+	m_context << util::selectorFromSignatureU256("Error(string)");
 	m_context << Instruction::DUP2 << Instruction::MSTORE;
 	m_context << u256(4) << Instruction::ADD;
 	// Stack: <string data> <mem pos of encoding start>
@@ -111,7 +111,7 @@ void CompilerUtils::revertWithError(
 )
 {
 	fetchFreeMemoryPointer();
-	m_context << util::selectorFromSignature(_signature);
+	m_context << util::selectorFromSignatureU256(_signature);
 	m_context << Instruction::DUP2 << Instruction::MSTORE;
 	m_context << u256(4) << Instruction::ADD;
 	// Stack: <arguments...> <mem pos of encoding start>
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
@@ -253,7 +253,7 @@ size_t ContractCompiler::deployLibrary(ContractDefinition const& _contract)
 			return(codepos, subSize)
 		}
 		)")
-		("panicSelector", util::selectorFromSignature("Panic(uint256)").str())
+		("panicSelector", util::selectorFromSignatureU256("Panic(uint256)").str())
 		("panicCode", "0")
 		.render(),
 		{"subSize", "subOffset"}
@@ -1046,7 +1046,7 @@ void ContractCompiler::handleCatch(vector<ASTPointer<TryCatchClause>> const& _ca
 		solAssert(m_context.evmVersion().supportsReturndata(), "");
 
 		// stack: <selector>
-		m_context << Instruction::DUP1 << util::selectorFromSignature32("Error(string)") << Instruction::EQ;
+		m_context << Instruction::DUP1 << util::selectorFromSignatureU32("Error(string)") << Instruction::EQ;
 		m_context << Instruction::ISZERO;
 		m_context.appendConditionalJumpTo(panicTag);
 		m_context << Instruction::POP; // remove selector
@@ -1078,7 +1078,7 @@ void ContractCompiler::handleCatch(vector<ASTPointer<TryCatchClause>> const& _ca
 		solAssert(m_context.evmVersion().supportsReturndata(), "");
 
 		// stack: <selector>
-		m_context << util::selectorFromSignature32("Panic(uint256)") << Instruction::EQ;
+		m_context << util::selectorFromSignatureU32("Panic(uint256)") << Instruction::EQ;
 		m_context << Instruction::ISZERO;
 		m_context.appendConditionalJumpTo(fallbackTag);
 
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -1329,7 +1329,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 					// hash the signature
 					if (auto const* stringType = dynamic_cast<StringLiteralType const*>(selectorType))
 					{
-						m_context << util::selectorFromSignature(stringType->value());
+						m_context << util::selectorFromSignatureU256(stringType->value());
 						dataOnStack = TypeProvider::fixedBytes(4);
 					}
 					else
diff --git a/libsolidity/codegen/YulUtilFunctions.cpp b/libsolidity/codegen/YulUtilFunctions.cpp
@@ -233,7 +233,7 @@ string YulUtilFunctions::requireOrAssertFunction(bool _assert, Type const* _mess
 			.render();
 
 		int const hashHeaderSize = 4;
-		u256 const errorHash = util::selectorFromSignature("Error(string)");
+		u256 const errorHash = util::selectorFromSignatureU256("Error(string)");
 
 		string const encodeFunc = ABIFunctions(m_evmVersion, m_revertStrings, m_functionCollector)
 			.tupleEncoder(
@@ -4426,7 +4426,7 @@ string YulUtilFunctions::revertReasonIfDebugBody(
 		revert(start, <overallLength>)
 	)");
 	templ("allocate", _allocation);
-	templ("sig", util::selectorFromSignature("Error(string)").str());
+	templ("sig", util::selectorFromSignatureU256("Error(string)").str());
 	templ("length", to_string(_message.length()));
 
 	size_t words = (_message.length() + 31) / 32;
@@ -4454,7 +4454,7 @@ string YulUtilFunctions::panicFunction(util::PanicCode _code)
 			}
 		)")
 		("functionName", functionName)
-		("selector", util::selectorFromSignature("Panic(uint256)").str())
+		("selector", util::selectorFromSignatureU256("Panic(uint256)").str())
 		("code", toCompactHexWithPrefix(static_cast<unsigned>(_code)))
 		.render();
 	});
diff --git a/libsolidity/codegen/ir/IRGeneratorForStatements.cpp b/libsolidity/codegen/ir/IRGeneratorForStatements.cpp
@@ -1196,7 +1196,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 			// hash the signature
 			Type const& selectorType = type(*arguments.front());
 			if (auto const* stringType = dynamic_cast<StringLiteralType const*>(&selectorType))
-				selector = formatNumber(util::selectorFromSignature(stringType->value()));
+				selector = formatNumber(util::selectorFromSignatureU256(stringType->value()));
 			else
 			{
 				// Used to reset the free memory pointer later.
@@ -1785,7 +1785,7 @@ void IRGeneratorForStatements::endVisit(MemberAccess const& _memberAccess)
 					""
 				);
 				define(IRVariable{_memberAccess}) << formatNumber(
-					util::selectorFromSignature(functionType.externalSignature())
+					util::selectorFromSignatureU256(functionType.externalSignature())
 				) << "\n";
 			}
 			else if (functionType.kind() == FunctionType::Kind::Event)
@@ -3234,7 +3234,7 @@ void IRGeneratorForStatements::handleCatch(TryStatement const& _tryStatement)
 
 	if (TryCatchClause const* errorClause = _tryStatement.errorClause())
 	{
-		appendCode() << "case " << selectorFromSignature32("Error(string)") << " {\n";
+		appendCode() << "case " << selectorFromSignatureU32("Error(string)") << " {\n";
 		setLocation(*errorClause);
 		string const dataVariable = m_context.newYulVariable();
 		appendCode() << "let " << dataVariable << " := " << m_utils.tryDecodeErrorMessageFunction() << "()\n";
@@ -3254,7 +3254,7 @@ void IRGeneratorForStatements::handleCatch(TryStatement const& _tryStatement)
 	}
 	if (TryCatchClause const* panicClause = _tryStatement.panicClause())
 	{
-		appendCode() << "case " << selectorFromSignature32("Panic(uint256)") << " {\n";
+		appendCode() << "case " << selectorFromSignatureU32("Panic(uint256)") << " {\n";
 		setLocation(*panicClause);
 		string const success = m_context.newYulVariable();
 		string const code = m_context.newYulVariable();
@@ -3317,7 +3317,7 @@ void IRGeneratorForStatements::revertWithError(
 	})");
 	templ("pos", m_context.newYulVariable());
 	templ("end", m_context.newYulVariable());
-	templ("hash", util::selectorFromSignature(_signature).str());
+	templ("hash", util::selectorFromSignatureU256(_signature).str());
 	templ("allocateUnbounded", m_utils.allocateUnboundedFunction());
 
 	vector<string> errorArgumentVars;
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
@@ -1034,7 +1034,7 @@ Json::Value CompilerStack::interfaceSymbols(string const& _contractName) const
 	for (ErrorDefinition const* error: contractDefinition(_contractName).interfaceErrors())
 	{
 		string signature = error->functionType(true)->externalSignature();
-		interfaceSymbols["errors"][signature] = util::toHex(toCompactBigEndian(util::selectorFromSignature32(signature), 4));
+		interfaceSymbols["errors"][signature] = util::toHex(toCompactBigEndian(util::selectorFromSignatureU32(signature), 4));
 	}
 
 	for (EventDefinition const* event: ranges::concat_view(
diff --git a/libsolidity/interface/GasEstimator.cpp b/libsolidity/interface/GasEstimator.cpp
@@ -30,6 +30,7 @@
 #include <libevmasm/ControlFlowGraph.h>
 #include <libevmasm/KnownState.h>
 #include <libevmasm/PathGasMeter.h>
+#include <libsolutil/FunctionSelector.h>
 #include <libsolutil/Keccak256.h>
 
 #include <functional>
@@ -54,7 +55,7 @@ GasEstimator::GasConsumption GasEstimator::functionalEstimation(
 		ExpressionClasses& classes = state->expressionClasses();
 		using Id = ExpressionClasses::Id;
 		using Ids = vector<Id>;
-		Id hashValue = classes.find(u256(util::FixedHash<4>::Arith(util::FixedHash<4>(util::keccak256(_signature)))));
+		Id hashValue = classes.find(u256(util::selectorFromSignatureU32(_signature)));
 		Id calldata = classes.find(Instruction::CALLDATALOAD, Ids{classes.find(u256(0))});
 		if (!m_evmVersion.hasBitwiseShifting())
 			// div(calldataload(0), 1 << 224) equals to hashValue
diff --git a/libsolutil/FixedHash.h b/libsolutil/FixedHash.h
@@ -61,7 +61,7 @@ class FixedHash
 	explicit FixedHash() { m_data.fill(0); }
 
 	/// Construct from another hash, filling with zeroes or cropping as necessary.
-	template <unsigned M> explicit FixedHash(FixedHash<M> const& _h, ConstructFromHashType _t = AlignLeft)
+	template <unsigned M> explicit FixedHash(FixedHash<M> const& _h, ConstructFromHashType _t)
 	{
 		m_data.fill(0);
 		unsigned c = std::min(M, N);
diff --git a/libsolutil/FunctionSelector.h b/libsolutil/FunctionSelector.h
@@ -26,17 +26,22 @@
 namespace solidity::util
 {
 
+/// @returns the ABI selector for a given function signature, as a FixedHash h32.
+inline FixedHash<4> selectorFromSignatureH32(std::string const& _signature)
+{
+	return FixedHash<4>(util::keccak256(_signature), FixedHash<4>::AlignLeft);
+}
+
 /// @returns the ABI selector for a given function signature, as a 32 bit number.
-inline uint32_t selectorFromSignature32(std::string const& _signature)
+inline uint32_t selectorFromSignatureU32(std::string const& _signature)
 {
-	return uint32_t(FixedHash<4>::Arith(util::FixedHash<4>(util::keccak256(_signature))));
+	return uint32_t(FixedHash<4>::Arith(selectorFromSignatureH32(_signature)));
 }
 
 /// @returns the ABI selector for a given function signature, as a u256 (left aligned) number.
-inline u256 selectorFromSignature(std::string const& _signature)
+inline u256 selectorFromSignatureU256(std::string const& _signature)
 {
-	return u256(selectorFromSignature32(_signature)) << (256 - 32);
+	return u256(selectorFromSignatureU32(_signature)) << (256 - 32);
 }
 
-
 }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -35,6 +35,7 @@ set(libsolutil_sources
     libsolutil/CommonData.cpp
     libsolutil/CommonIO.cpp
     libsolutil/FixedHash.cpp
+    libsolutil/FunctionSelector.cpp
     libsolutil/IndentedWriter.cpp
     libsolutil/IpfsHash.cpp
     libsolutil/IterateReplacing.cpp
diff --git a/test/EVMHost.cpp b/test/EVMHost.cpp
@@ -255,7 +255,7 @@ evmc::result EVMHost::call(evmc_message const& _message) noexcept
 		h160 createAddress(keccak256(
 			bytes(begin(message.sender.bytes), end(message.sender.bytes)) +
 			asBytes(to_string(sender.nonce++))
-		));
+		), h160::AlignLeft);
 		message.destination = convertToEVMC(createAddress);
 		code = evmc::bytes(message.input_data, message.input_data + message.input_size);
 	}
@@ -266,7 +266,7 @@ evmc::result EVMHost::call(evmc_message const& _message) noexcept
 			bytes(begin(message.sender.bytes), end(message.sender.bytes)) +
 			bytes(begin(message.create2_salt.bytes), end(message.create2_salt.bytes)) +
 			keccak256(bytes(message.input_data, message.input_data + message.input_size)).asBytes()
-		));
+		), h160::AlignLeft);
 		message.destination = convertToEVMC(createAddress);
 		if (accounts.count(message.destination) && (
 			accounts[message.destination].nonce > 0 ||
diff --git a/test/ExecutionFramework.cpp b/test/ExecutionFramework.cpp
@@ -30,7 +30,6 @@
 #include <test/libsolidity/util/SoltestTypes.h>
 
 #include <libsolutil/CommonIO.h>
-#include <libsolutil/FunctionSelector.h>
 
 #include <liblangutil/Exceptions.h>
 
@@ -123,7 +122,7 @@ bytes ExecutionFramework::panicData(util::PanicCode _code)
 {
 	return
 		m_evmVersion.supportsReturndata() ?
-		toCompactBigEndian(selectorFromSignature32("Panic(uint256)"), 4) + encode(u256(static_cast<unsigned>(_code))) :
+		toCompactBigEndian(selectorFromSignatureU32("Panic(uint256)"), 4) + encode(u256(static_cast<unsigned>(_code))) :
 		bytes();
 }
 
diff --git a/test/ExecutionFramework.h b/test/ExecutionFramework.h
@@ -31,8 +31,7 @@
 
 #include <liblangutil/EVMVersion.h>
 
-#include <libsolutil/FixedHash.h>
-#include <libsolutil/Keccak256.h>
+#include <libsolutil/FunctionSelector.h>
 #include <libsolutil/ErrorCodes.h>
 
 #include <functional>
@@ -108,8 +107,7 @@ class ExecutionFramework
 
 	bytes const& callContractFunctionWithValueNoEncoding(std::string _sig, u256 const& _value, bytes const& _arguments)
 	{
-		util::FixedHash<4> hash(util::keccak256(_sig));
-		sendMessage(hash.asBytes() + _arguments, false, _value);
+		sendMessage(util::selectorFromSignatureH32(_sig).asBytes() + _arguments, false, _value);
 		return m_output;
 	}
 
diff --git a/test/contracts/Wallet.cpp b/test/contracts/Wallet.cpp
@@ -591,7 +591,7 @@ BOOST_AUTO_TEST_CASE(revoke_addOwner)
 	BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs());
 	// add a new owner
 	h160 deployer = m_sender;
-	h256 opHash = util::keccak256(FixedHash<4>(util::keccak256("addOwner(address)")).asBytes() + h256(0x33).asBytes());
+	h256 opHash = util::keccak256(util::selectorFromSignatureH32("addOwner(address)").asBytes() + h256(0x33).asBytes());
 	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x33)) == encodeArgs());
 	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x33)) == encodeArgs(false));
 	m_sender = account(0);
diff --git a/test/libsolidity/ABIEncoderTests.cpp b/test/libsolidity/ABIEncoderTests.cpp
@@ -342,7 +342,7 @@ BOOST_AUTO_TEST_CASE(external_function)
 	BOTH_ENCODERS(
 		compileAndRun(sourceCode);
 		callContractFunction("f(uint256)", u256(0));
-		string functionIdF = asString(m_contractAddress.ref()) + asString(FixedHash<4>(keccak256("f(uint256)")).ref());
+		string functionIdF = asString(m_contractAddress.ref()) + asString(util::selectorFromSignatureH32("f(uint256)").ref());
 		REQUIRE_LOG_DATA(encodeArgs(functionIdF, functionIdF));
 	)
 }
diff --git a/test/libsolidity/AnalysisFramework.cpp b/test/libsolidity/AnalysisFramework.cpp
@@ -30,7 +30,7 @@
 
 #include <liblangutil/Scanner.h>
 
-#include <libsolutil/Keccak256.h>
+#include <libsolutil/FunctionSelector.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -170,6 +170,5 @@ FunctionTypePointer AnalysisFramework::retrieveFunctionBySignature(
 	std::string const& _signature
 )
 {
-	FixedHash<4> hash(util::keccak256(_signature));
-	return _contract.interfaceFunctions()[hash];
+	return _contract.interfaceFunctions()[util::selectorFromSignatureH32(_signature)];
 }
diff --git a/test/libsolidity/GasMeter.cpp b/test/libsolidity/GasMeter.cpp
@@ -78,7 +78,7 @@ class GasMeterTestFramework: public SolidityExecutionFramework
 	{
 		u256 gasUsed = 0;
 		GasMeter::GasConsumption gas;
-		util::FixedHash<4> hash(util::keccak256(_sig));
+		util::FixedHash<4> hash = util::selectorFromSignatureH32(_sig);
 		for (bytes const& arguments: _argumentVariants)
 		{
 			sendMessage(hash.asBytes() + arguments, false, 0);
diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp
diff --git a/test/libsolidity/util/ContractABIUtils.cpp b/test/libsolidity/util/ContractABIUtils.cpp
diff --git a/test/libsolutil/FixedHash.cpp b/test/libsolutil/FixedHash.cpp
diff --git a/test/libsolutil/FunctionSelector.cpp b/test/libsolutil/FunctionSelector.cpp
diff --git a/test/tools/yulInterpreter/EwasmBuiltinInterpreter.cpp b/test/tools/yulInterpreter/EwasmBuiltinInterpreter.cpp

Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,7 @@ struct ReservedErrorSelector: public PostTypeChecker::Checker`
`411`	`411`	`);`
`412`	`412`	`else`
`413`	`413`	`{`
`414`		`- uint32_t selector = util::selectorFromSignature32(_error.functionType(true)->externalSignature());`
	`414`	`+ uint32_t selector = util::selectorFromSignatureU32(_error.functionType(true)->externalSignature());`
`415`	`415`	`if (selector == 0 \|\| ~selector == 0)`
`416`	`416`	`m_errorReporter.syntaxError(`
`417`	`417`	`2855_error,`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ bool PostTypeContractLevelChecker::check(ContractDefinition const& _contract)`
`52`	`52`	`for (ErrorDefinition const* error: _contract.interfaceErrors())`
`53`	`53`	`{`
`54`	`54`	`string signature = error->functionType(true)->externalSignature();`
`55`		`- uint32_t hash = util::selectorFromSignature32(signature);`
	`55`	`+ uint32_t hash = util::selectorFromSignatureU32(signature);`
`56`	`56`	`// Fail if there is a different signature for the same hash.`
`57`	`57`	`if (!errorHashes[hash].empty() && !errorHashes[hash].count(signature))`
`58`	`58`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@`
`27`	`27`	`#include <libsolidity/ast/ASTVisitor.h>`
`28`	`28`	`#include <libsolidity/ast/AST_accept.h>`
`29`	`29`	`#include <libsolidity/ast/TypeProvider.h>`
	`30`	`+#include <libsolutil/FunctionSelector.h>`
`30`	`31`	`#include <libsolutil/Keccak256.h>`
`31`	`32`
`32`	`33`	`#include <range/v3/view/tail.hpp>`
`@@ -281,8 +282,7 @@ vector<pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition:`
`281`	`282`	`if (signaturesSeen.count(functionSignature) == 0)`
`282`	`283`	`{`
`283`	`284`	`signaturesSeen.insert(functionSignature);`
`284`		`- util::FixedHash<4> hash(util::keccak256(functionSignature));`
`285`		`- interfaceFunctionList.emplace_back(hash, fun);`
	`285`	`+ interfaceFunctionList.emplace_back(util::selectorFromSignatureH32(functionSignature), fun);`
`286`	`286`	`}`
`287`	`287`	`}`
`288`	`288`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3583,12 +3583,12 @@ string FunctionType::externalSignature() const`
`3583`	`3583`
`3584`	`3584`	`u256 FunctionType::externalIdentifier() const`
`3585`	`3585`	`{`
`3586`		`- return util::selectorFromSignature32(externalSignature());`
	`3586`	`+ return util::selectorFromSignatureU32(externalSignature());`
`3587`	`3587`	`}`
`3588`	`3588`
`3589`	`3589`	`string FunctionType::externalIdentifierHex() const`
`3590`	`3590`	`{`
`3591`		`- return util::FixedHash<4>(util::keccak256(externalSignature())).hex();`
	`3591`	`+ return util::selectorFromSignatureH32(externalSignature()).hex();`
`3592`	`3592`	`}`
`3593`	`3593`
`3594`	`3594`	`bool FunctionType::isPure() const`
Original file line number	Diff line number	Diff line change
`@@ -889,7 +889,7 @@ void ArrayUtils::popStorageArrayElement(ArrayType const& _type) const`
`889`	`889`	`}`
`890`	`890`	`sstore(ref, slot_value)`
`891`	`891`	`})");`
`892`		`- code("panicSelector", util::selectorFromSignature("Panic(uint256)").str());`
	`892`	`+ code("panicSelector", util::selectorFromSignatureU256("Panic(uint256)").str());`
`893`	`893`	`code("emptyArrayPop", to_string(unsigned(util::PanicCode::EmptyArrayPop)));`
`894`	`894`	`m_context.appendInlineAssembly(code.render(), {"ref", "slot_value", "length"});`
`895`	`895`	`m_context << Instruction::POP << Instruction::POP << Instruction::POP;`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ void CompilerUtils::revertWithStringData(Type const& _argumentType)`
`95`	`95`	`{`
`96`	`96`	`solAssert(_argumentType.isImplicitlyConvertibleTo(*TypeProvider::fromElementaryTypeName("string memory")));`
`97`	`97`	`fetchFreeMemoryPointer();`
`98`		`- m_context << util::selectorFromSignature("Error(string)");`
	`98`	`+ m_context << util::selectorFromSignatureU256("Error(string)");`
`99`	`99`	`m_context << Instruction::DUP2 << Instruction::MSTORE;`
`100`	`100`	`m_context << u256(4) << Instruction::ADD;`
`101`	`101`	`// Stack: <string data> <mem pos of encoding start>`
`@@ -111,7 +111,7 @@ void CompilerUtils::revertWithError(`
`111`	`111`	`)`
`112`	`112`	`{`
`113`	`113`	`fetchFreeMemoryPointer();`
`114`		`- m_context << util::selectorFromSignature(_signature);`
	`114`	`+ m_context << util::selectorFromSignatureU256(_signature);`
`115`	`115`	`m_context << Instruction::DUP2 << Instruction::MSTORE;`
`116`	`116`	`m_context << u256(4) << Instruction::ADD;`
`117`	`117`	`// Stack: <arguments...> <mem pos of encoding start>`
Original file line number	Diff line number	Diff line change
`@@ -1329,7 +1329,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)`
`1329`	`1329`	`// hash the signature`
`1330`	`1330`	`if (auto const* stringType = dynamic_cast<StringLiteralType const*>(selectorType))`
`1331`	`1331`	`{`
`1332`		`- m_context << util::selectorFromSignature(stringType->value());`
	`1332`	`+ m_context << util::selectorFromSignatureU256(stringType->value());`
`1333`	`1333`	`dataOnStack = TypeProvider::fixedBytes(4);`
`1334`	`1334`	`}`
`1335`	`1335`	`else`