Optimise AssemblyItem::m_data.

cmake/EthCompilerSettings.cmake

@@ -71,7 +71,7 @@ if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MA
 	add_compile_options(-fPIC)
 
 	# Configuration-specific compiler settings.
-	set(CMAKE_CXX_FLAGS_DEBUG          "-Og -g -DETH_DEBUG")
+	set(CMAKE_CXX_FLAGS_DEBUG          " -g -DETH_DEBUG")
 	set(CMAKE_CXX_FLAGS_MINSIZEREL     "-Os -DNDEBUG")
 	set(CMAKE_CXX_FLAGS_RELEASE        "-O3 -DNDEBUG")
 	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")

libevmasm/Assembly.cpp

@@ -416,7 +416,7 @@ LinkerObject const& Assembly::assemble() const
 		switch (i.type())
 		{
 		case Operation:
-			ret.bytecode.push_back((byte)i.data());
+			ret.bytecode.push_back((byte)i.instruction());
 			break;
 		case PushString:
 		{

libevmasm/AssemblyItem.cpp

@@ -29,19 +29,19 @@ using namespace dev::eth;
 
 AssemblyItem AssemblyItem::toSubAssemblyTag(size_t _subId) const
 {
-	assertThrow(m_data < (u256(1) << 64), Exception, "Tag already has subassembly set.");
+	assertThrow(data() < (u256(1) << 64), Exception, "Tag already has subassembly set.");
 
 	assertThrow(m_type == PushTag || m_type == Tag, Exception, "");
 	AssemblyItem r = *this;
 	r.m_type = PushTag;
-	r.setPushTagSubIdAndTag(_subId, size_t(m_data));
+	r.setPushTagSubIdAndTag(_subId, size_t(data()));
 	return r;
 }
 
 pair<size_t, size_t> AssemblyItem::splitForeignPushTag() const
 {
 	assertThrow(m_type == PushTag || m_type == Tag, Exception, "");
-	return make_pair(size_t(m_data / (u256(1) << 64)) - 1, size_t(m_data));
+	return make_pair(size_t((data()) / (u256(1) << 64)) - 1, size_t(data()));
 }
 
 void AssemblyItem::setPushTagSubIdAndTag(size_t _subId, size_t _tag)
@@ -60,7 +60,7 @@ unsigned AssemblyItem::bytesRequired(unsigned _addressLength) const
 	case PushString:
 		return 33;
 	case Push:
-		return 1 + max<unsigned>(1, dev::bytesRequired(m_data));
+		return 1 + max<unsigned>(1, dev::bytesRequired(data()));
 	case PushSubSize:
 	case PushProgramSize:
 		return 4;		// worst case: a 16MB program

libevmasm/AssemblyItem.h

@@ -59,16 +59,22 @@ public:
 	AssemblyItem(u256 _push, SourceLocation const& _location = SourceLocation()):
 		AssemblyItem(Push, _push, _location) { }
 	AssemblyItem(solidity::Instruction _i, SourceLocation const& _location = SourceLocation()):
-		AssemblyItem(Operation, byte(_i), _location) { }
+		m_type(Operation),
+		m_instruction(_i),
+		m_location(_location)
+	{}
 	AssemblyItem(AssemblyItemType _type, u256 _data = 0, SourceLocation const& _location = SourceLocation()):
 		m_type(_type),
-		m_data(_data),
 		m_location(_location)
 	{
+		if (m_type == Operation)
+			m_instruction = Instruction(byte(_data));
+		else
+			m_data = std::make_shared<u256>(_data);
 	}
 
-	AssemblyItem tag() const { assertThrow(m_type == PushTag || m_type == Tag, Exception, ""); return AssemblyItem(Tag, m_data); }
+	AssemblyItem tag() const { assertThrow(m_type == PushTag || m_type == Tag, Exception, ""); return AssemblyItem(Tag, data()); }
-	AssemblyItem pushTag() const { assertThrow(m_type == PushTag || m_type == Tag, Exception, ""); return AssemblyItem(PushTag, m_data); }
+	AssemblyItem pushTag() const { assertThrow(m_type == PushTag || m_type == Tag, Exception, ""); return AssemblyItem(PushTag, data()); }
 	/// Converts the tag to a subassembly tag. This has to be called in order to move a tag across assemblies.
 	/// @param _subId the identifier of the subassembly the tag is taken from.
 	AssemblyItem toSubAssemblyTag(size_t _subId) const;
@@ -79,18 +85,34 @@ public:
 	void setPushTagSubIdAndTag(size_t _subId, size_t _tag);
 
 	AssemblyItemType type() const { return m_type; }
-	u256 const& data() const { return m_data; }
+	u256 const& data() const { assertThrow(m_type != Operation, Exception, ""); return *m_data; }
-	void setType(AssemblyItemType const _type) { m_type = _type; }
+	//void setType(AssemblyItemType const _type) { m_type = _type; }
-	void setData(u256 const& _data) { m_data = _data; }
+	void setData(u256 const& _data) { assertThrow(m_type != Operation, Exception, ""); m_data = std::make_shared<u256>(_data); }
 
 	/// @returns the instruction of this item (only valid if type() == Operation)
-	Instruction instruction() const { return Instruction(byte(m_data)); }
+	Instruction instruction() const { assertThrow(m_type == Operation, Exception, ""); return m_instruction; }
 
 	/// @returns true if the type and data of the items are equal.
-	bool operator==(AssemblyItem const& _other) const { return m_type == _other.m_type && m_data == _other.m_data; }
+	bool operator==(AssemblyItem const& _other) const
+	{
+		if (type() != _other.type())
+			return false;
+		if (type() == Operation)
+			return instruction() == _other.instruction();
+		else
+			return data() == _other.data();
+	}
 	bool operator!=(AssemblyItem const& _other) const { return !operator==(_other); }
 	/// Less-than operator compatible with operator==.
-	bool operator<(AssemblyItem const& _other) const { return std::tie(m_type, m_data) < std::tie(_other.m_type, _other.m_data); }
+	bool operator<(AssemblyItem const& _other) const
+	{
+		if (type() != _other.type())
+			return type() < _other.type();
+		else if (type() == Operation)
+			return instruction() < _other.instruction();
+		else
+			return data() < _other.data();
+	}
 
 	/// @returns an upper bound for the number of bytes required by this item, assuming that
 	/// the value of a jump tag takes @a _addressLength bytes.
@@ -100,7 +122,6 @@ public:
 	/// @returns true if the assembly item can be used in a functional context.
 	bool canBeFunctional() const;
 
-	bool match(AssemblyItem const& _i) const { return _i.m_type == UndefinedItem || (m_type == _i.m_type && (m_type != Operation || m_data == _i.m_data)); }
 	void setLocation(SourceLocation const& _location) { m_location = _location; }
 	SourceLocation const& location() const { return m_location; }
 
@@ -115,7 +136,8 @@ public:
 
 private:
 	AssemblyItemType m_type;
-	u256 m_data;
+	Instruction m_instruction; ///< Only valid if m_type == Operation
+	std::shared_ptr<u256> m_data; ///< Only valid if m_type != Operation
 	SourceLocation m_location;
 	JumpType m_jumpType = JumpType::Ordinary;
 	/// Pushed value for operations with data to be determined during assembly stage,

libevmasm/ExpressionClasses.cpp

@@ -40,8 +40,18 @@ bool ExpressionClasses::Expression::operator<(ExpressionClasses::Expression cons
 	assertThrow(!!item && !!_other.item, OptimizerException, "");
 	auto type = item->type();
 	auto otherType = _other.item->type();
-	return std::tie(type, item->data(), arguments, sequenceNumber) <
+	if (type != otherType)
-		std::tie(otherType, _other.item->data(), _other.arguments, _other.sequenceNumber);
+		return type < otherType;
+	else if (type == Operation)
+	{
+		auto instr = item->instruction();
+		auto otherInstr = _other.item->instruction();
+		return std::tie(instr, arguments, sequenceNumber) <
+			std::tie(otherInstr, _other.arguments, _other.sequenceNumber);
+	}
+	else
+		return std::tie(item->data(), arguments, sequenceNumber) <
+			std::tie(_other.item->data(), _other.arguments, _other.sequenceNumber);
 }
 
 ExpressionClasses::Id ExpressionClasses::find(
@@ -479,8 +489,13 @@ bool Pattern::matchesBaseItem(AssemblyItem const* _item) const
 		return false;
 	if (m_type != _item->type())
 		return false;
-	if (m_requireDataMatch && m_data != _item->data())
+	if (m_requireDataMatch)
-		return false;
+	{
+		if (m_type == Operation)
+			return m_data == u256(byte(_item->instruction()));
+		else
+			return m_data == _item->data();
+	}
 	return true;
 }