Implement ethdebug instruction json as struct hierarchy

Author: clonker

Diff for: libevmasm/Ethdebug.cpp

@@ -19,6 +19,8 @@
 #include <libevmasm/Ethdebug.h>
 
 #include <range/v3/algorithm/any_of.hpp>
+#include <range/v3/view/transform.hpp>
+#include <range/v3/to_container.hpp>
 
 using namespace solidity;
 using namespace solidity::evmasm;
@@ -27,14 +29,64 @@ using namespace solidity::evmasm::ethdebug;
 namespace
 {
 
-std::vector<Json> codeSectionInstructions(Assembly const& _assembly, LinkerObject const& _linkerObject, unsigned _sourceId, size_t const _codeSectionIndex)
+struct SourceRange
+{
+	size_t sourceID;
+	int length;
+	int offset;
+};
+void to_json(Json& _json, SourceRange const& _sourceRange)
+{
+	_json = { {"source", { {"id", static_cast<int>(_sourceRange.sourceID)}} }, { "range", { { "offset", _sourceRange.offset }, { "length", _sourceRange.length } } } };
+}
+
+struct Context
+{
+	SourceRange code;
+};
+void to_json(Json& _json, Context const& _context)
+{
+	_json = { {"code", _context.code} };
+}
+
+struct Operation
+{
+	std::string mnemonic;
+	std::vector<bytes> arguments;
+};
+void to_json(Json& _json, Operation const& _operation)
+{
+	_json = { {"mnemonic", _operation.mnemonic} };
+	if (!_operation.arguments.empty())
+	{
+		_json["arguments"] = _operation.arguments |
+			ranges::views::transform([](bytes const& _argumentData) { return util::toHex(_argumentData, util::HexPrefix::Add); });
+	}
+}
+
+struct Instruction
+{
+	size_t offset;
+	Context context;
+	Operation operation;
+};
+void to_json(Json& _json, Instruction const& _instruction)
+{
+	_json = {
+		{"offset", _instruction.offset},
+		{"context", _instruction.context},
+		{"operation", _instruction.operation}
+	};
+}
+
+std::vector<Instruction> codeSectionInstructions(Assembly const& _assembly, LinkerObject const& _linkerObject, unsigned const _sourceID, size_t const _codeSectionIndex)
 {
 	solAssert(_codeSectionIndex < _linkerObject.codeSectionLocations.size());
 	solAssert(_codeSectionIndex < _assembly.codeSections().size());
 	auto const& locations = _linkerObject.codeSectionLocations[_codeSectionIndex];
 	auto const& codeSection = _assembly.codeSections().at(_codeSectionIndex);
 
-	std::vector<Json> instructions;
+	std::vector<Instruction> instructions;
 	instructions.reserve(codeSection.items.size());
 
 	bool const codeSectionContainsVerbatim = ranges::any_of(
@@ -51,8 +103,9 @@ std::vector<Json> codeSectionInstructions(Assembly const& _assembly, LinkerObjec
 		solAssert(end <= _linkerObject.bytecode.size());
 		solAssert(start < end);
 		solAssert(assemblyItemIndex < codeSection.items.size());
-		Json operation = Json::object();
-		operation["mnemonic"] = instructionInfo(static_cast<Instruction>(_linkerObject.bytecode[start]), _assembly.evmVersion()).name;
+
+		Operation operation;
+		operation.mnemonic = instructionInfo(static_cast<evmasm::Instruction>(_linkerObject.bytecode[start]), _assembly.evmVersion()).name;
 		static size_t constexpr instructionSize = 1;
 		if (start + instructionSize < end)
 		{
@@ -61,56 +114,51 @@ std::vector<Json> codeSectionInstructions(Assembly const& _assembly, LinkerObjec
 				_linkerObject.bytecode.begin() + static_cast<std::ptrdiff_t>(end)
 			);
 			solAssert(!argumentData.empty());
-			operation["arguments"] = Json::array({util::toHex(argumentData, util::HexPrefix::Add)});
+			operation.arguments = {argumentData};
 		}
 		langutil::SourceLocation const& location = codeSection.items.at(assemblyItemIndex).location();
-		instructions.emplace_back(Json{
-			{ "offset", start },
-			{"operation", operation },
-			{
-				"context", {
-					"code", {
-						"source", {
-							{ "id", static_cast<int>(_sourceId) },
-						},
-						"range", {
-							{ "offset", location.start },
-							{ "length", location.end - location.start }
-						}
-					}
+
+		instructions.emplace_back(Instruction{
+			.offset = start,
+			.context = {
+				.code = {
+					.sourceID = _sourceID,
+					.length = location.end - location.start,
+					.offset = location.start
 				}
-			}
+			},
+			.operation = operation
 		});
 	}
 
 	return instructions;
 }
 
-Json programInstructions(Assembly const& _assembly, LinkerObject const& _linkerObject, unsigned _sourceId)
+std::vector<Instruction> programInstructions(Assembly const& _assembly, LinkerObject const& _linkerObject, unsigned const _sourceID)
 {
 	auto const numCodeSections = _assembly.codeSections().size();
 	solAssert(numCodeSections == _linkerObject.codeSectionLocations.size());
 
-	std::vector<Json> instructionInfo;
+	std::vector<Instruction> instructionInfo;
 	for (size_t codeSectionIndex = 0; codeSectionIndex < numCodeSections; ++codeSectionIndex)
-		instructionInfo += codeSectionInstructions(_assembly, _linkerObject, _sourceId, codeSectionIndex);
+		instructionInfo += codeSectionInstructions(_assembly, _linkerObject, _sourceID, codeSectionIndex);
 	return instructionInfo;
 }
 
 } // anonymous namespace
 
-Json ethdebug::program(std::string_view _name, unsigned _sourceId, Assembly const* _assembly, LinkerObject const& _linkerObject)
+Json ethdebug::program(std::string_view _name, unsigned _sourceID, Assembly const* _assembly, LinkerObject const& _linkerObject)
 {
 	Json result = Json::object();
 	result["contract"] = Json::object();
 	result["contract"]["name"] = _name;
 	result["contract"]["definition"] = Json::object();
 	result["contract"]["definition"]["source"] = Json::object();
-	result["contract"]["definition"]["source"]["id"] = _sourceId;
+	result["contract"]["definition"]["source"]["id"] = _sourceID;
 	if (_assembly)
 	{
 		result["environment"] = _assembly->isCreation() ? "create" : "call";
-		result["instructions"] = programInstructions(*_assembly, _linkerObject, _sourceId);
+		result["instructions"] = programInstructions(*_assembly, _linkerObject, _sourceID);
 	}
 	return result;
 }

Diff for: libevmasm/Ethdebug.h

@@ -27,7 +27,7 @@ namespace solidity::evmasm::ethdebug
 {
 
 // returns ethdebug/format/program.
-Json program(std::string_view _name, unsigned _sourceId, Assembly const* _assembly, LinkerObject const& _linkerObject);
+Json program(std::string_view _name, unsigned _sourceID, Assembly const* _assembly, LinkerObject const& _linkerObject);
 
 // returns ethdebug/format/info/resources
 Json resources(std::vector<std::string> const& _sources, std::string const& _version);