Merge branch 'develop' of github.com:tfire/solidity into fix/remove-namespace-ast-annotations

Author: tylerfxn

.circleci/config.yml

@@ -504,28 +504,14 @@ defaults:
       binary_type: solcjs
       compile_only: 1
       nodejs_version: '14'
-  - job_native_compile_ext_gnosis: &job_native_compile_ext_gnosis
-      <<: *workflow_ubuntu2004_static
-      name: t_native_compile_ext_gnosis
-      project: gnosis
-      binary_type: native
-      compile_only: 1
-      nodejs_version: '14'
 
   - job_native_test_ext_gnosis: &job_native_test_ext_gnosis
-      <<: *workflow_emscripten
+      <<: *workflow_ubuntu2004_static
       name: t_native_test_ext_gnosis
       project: gnosis
       binary_type: native
-      # NOTE: Tests do not start on node.js 14 ("ganache-cli exited early with code 1").
-      nodejs_version: '12'
-  - job_native_test_ext_gnosis_v2: &job_native_test_ext_gnosis_v2
-      <<: *workflow_ubuntu2004_static
-      name: t_native_test_ext_gnosis_v2
-      project: gnosis-v2
-      binary_type: native
-      # NOTE: Tests do not start on node.js 14 ("ganache-cli exited early with code 1").
-      nodejs_version: '12'
+      # NOTE: Tests crash on nodejs 17: "Error: error:0308010C:digital envelope routines::unsupported"
+      nodejs_version: '16'
   - job_native_test_ext_zeppelin: &job_native_test_ext_zeppelin
       <<: *workflow_ubuntu2004_static
       name: t_native_test_ext_zeppelin
@@ -1466,12 +1452,8 @@ workflows:
       - t_ems_ext_hardhat: *workflow_emscripten
 
       - t_ems_ext: *job_ems_compile_ext_colony
-      - t_ems_ext: *job_native_compile_ext_gnosis
 
-      # FIXME: Gnosis tests are pretty flaky right now. They often fail on CircleCI due to random ProviderError
-      # and there are also other less frequent problems. See https://github.com/gnosis/safe-contracts/issues/216.
-      #-t_ems_ext: *job_native_test_ext_gnosis
-      - t_ems_ext: *job_native_test_ext_gnosis_v2
+      - t_ems_ext: *job_native_test_ext_gnosis
       - t_ems_ext: *job_native_test_ext_zeppelin
       - t_ems_ext: *job_native_test_ext_ens
       - t_ems_ext: *job_native_test_ext_trident
@@ -1488,8 +1470,7 @@ workflows:
           <<: *workflow_trigger_on_tags
           requires:
             - t_ems_compile_ext_colony
-            - t_native_compile_ext_gnosis
-            - t_native_test_ext_gnosis_v2
+            - t_native_test_ext_gnosis
             - t_native_test_ext_zeppelin
             - t_native_test_ext_ens
             - t_native_test_ext_trident

Changelog.md

@@ -6,6 +6,8 @@ Language Features:
 
 Compiler Features:
 * JSON-AST: Added selector field for errors and events.
+ * Peephole Optimizer: Optimize comparisons in front of conditional jumps and conditional jumps across a single unconditional jump.
+ * Yul Optimizer: Remove ``sstore`` and ``mstore`` operations that are never read from.
 
 Bugfixes:
  * Yul IR Code Generation: Optimize embedded creation code with correct settings. This fixes potential mismatches between the constructor code of a contract compiled in isolation and the bytecode in ``type(C).creationCode``, resp. the bytecode used for ``new C(...)``.

docs/contracts/interfaces.rst

@@ -10,7 +10,7 @@ Interfaces are similar to abstract contracts, but they cannot have any functions
 There are further restrictions:
 
 - They cannot inherit from other contracts, but they can inherit from other interfaces.
-- All declared functions must be external.
+- All declared functions must be external in the interface, even if they are public in the contract.
 - They cannot declare a constructor.
 - They cannot declare state variables.
 - They cannot declare modifiers.

libevmasm/PeepholeOptimiser.cpp

@@ -233,6 +233,65 @@ struct IsZeroIsZeroJumpI: SimplePeepholeOptimizerMethod<IsZeroIsZeroJumpI>
 	}
 };
 
+struct EqIsZeroJumpI: SimplePeepholeOptimizerMethod<EqIsZeroJumpI>
+{
+	static size_t applySimple(
+		AssemblyItem const& _eq,
+		AssemblyItem const& _iszero,
+		AssemblyItem const& _pushTag,
+		AssemblyItem const& _jumpi,
+		std::back_insert_iterator<AssemblyItems> _out
+	)
+	{
+		if (
+			_eq == Instruction::EQ &&
+			_iszero == Instruction::ISZERO &&
+			_pushTag.type() == PushTag &&
+			_jumpi == Instruction::JUMPI
+		)
+		{
+			*_out = AssemblyItem(Instruction::SUB, _eq.location());
+			*_out = _pushTag;
+			*_out = _jumpi;
+			return true;
+		}
+		else
+			return false;
+	}
+};
+
+// push_tag_1 jumpi push_tag_2 jump tag_1: -> iszero push_tag_2 jumpi tag_1:
+struct DoubleJump: SimplePeepholeOptimizerMethod<DoubleJump>
+{
+	static size_t applySimple(
+		AssemblyItem const& _pushTag1,
+		AssemblyItem const& _jumpi,
+		AssemblyItem const& _pushTag2,
+		AssemblyItem const& _jump,
+		AssemblyItem const& _tag1,
+		std::back_insert_iterator<AssemblyItems> _out
+	)
+	{
+		if (
+			_pushTag1.type() == PushTag &&
+			_jumpi == Instruction::JUMPI &&
+			_pushTag2.type() == PushTag &&
+			_jump == Instruction::JUMP &&
+			_tag1.type() == Tag &&
+			_pushTag1.data() == _tag1.data()
+		)
+		{
+			*_out = AssemblyItem(Instruction::ISZERO, _jumpi.location());
+			*_out = _pushTag2;
+			*_out = _jumpi;
+			*_out = _tag1;
+			return true;
+		}
+		else
+			return false;
+	}
+};
+
 struct JumpToNext: SimplePeepholeOptimizerMethod<JumpToNext>
 {
 	static size_t applySimple(
@@ -372,7 +431,7 @@ bool PeepholeOptimiser::optimise()
 		applyMethods(
 			state,
 			PushPop(), OpPop(), DoublePush(), DoubleSwap(), CommutativeSwap(), SwapComparison(),
-			DupSwap(), IsZeroIsZeroJumpI(), JumpToNext(), UnreachableCode(),
+			DupSwap(), IsZeroIsZeroJumpI(), EqIsZeroJumpI(), DoubleJump(), JumpToNext(), UnreachableCode(),
 			TagConjunctions(), TruthyAnd(), Identity()
 		);
 	if (m_optimisedItems.size() < m_items.size() || (

libevmasm/SemanticInformation.cpp

@@ -121,7 +121,9 @@ vector<SemanticInformation::Operation> SemanticInformation::readWriteOperations(
 			Location::Memory,
 			Effect::Write,
 			paramCount - 2,
-			paramCount - 1,
+			// Length is in paramCount - 1, but it is only a max length,
+			// there is no guarantee that the full area is written to.
+			{},
 			{}
 		});
 		return operations;

libsolidity/ast/Types.cpp

@@ -2341,6 +2341,11 @@ TypeResult StructType::interfaceType(bool _inLibrary) const
 	return *m_interfaceType_library;
 }
 
+Declaration const* StructType::typeDefinition() const
+{
+	return &structDefinition();
+}
+
 BoolResult StructType::validForLocation(DataLocation _loc) const
 {
 	for (auto const& member: m_struct.members())
@@ -2473,6 +2478,11 @@ Type const* EnumType::encodingType() const
 	return TypeProvider::uint(8);
 }
 
+Declaration const* EnumType::typeDefinition() const
+{
+	return &enumDefinition();
+}
+
 TypeResult EnumType::unaryOperatorResult(Token _operator) const
 {
 	return _operator == Token::Delete ? TypeProvider::emptyTuple() : nullptr;
@@ -2541,6 +2551,11 @@ Type const& UserDefinedValueType::underlyingType() const
 	return *type;
 }
 
+Declaration const* UserDefinedValueType::typeDefinition() const
+{
+	return &m_definition;
+}
+
 string UserDefinedValueType::richIdentifier() const
 {
 	return "t_userDefinedValueType" + parenthesizeIdentifier(m_definition.name()) + to_string(m_definition.id());

libsolidity/ast/Types.h

@@ -369,6 +369,10 @@ class Type
 	/// are returned without modification.
 	virtual TypeResult interfaceType(bool /*_inLibrary*/) const { return nullptr; }
 
+	/// @returns the declaration of a user defined type (enum, struct, user defined value type).
+	/// Returns nullptr otherwise.
+	virtual Declaration const* typeDefinition() const { return nullptr; }
+
 	/// Clears all internally cached values (if any).
 	virtual void clearCache() const;
 
@@ -1004,6 +1008,8 @@ class StructType: public ReferenceType
 	Type const* encodingType() const override;
 	TypeResult interfaceType(bool _inLibrary) const override;
 
+	Declaration const* typeDefinition() const override;
+
 	BoolResult validForLocation(DataLocation _loc) const override;
 
 	bool recursive() const;
@@ -1069,6 +1075,8 @@ class EnumType: public Type
 		return _inLibrary ? this : encodingType();
 	}
 
+	Declaration const* typeDefinition() const override;
+
 	EnumDefinition const& enumDefinition() const { return m_enum; }
 	/// @returns the value that the string has in the Enum
 	unsigned int memberValue(ASTString const& _member) const;
@@ -1101,6 +1109,9 @@ class UserDefinedValueType: public Type
 	TypeResult binaryOperatorResult(Token, Type const*) const override { return nullptr; }
 	Type const* encodingType() const override { return &underlyingType(); }
 	TypeResult interfaceType(bool /* _inLibrary */) const override {return &underlyingType(); }
+
+	Declaration const* typeDefinition() const override;
+
 	std::string richIdentifier() const override;
 	bool operator==(Type const& _other) const override;
 

libsolidity/interface/OptimiserSettings.h

@@ -55,7 +55,7 @@ struct OptimiserSettings
 			"xa[rul]"                  // Prune a bit more in SSA
 			"xa[r]cL"                  // Turn into SSA again and simplify
 			"gvif"                     // Run full inliner
-			"CTUca[r]LsTFOtfDnca[r]Iulc" // SSA plus simplify
+			"CTUca[r]LSsTFOtfDnca[r]Iulc" // SSA plus simplify
 		"]"
 		"jmul[jul] VcTOcul jmul";      // Make source short and pretty
 

libyul/CMakeLists.txt

@@ -179,6 +179,8 @@ add_library(yul
 	optimiser/UnusedAssignEliminator.h
 	optimiser/UnusedStoreBase.cpp
 	optimiser/UnusedStoreBase.h
+	optimiser/UnusedStoreEliminator.cpp
+	optimiser/UnusedStoreEliminator.h
 	optimiser/Rematerialiser.cpp
 	optimiser/Rematerialiser.h
 	optimiser/SMTSolver.cpp

libyul/optimiser/StructuralSimplifier.cpp

@@ -55,6 +55,30 @@ OptionalStatements replaceConstArgSwitch(Switch& _switchStmt, u256 const& _const
 		return optional<vector<Statement>>{vector<Statement>{}};
 }
 
+optional<u256> hasLiteralValue(Expression const& _expression)
+{
+	if (holds_alternative<Literal>(_expression))
+		return valueOfLiteral(std::get<Literal>(_expression));
+	else
+		return std::optional<u256>();
+}
+
+bool expressionAlwaysTrue(Expression const& _expression)
+{
+	if (std::optional<u256> value = hasLiteralValue(_expression))
+		return *value != 0;
+	else
+		return false;
+}
+
+bool expressionAlwaysFalse(Expression const& _expression)
+{
+	if (std::optional<u256> value = hasLiteralValue(_expression))
+		return *value == 0;
+	else
+		return false;
+}
+
 }
 
 void StructuralSimplifier::run(OptimiserStepContext&, Block& _ast)
@@ -103,27 +127,3 @@ void StructuralSimplifier::simplify(std::vector<yul::Statement>& _statements)
 		}
 	);
 }
-
-bool StructuralSimplifier::expressionAlwaysTrue(Expression const& _expression)
-{
-	if (std::optional<u256> value = hasLiteralValue(_expression))
-		return *value != 0;
-	else
-		return false;
-}
-
-bool StructuralSimplifier::expressionAlwaysFalse(Expression const& _expression)
-{
-	if (std::optional<u256> value = hasLiteralValue(_expression))
-		return *value == 0;
-	else
-		return false;
-}
-
-std::optional<u256> StructuralSimplifier::hasLiteralValue(Expression const& _expression) const
-{
-	if (holds_alternative<Literal>(_expression))
-		return valueOfLiteral(std::get<Literal>(_expression));
-	else
-		return std::optional<u256>();
-}