From afad40ac5a259cf60cd2f5c8b31495f3f64f3e8e Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Fri, 6 Jan 2017 11:33:08 +0100
Subject: Optimise AssemblyItem::m_data.

---
 libevmasm/AssemblyItem.h | 46 ++++++++++++++++++++++++++++++++++------------
 1 file changed, 34 insertions(+), 12 deletions(-)

(limited to 'libevmasm/AssemblyItem.h')

diff --git a/libevmasm/AssemblyItem.h b/libevmasm/AssemblyItem.h
index cddfb17c..7fcaa145 100644
--- a/libevmasm/AssemblyItem.h
+++ b/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 pushTag() const { assertThrow(m_type == PushTag || m_type == Tag, Exception, ""); return AssemblyItem(PushTag, 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, 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; }
-	void setType(AssemblyItemType const _type) { m_type = _type; }
-	void setData(u256 const& _data) { m_data = _data; }
+	u256 const& data() const { assertThrow(m_type != Operation, Exception, ""); return *m_data; }
+	//void setType(AssemblyItemType const _type) { m_type = _type; }
+	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,
-- 
cgit