[libevmasm] Add support to import evm assembly json.

Author: aarlt

libevmasm/Assembly.cpp

@@ -34,7 +34,7 @@
 #include <liblangutil/CharStream.h>
 #include <liblangutil/Exceptions.h>
 
-#include <json/json.h>
+#include <libsolutil/JSON.h>
 
 #include <range/v3/algorithm/any_of.hpp>
 #include <range/v3/view/enumerate.hpp>
@@ -74,6 +74,123 @@ unsigned Assembly::codeSize(unsigned subTagSize) const
 	}
 }
 
+void Assembly::addAssemblyItemsFromJSON(Json::Value const& _code)
+{
+	solAssert(m_items.empty(), "");
+	solAssert(_code.isArray(), "");
+	for (auto const& jsonItem: _code)
+		m_items.emplace_back(createAssemblyItemFromJSON(jsonItem));
+
+	for (auto current = m_items.begin(); current != m_items.end(); ++current)
+	{
+		// During the assembly json export a `JUMPDEST` is always generated after a `tag`.
+		// So we just ignore exactly these `JUMPDEST`'s.
+		auto const next = std::next(current);
+		if (
+			next != m_items.end() &&
+			current->type() == AssemblyItemType::Tag &&
+			next->type() == AssemblyItemType::Operation &&
+			next->instruction() == Instruction::JUMPDEST
+		)
+			m_items.erase(next);
+	}
+}
+
+AssemblyItem Assembly::createAssemblyItemFromJSON(Json::Value const& _json)
+{
+	solAssert(isOfType<std::string>(_json["name"]));
+	solAssert(isOfType<int>(_json["begin"]));
+	solAssert(isOfType<int>(_json["end"]));
+	solAssert(isOfType<int>(_json["source"]));
+	solAssert(isOfTypeIfExists<std::string>(_json, "value"));
+	solAssert(isOfTypeIfExists<int>(_json, "modifierDepth"));
+	solAssert(isOfTypeIfExists<std::string>(_json, "jumpType"));
+
+	std::string name = getOrDefault<std::string>(_json["name"], "");
+	solAssert(!name.empty());
+
+	SourceLocation location;
+	location.start = get<int>(_json["begin"]);
+	location.end = get<int>(_json["end"]);
+	int srcIndex = get<int>(_json["source"]);
+	size_t modifierDepth = static_cast<size_t>(getOrDefault<int>(_json["modifierDepth"], 0));
+	std::string value = getOrDefault<std::string>(_json["value"], "");
+	std::string jumpType = getOrDefault<std::string>(_json["jumpType"], "");
+
+
+	auto updateUsedTags = [&](u256 const& data) {
+		m_usedTags = max(m_usedTags, static_cast<unsigned>(data) + 1);
+		return data;
+	};
+
+	auto immutableHash = [&](string const& _immutableName) -> h256 {
+		h256 hash(util::keccak256(_immutableName));
+		m_immutables[hash] = _immutableName;
+		return hash;
+	};
+
+	auto libraryHash = [&](string const& _libraryName) -> h256 {
+		h256 hash(util::keccak256(_libraryName));
+		m_libraries[hash] = _libraryName;
+		return hash;
+	};
+
+	if (srcIndex > -1 && srcIndex < static_cast<int>(sources().size()))
+		location.sourceName = sources()[static_cast<size_t>(srcIndex)];
+
+	AssemblyItem result(0);
+
+	if (c_instructions.count(name))
+	{
+		AssemblyItem item{c_instructions.at(name), location};
+		if (!jumpType.empty())
+			item.setJumpType(jumpType);
+		result = item;
+	}
+	else
+	{
+		if (name == "PUSH")
+		{
+			AssemblyItem item{AssemblyItemType::Push, u256("0x" + value)};
+			if (!jumpType.empty())
+				item.setJumpType(jumpType);
+			result = item;
+		}
+		else if (name == "PUSH [ErrorTag]")
+			result = {AssemblyItemType::PushTag, 0};
+		else if (name == "PUSH [tag]")
+			result = {AssemblyItemType::PushTag, updateUsedTags(u256(value))};
+		else if (name == "PUSH [$]")
+			result = {AssemblyItemType::PushSub, u256("0x" + value)};
+		else if (name == "PUSH #[$]")
+			result = {AssemblyItemType::PushSubSize, u256("0x" + value)};
+		else if (name == "PUSHSIZE")
+			result = {AssemblyItemType::PushProgramSize, 0};
+		else if (name == "PUSHLIB")
+			result = {AssemblyItemType::PushLibraryAddress, libraryHash(value)};
+		else if (name == "PUSHDEPLOYADDRESS")
+			result = {AssemblyItemType::PushDeployTimeAddress, 0};
+		else if (name == "PUSHIMMUTABLE")
+			result = {AssemblyItemType::PushImmutable, immutableHash(value)};
+		else if (name == "ASSIGNIMMUTABLE")
+			result = {AssemblyItemType::AssignImmutable, immutableHash(value)};
+		else if (name == "tag")
+			result = {AssemblyItemType::Tag, updateUsedTags(u256(value))};
+		else if (name == "PUSH data")
+			result = {AssemblyItemType::PushData, u256("0x" + value)};
+		else if (name == "VERBATIM")
+		{
+			AssemblyItem item(fromHex(value), 0, 0);
+			result = item;
+		}
+		else
+			assertThrow(false, InvalidOpcode, "");
+	}
+	result.setLocation(location);
+	result.m_modifierDepth = modifierDepth;
+	return result;
+}
+
 namespace
 {
 
@@ -298,6 +415,43 @@ Json::Value Assembly::assemblyJSON(map<string, unsigned> const& _sourceIndices,
 	return root;
 }
 
+std::shared_ptr<Assembly> Assembly::loadFromAssemblyJSON(Json::Value const& _json, std::vector<std::string> const& _sourceList /* = {} */, bool _isCreation /* = true */)
+{
+	if (!_json[".code"].isArray())
+		return {};
+
+	std::shared_ptr<Assembly> result = std::make_shared<Assembly>(_isCreation, "");
+	vector<string> sourceList;
+	if (_sourceList.empty())
+	{
+		if (_json.isMember("sourceList"))
+			for (auto const& it: _json["sourceList"])
+				sourceList.emplace_back(it.asString());
+	}
+	else
+		sourceList = _sourceList;
+	result->setSources(sourceList);
+	result->addAssemblyItemsFromJSON(_json[".code"]);
+	if (_json[".auxdata"].isString())
+		result->m_auxiliaryData = fromHex(_json[".auxdata"].asString());
+	Json::Value const& data = _json[".data"];
+	for (Json::ValueConstIterator itr = data.begin(); itr != data.end(); itr++)
+	{
+		solAssert(itr.key().isString(), "");
+		std::string key = itr.key().asString();
+		Json::Value const& code = data[key];
+		if (code.isString())
+			result->m_data[h256(fromHex(key))] = fromHex(code.asString());
+		else
+		{
+			std::shared_ptr<Assembly> subassembly(Assembly::loadFromAssemblyJSON(code, sourceList, /* isCreation = */ false));
+			assertThrow(subassembly, AssemblyException, "");
+			result->m_subs.emplace_back(std::make_shared<Assembly>(*subassembly));
+		}
+	}
+	return result;
+}
+
 AssemblyItem Assembly::namedTag(string const& _name, size_t _params, size_t _returns, optional<uint64_t> _sourceID)
 {
 	assertThrow(!_name.empty(), AssemblyException, "Empty named tag.");

libevmasm/Assembly.h

@@ -154,6 +154,12 @@ class Assembly
 		bool _includeSourceList = true
 	) const;
 
+	/// Loads the JSON representation of assembly.
+	/// @param _json JSON object containing assembly
+	/// @param _loadSources true, if source list should be included, false otherwise.
+	/// @returns true on success, false otherwise
+	static std::shared_ptr<Assembly> loadFromAssemblyJSON(Json::Value const& _json, std::vector<std::string> const& _sourceList = {}, bool _isCreation = true);
+
 	/// Mark this assembly as invalid. Calling ``assemble`` on it will throw.
 	void markAsInvalid() { m_invalid = true; }
 
@@ -162,6 +168,22 @@ class Assembly
 
 	bool isCreation() const { return m_creation; }
 
+	/// Set the source name list.
+	void setSources(std::vector<std::shared_ptr<std::string const>> _sources)
+	{
+		m_sources = std::move(_sources);
+	}
+
+	/// Set the source name list from simple vector<string>.
+	void setSources(std::vector<std::string> const& _sources)
+	{
+		for (auto const& item: _sources)
+			m_sources.emplace_back(std::make_shared<std::string>(item));
+	}
+
+	/// @returns List of source names.
+	std::vector<std::shared_ptr<std::string const>> sources() const& { return m_sources; }
+
 protected:
 	/// Does the same operations as @a optimise, but should only be applied to a sub and
 	/// returns the replaced tags. Also takes an argument containing the tags of this assembly
@@ -170,6 +192,14 @@ class Assembly
 
 	unsigned codeSize(unsigned subTagSize) const;
 
+	/// Add all assembly items from given JSON array.
+	void addAssemblyItemsFromJSON(Json::Value const& _code);
+
+	/// Creates an AssemblyItem from a given JSON representation.
+	/// @param _json JSON representation of an assembly item
+	/// @returns AssemblyItem of _json argument.
+	AssemblyItem createAssemblyItemFromJSON(Json::Value const& _json);
+
 private:
 	bool m_invalid = false;
 
@@ -216,6 +246,7 @@ class Assembly
 	std::string m_name;
 
 	langutil::SourceLocation m_currentSourceLocation;
+	std::vector<std::shared_ptr<std::string const>> m_sources;
 
 public:
 	size_t m_currentModifierDepth = 0;

libevmasm/AssemblyItem.cpp

@@ -243,6 +243,18 @@ string AssemblyItem::getJumpTypeAsString() const
 	}
 }
 
+void AssemblyItem::setJumpType(std::string const& _jumpType)
+{
+	if (_jumpType == "[in]")
+		m_jumpType = JumpType::IntoFunction;
+	else if (_jumpType == "[out]")
+		m_jumpType = JumpType::OutOfFunction;
+	else if (_jumpType.empty())
+		m_jumpType = JumpType::Ordinary;
+	else
+		assertThrow(false, AssemblyException, "Invalid jump type.");
+}
+
 string AssemblyItem::toAssemblyText(Assembly const& _assembly) const
 {
 	string text;

libevmasm/AssemblyItem.h

@@ -173,6 +173,7 @@ class AssemblyItem
 	langutil::SourceLocation const& location() const { return m_location; }
 
 	void setJumpType(JumpType _jumpType) { m_jumpType = _jumpType; }
+	void setJumpType(std::string const& _jumpType);
 	JumpType getJumpType() const { return m_jumpType; }
 	std::string getJumpTypeAsString() const;