Merge branch 'develop' into patch-fixed_docs

fanhefeng · web-flow · commit ee6cd11d9b52 · 2025-05-07T00:48:04.000+08:00
diff --git a/libevmasm/AssemblyItem.h b/libevmasm/AssemblyItem.h
@@ -85,7 +85,10 @@ class AssemblyItem
 		m_type(Operation),
 		m_instruction(_i),
 		m_debugData(std::move(_debugData))
-	{}
+	{
+		solAssert(_i != Instruction::SWAPN, "Construct via AssemblyItem::swapN");
+		solAssert(_i != Instruction::DUPN, "Construct via AssemblyItem::dupN");
+	}
 	AssemblyItem(AssemblyItemType _type, u256 _data = 0, langutil::DebugData::ConstPtr _debugData = langutil::DebugData::create()):
 		m_type(_type),
 		m_debugData(std::move(_debugData))
diff --git a/test/libevmasm/PlainAssemblyParser.cpp b/test/libevmasm/PlainAssemblyParser.cpp
@@ -28,8 +28,6 @@
 
 #include <fmt/format.h>
 
-#include <sstream>
-
 using namespace std::string_literals;
 using namespace solidity;
 using namespace solidity::test;
@@ -39,16 +37,46 @@ using namespace solidity::langutil;
 
 Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _source)
 {
+	m_sourceStream = std::istringstream(_source);
 	m_sourceName = std::move(_sourceName);
-	Json codeJSON = Json::array();
-	std::istringstream sourceStream(_source);
-	while (getline(sourceStream, m_line))
+	m_lineNumber = 0;
+
+	advanceLine();
+	return parseAssembly(0);
+}
+
+Json PlainAssemblyParser::parseAssembly(size_t _nestingLevel)
+{
+	Json assemblyJSON = {{".code", Json::array()}};
+	Json& codeJSON = assemblyJSON[".code"];
+
+	while (m_line.has_value())
 	{
-		advanceLine(m_line);
 		if (m_lineTokens.empty())
+		{
+			advanceLine();
+			continue;
+		}
+
+		size_t newLevel = parseNestingLevel();
+		if (newLevel > _nestingLevel)
+			BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Indentation does not match the current subassembly nesting level.")));
+
+		if (newLevel < _nestingLevel)
+			return assemblyJSON;
+
+		if (currentToken().value == ".sub")
+		{
+			advanceLine();
+
+			std::string nextDataIndex = std::to_string(assemblyJSON[".data"].size());
+			assemblyJSON[".data"][nextDataIndex] = parseAssembly(_nestingLevel + 1);
 			continue;
+		}
+		else if (assemblyJSON.contains(".data"))
+			BOOST_THROW_EXCEPTION(std::runtime_error(formatError("The code of an assembly must be specified before its subassemblies.")));
 
-		if (c_instructions.contains(currentToken().value))
+		if (c_instructions.contains(currentToken().value) || currentToken().value == "PUSHSIZE")
 		{
 			expectNoMoreArguments();
 			codeJSON.push_back({{"name", currentToken().value}});
@@ -62,6 +90,19 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou
 				expectNoMoreArguments();
 				codeJSON.push_back({{"name", "PUSH [tag]"}, {"value", tagID}});
 			}
+			else if (hasMoreTokens() && (nextToken().value == "[$]" || nextToken().value == "#[$]"))
+			{
+				std::string pushType = std::string(nextToken().value);
+				advanceToken();
+				std::string_view subassemblyID = expectArgument();
+				expectNoMoreArguments();
+
+				if (!subassemblyID.starts_with("0x"))
+					BOOST_THROW_EXCEPTION(std::runtime_error(formatError("The subassembly ID must be a hex number prefixed with '0x'.")));
+
+				subassemblyID.remove_prefix("0x"s.size());
+				codeJSON.push_back({{"name", "PUSH " + pushType}, {"value", subassemblyID}});
+			}
 			else
 			{
 				std::string_view immediateArgument = expectArgument();
@@ -84,8 +125,24 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou
 		}
 		else
 			BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Unknown instruction.")));
+
+		advanceLine();
 	}
-	return {{".code", codeJSON}};
+
+	return assemblyJSON;
+}
+
+size_t PlainAssemblyParser::parseNestingLevel() const
+{
+	std::string_view indentationString = indentation();
+
+	if (indentationString != std::string(indentationString.size(), ' '))
+		BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Non-space characters used for indentation.")));
+
+	if (indentationString.size() % 4 != 0)
+		BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Each indentation level must consist of 4 spaces.")));
+
+	return indentationString.size() / 4;
 }
 
 PlainAssemblyParser::Token const& PlainAssemblyParser::currentToken() const
@@ -100,6 +157,16 @@ PlainAssemblyParser::Token const& PlainAssemblyParser::nextToken() const
 	return m_lineTokens[m_tokenIndex + 1];
 }
 
+std::string_view PlainAssemblyParser::indentation() const
+{
+	soltestAssert(m_line.has_value());
+
+	if (m_lineTokens.empty())
+		return *m_line;
+
+	return std::string_view(*m_line).substr(0, m_lineTokens.at(0).position);
+}
+
 bool PlainAssemblyParser::advanceToken()
 {
 	if (!hasMoreTokens())
@@ -125,12 +192,20 @@ void PlainAssemblyParser::expectNoMoreArguments()
 		BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Too many arguments.")));
 }
 
-void PlainAssemblyParser::advanceLine(std::string_view _line)
+bool PlainAssemblyParser::advanceLine()
 {
+	std::string line;
+	if (!getline(m_sourceStream, line))
+	{
+		m_line = std::nullopt;
+		return false;
+	}
+
 	++m_lineNumber;
-	m_line = _line;
-	m_lineTokens = tokenizeLine(m_line);
+	m_line = std::move(line);
+	m_lineTokens = tokenizeLine(*m_line);
 	m_tokenIndex = 0;
+	return true;
 }
 
 std::vector<PlainAssemblyParser::Token> PlainAssemblyParser::tokenizeLine(std::string_view _line)
@@ -162,6 +237,9 @@ std::vector<PlainAssemblyParser::Token> PlainAssemblyParser::tokenizeLine(std::s
 
 std::string PlainAssemblyParser::formatError(std::string_view _message) const
 {
+	soltestAssert(m_line.has_value());
+	soltestAssert(!m_lineTokens.empty());
+
 	std::string lineNumberString = std::to_string(m_lineNumber);
 	std::string padding(lineNumberString.size(), ' ');
 	std::string underline = std::string(currentToken().position, ' ') + std::string(currentToken().value.size(), '^');
@@ -174,7 +252,7 @@ std::string PlainAssemblyParser::formatError(std::string_view _message) const
 		_message,
 		padding, m_sourceName,
 		padding,
-		m_lineNumber, m_line,
+		m_lineNumber, *m_line,
 		padding, underline
 	);
 }
diff --git a/test/libevmasm/PlainAssemblyParser.h b/test/libevmasm/PlainAssemblyParser.h
@@ -20,6 +20,7 @@
 
 #include <libsolutil/JSON.h>
 
+#include <sstream>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -36,12 +37,20 @@ namespace solidity::evmasm::test
 /// - A non-empty line represents a single assembly item.
 /// - The name of the item is the first thing on the line and may consist of one or more tokens.
 /// - One or more arguments follow the name.
+/// - Indentation determines assembly nesting level (4 spaces per level).
+/// - A new subassembly starts with '.sub' and contains all subsequent lines at a higher nesting level.
+///     The first line at the same or lower nesting level ends the subassembly.
+/// - Subassemblies can be nested to arbitrary depth.
+/// - The code of an assembly must be specified before its subassemblies.
 ///
 /// Supported items:
 /// - All instruction names.
 /// - PUSH <hex value>
 /// - PUSH [tag] <tagID>
 /// - tag <tagID>
+/// - PUSH [$] <subassemblyID>
+/// - PUSH #[$] <subassemblyID>
+/// - .sub
 class PlainAssemblyParser
 {
 public:
@@ -56,24 +65,30 @@ class PlainAssemblyParser
 		size_t position;        ///< Position of the first character of the token within m_line.
 	};
 
+	Json parseAssembly(size_t _nestingLevel);
+	size_t parseNestingLevel() const;
+
 	Token const& currentToken() const;
 	Token const& nextToken() const;
 	bool hasMoreTokens() const { return m_tokenIndex + 1 < m_lineTokens.size(); }
 
+	std::string_view indentation() const;
+
 	bool advanceToken();
 	std::string_view expectArgument();
 	void expectNoMoreArguments();
-	void advanceLine(std::string_view _line);
+	bool advanceLine();
 
 	static std::vector<Token> tokenizeLine(std::string_view _line);
 	std::string formatError(std::string_view _message) const;
 
 private:
-	std::string m_sourceName;        ///< Name of the file the source comes from.
-	size_t m_lineNumber = 0;         ///< The number of the current line within the source, 1-based.
-	std::string m_line;              ///< The current line, unparsed.
-	std::vector<Token> m_lineTokens; ///< Decomposition of the current line into tokens (does not include comments).
-	size_t m_tokenIndex = 0;         ///< Points at a token within m_lineTokens.
+	std::istringstream m_sourceStream; ///< The source code being parsed.
+	std::string m_sourceName;          ///< Name of the file the source comes from.
+	size_t m_lineNumber = 0;           ///< The number of the current line within the source, 1-based.
+	std::optional<std::string> m_line; ///< The current line, unparsed.
+	std::vector<Token> m_lineTokens;   ///< Decomposition of the current line into tokens (does not include comments).
+	size_t m_tokenIndex = 0;           ///< Points at a token within m_lineTokens.
 };
 
 }
diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/empty.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/empty.asm
@@ -0,0 +1,10 @@
+// ====
+// outputs: InputAssemblyJSON,Assembly,Bytecode,Opcodes,SourceMappings
+// ----
+// InputAssemblyJSON: {
+//     ".code": []
+// }
+// Assembly:
+// Bytecode:
+// Opcodes:
+// SourceMappings:
diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/pushsize.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/pushsize.asm
@@ -0,0 +1,33 @@
+PUSHSIZE
+
+.sub
+    PUSHSIZE
+// ====
+// outputs: InputAssemblyJSON,Assembly,Bytecode,Opcodes,SourceMappings
+// ----
+// InputAssemblyJSON: {
+//     ".code": [
+//         {
+//             "name": "PUSHSIZE"
+//         }
+//     ],
+//     ".data": {
+//         "0": {
+//             ".code": [
+//                 {
+//                     "name": "PUSHSIZE"
+//                 }
+//             ]
+//         }
+//     }
+// }
+// Assembly:
+//   bytecodeSize
+// stop
+//
+// sub_0: assembly {
+//       bytecodeSize
+// }
+// Bytecode: 6003fe
+// Opcodes: PUSH1 0x3 INVALID
+// SourceMappings: :::-:0
diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/pushsubsize.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/pushsubsize.asm
@@ -0,0 +1,72 @@
+PUSH [$] 0x0000
+PUSH #[$] 0x0000
+
+.sub
+    PUSH [$] 0x0
+    PUSH #[$] 0x2
+
+    .sub
+    .sub
+    .sub
+// ====
+// outputs: InputAssemblyJSON,Assembly,Bytecode,Opcodes,SourceMappings
+// ----
+// InputAssemblyJSON: {
+//     ".code": [
+//         {
+//             "name": "PUSH [$]",
+//             "value": "0000"
+//         },
+//         {
+//             "name": "PUSH #[$]",
+//             "value": "0000"
+//         }
+//     ],
+//     ".data": {
+//         "0": {
+//             ".code": [
+//                 {
+//                     "name": "PUSH [$]",
+//                     "value": "0"
+//                 },
+//                 {
+//                     "name": "PUSH #[$]",
+//                     "value": "2"
+//                 }
+//             ],
+//             ".data": {
+//                 "0": {
+//                     ".code": []
+//                 },
+//                 "1": {
+//                     ".code": []
+//                 },
+//                 "2": {
+//                     ".code": []
+//                 }
+//             }
+//         }
+//     }
+// }
+// Assembly:
+//   dataOffset(sub_0)
+//   dataSize(sub_0)
+// stop
+//
+// sub_0: assembly {
+//       dataOffset(sub_0)
+//       dataSize(sub_2)
+//     stop
+//
+//     sub_0: assembly {
+//     }
+//
+//     sub_1: assembly {
+//     }
+//
+//     sub_2: assembly {
+//     }
+// }
+// Bytecode: 60056005fe60056000fe
+// Opcodes: PUSH1 0x5 PUSH1 0x5 INVALID PUSH1 0x5 PUSH1 0x0 INVALID
+// SourceMappings: :::-:0;
diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies.asm
diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_empty.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_empty.asm
diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_nested.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_nested.asm
