From 2e41aa485112e9ab77dd62d8760d8f961bd2d772 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Fri, 25 Apr 2025 06:10:31 +0200 Subject: [PATCH 1/4] PlainAssemblyParser: Store the stream globally in the class --- test/libevmasm/PlainAssemblyParser.cpp | 37 +++++++++++++++++++------- test/libevmasm/PlainAssemblyParser.h | 14 +++++----- 2 files changed, 35 insertions(+), 16 deletions(-) diff --git a/test/libevmasm/PlainAssemblyParser.cpp b/test/libevmasm/PlainAssemblyParser.cpp index 0fb9d62c8c10..4d09043b1623 100644 --- a/test/libevmasm/PlainAssemblyParser.cpp +++ b/test/libevmasm/PlainAssemblyParser.cpp @@ -28,8 +28,6 @@ #include -#include - using namespace std::string_literals; using namespace solidity; using namespace solidity::test; @@ -39,15 +37,21 @@ 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; + + if (!m_line.has_value()) + advanceLine(); + + while (m_line.has_value()) { - advanceLine(m_line); if (m_lineTokens.empty()) + { + advanceLine(); continue; - + } if (c_instructions.contains(currentToken().value)) { expectNoMoreArguments(); @@ -84,6 +88,8 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou } else BOOST_THROW_EXCEPTION(std::runtime_error(formatError("Unknown instruction."))); + + advanceLine(); } return {{".code", codeJSON}}; } @@ -125,12 +131,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::tokenizeLine(std::string_view _line) @@ -162,6 +176,9 @@ std::vector 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 +191,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 index 0154af5f7f19..95cc3ee8f84e 100644 --- a/test/libevmasm/PlainAssemblyParser.h +++ b/test/libevmasm/PlainAssemblyParser.h @@ -20,6 +20,7 @@ #include +#include #include #include #include @@ -63,17 +64,18 @@ class PlainAssemblyParser bool advanceToken(); std::string_view expectArgument(); void expectNoMoreArguments(); - void advanceLine(std::string_view _line); + bool advanceLine(); static std::vector 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 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 m_line; ///< The current line, unparsed. + std::vector 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. }; } From ccd62b2bd456938a08dd53308fcd4de73fa76118 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Fri, 25 Apr 2025 06:17:46 +0200 Subject: [PATCH 2/4] PlainAssemblyParser: Syntax for subassemblies --- test/libevmasm/PlainAssemblyParser.cpp | 56 +++++- test/libevmasm/PlainAssemblyParser.h | 11 ++ .../isoltestTesting/empty.asm | 10 + .../isoltestTesting/subassemblies.asm | 69 +++++++ .../isoltestTesting/subassemblies_empty.asm | 34 ++++ .../isoltestTesting/subassemblies_nested.asm | 171 ++++++++++++++++++ 6 files changed, 347 insertions(+), 4 deletions(-) create mode 100644 test/libevmasm/evmAssemblyTests/isoltestTesting/empty.asm create mode 100644 test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies.asm create mode 100644 test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_empty.asm create mode 100644 test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_nested.asm diff --git a/test/libevmasm/PlainAssemblyParser.cpp b/test/libevmasm/PlainAssemblyParser.cpp index 4d09043b1623..c8fbfeaeb451 100644 --- a/test/libevmasm/PlainAssemblyParser.cpp +++ b/test/libevmasm/PlainAssemblyParser.cpp @@ -39,11 +39,16 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou { m_sourceStream = std::istringstream(_source); m_sourceName = std::move(_sourceName); - Json codeJSON = Json::array(); m_lineNumber = 0; - if (!m_line.has_value()) - advanceLine(); + advanceLine(); + return parseAssembly(0); +} + +Json PlainAssemblyParser::parseAssembly(size_t _nestingLevel) +{ + Json assemblyJSON = {{".code", Json::array()}}; + Json& codeJSON = assemblyJSON[".code"]; while (m_line.has_value()) { @@ -52,6 +57,25 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou 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)) { expectNoMoreArguments(); @@ -91,7 +115,21 @@ Json PlainAssemblyParser::parse(std::string _sourceName, std::string const& _sou 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 @@ -106,6 +144,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()) diff --git a/test/libevmasm/PlainAssemblyParser.h b/test/libevmasm/PlainAssemblyParser.h index 95cc3ee8f84e..5332b3202f7b 100644 --- a/test/libevmasm/PlainAssemblyParser.h +++ b/test/libevmasm/PlainAssemblyParser.h @@ -37,12 +37,18 @@ 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 /// - PUSH [tag] /// - tag +/// - .sub class PlainAssemblyParser { public: @@ -57,10 +63,15 @@ 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(); diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/empty.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/empty.asm new file mode 100644 index 000000000000..a3c0ef5396a1 --- /dev/null +++ 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/subassemblies.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies.asm new file mode 100644 index 000000000000..7dc1a515067d --- /dev/null +++ b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies.asm @@ -0,0 +1,69 @@ +PUSH 0x2 +DUP1 +ADD + +.sub + PUSH 0x42 + DUP1 + MUL + +.sub + STOP +// ==== +// outputs: InputAssemblyJSON,Assembly,Bytecode,Opcodes,SourceMappings +// ---- +// InputAssemblyJSON: { +// ".code": [ +// { +// "name": "PUSH", +// "value": "2" +// }, +// { +// "name": "DUP1" +// }, +// { +// "name": "ADD" +// } +// ], +// ".data": { +// "0": { +// ".code": [ +// { +// "name": "PUSH", +// "value": "42" +// }, +// { +// "name": "DUP1" +// }, +// { +// "name": "MUL" +// } +// ] +// }, +// "1": { +// ".code": [ +// { +// "name": "STOP" +// } +// ] +// } +// } +// } +// Assembly: +// 0x02 +// dup1 +// add +// stop +// +// sub_0: assembly { +// 0x42 +// dup1 +// mul +// } +// +// sub_1: assembly { +// stop +// } +// Bytecode: 60028001fe +// Opcodes: PUSH1 0x2 DUP1 ADD INVALID +// SourceMappings: :::-:0;; diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_empty.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_empty.asm new file mode 100644 index 000000000000..8914710dbf34 --- /dev/null +++ b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_empty.asm @@ -0,0 +1,34 @@ +.sub +.sub +.sub +// ==== +// outputs: InputAssemblyJSON,Assembly,Bytecode,Opcodes,SourceMappings +// ---- +// InputAssemblyJSON: { +// ".code": [], +// ".data": { +// "0": { +// ".code": [] +// }, +// "1": { +// ".code": [] +// }, +// "2": { +// ".code": [] +// } +// } +// } +// Assembly: +// stop +// +// sub_0: assembly { +// } +// +// sub_1: assembly { +// } +// +// sub_2: assembly { +// } +// Bytecode: fe +// Opcodes: INVALID +// SourceMappings: diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_nested.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_nested.asm new file mode 100644 index 000000000000..59beb9b69ece --- /dev/null +++ b/test/libevmasm/evmAssemblyTests/isoltestTesting/subassemblies_nested.asm @@ -0,0 +1,171 @@ +TIMESTAMP +TIMESTAMP + +.sub + TIMESTAMP + + .sub + TIMESTAMP + .sub + TIMESTAMP + .sub + TIMESTAMP + .sub + TIMESTAMP + .sub + TIMESTAMP +.sub + NUMBER + SLOAD + .sub + NUMBER + MLOAD + .sub + NUMBER + TLOAD + +// ==== +// outputs: InputAssemblyJSON,Assembly,Bytecode,Opcodes,SourceMappings +// ---- +// InputAssemblyJSON: { +// ".code": [ +// { +// "name": "TIMESTAMP" +// }, +// { +// "name": "TIMESTAMP" +// } +// ], +// ".data": { +// "0": { +// ".code": [ +// { +// "name": "TIMESTAMP" +// } +// ], +// ".data": { +// "0": { +// ".code": [ +// { +// "name": "TIMESTAMP" +// } +// ] +// }, +// "1": { +// ".code": [ +// { +// "name": "TIMESTAMP" +// } +// ], +// ".data": { +// "0": { +// ".code": [ +// { +// "name": "TIMESTAMP" +// } +// ], +// ".data": { +// "0": { +// ".code": [ +// { +// "name": "TIMESTAMP" +// } +// ] +// } +// } +// } +// } +// }, +// "2": { +// ".code": [ +// { +// "name": "TIMESTAMP" +// } +// ] +// } +// } +// }, +// "1": { +// ".code": [ +// { +// "name": "NUMBER" +// }, +// { +// "name": "SLOAD" +// } +// ], +// ".data": { +// "0": { +// ".code": [ +// { +// "name": "NUMBER" +// }, +// { +// "name": "MLOAD" +// } +// ], +// ".data": { +// "0": { +// ".code": [ +// { +// "name": "NUMBER" +// }, +// { +// "name": "TLOAD" +// } +// ] +// } +// } +// } +// } +// } +// } +// } +// Assembly: +// timestamp +// timestamp +// stop +// +// sub_0: assembly { +// timestamp +// stop +// +// sub_0: assembly { +// timestamp +// } +// +// sub_1: assembly { +// timestamp +// stop +// +// sub_0: assembly { +// timestamp +// stop +// +// sub_0: assembly { +// timestamp +// } +// } +// } +// +// sub_2: assembly { +// timestamp +// } +// } +// +// sub_1: assembly { +// sload(number) +// stop +// +// sub_0: assembly { +// mload(number) +// stop +// +// sub_0: assembly { +// tload(number) +// } +// } +// } +// Bytecode: 4242fe +// Opcodes: TIMESTAMP TIMESTAMP INVALID +// SourceMappings: :::-:0; From 12f8750db1581d5f4203bab394fcffd91af6cbf2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Fri, 25 Apr 2025 07:58:58 +0200 Subject: [PATCH 3/4] PlainAssemblyParser: Support pushing assembly sizes and offsets --- test/libevmasm/PlainAssemblyParser.cpp | 15 +++- test/libevmasm/PlainAssemblyParser.h | 2 + .../isoltestTesting/pushsize.asm | 33 +++++++++ .../isoltestTesting/pushsubsize.asm | 72 +++++++++++++++++++ 4 files changed, 121 insertions(+), 1 deletion(-) create mode 100644 test/libevmasm/evmAssemblyTests/isoltestTesting/pushsize.asm create mode 100644 test/libevmasm/evmAssemblyTests/isoltestTesting/pushsubsize.asm diff --git a/test/libevmasm/PlainAssemblyParser.cpp b/test/libevmasm/PlainAssemblyParser.cpp index c8fbfeaeb451..07b680474cb9 100644 --- a/test/libevmasm/PlainAssemblyParser.cpp +++ b/test/libevmasm/PlainAssemblyParser.cpp @@ -76,7 +76,7 @@ Json PlainAssemblyParser::parseAssembly(size_t _nestingLevel) 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}}); @@ -90,6 +90,19 @@ Json PlainAssemblyParser::parseAssembly(size_t _nestingLevel) 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(); diff --git a/test/libevmasm/PlainAssemblyParser.h b/test/libevmasm/PlainAssemblyParser.h index 5332b3202f7b..9318d1662389 100644 --- a/test/libevmasm/PlainAssemblyParser.h +++ b/test/libevmasm/PlainAssemblyParser.h @@ -48,6 +48,8 @@ namespace solidity::evmasm::test /// - PUSH /// - PUSH [tag] /// - tag +/// - PUSH [$] +/// - PUSH #[$] /// - .sub class PlainAssemblyParser { diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/pushsize.asm b/test/libevmasm/evmAssemblyTests/isoltestTesting/pushsize.asm new file mode 100644 index 000000000000..3c92687c425a --- /dev/null +++ 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 new file mode 100644 index 000000000000..1b51c22a84ef --- /dev/null +++ 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; From 6046fbb190263fed8dff0d0fb3da928f656de148 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=9Aliwak?= Date: Sat, 26 Apr 2025 00:54:14 +0200 Subject: [PATCH 4/4] EVMAssemblyTest: Warn about custom expectedExecutionsPerDeployment having no effect --- test/libevmasm/EVMAssemblyTest.cpp | 11 +++++++++++ test/libevmasm/EVMAssemblyTest.h | 1 + 2 files changed, 12 insertions(+) diff --git a/test/libevmasm/EVMAssemblyTest.cpp b/test/libevmasm/EVMAssemblyTest.cpp index 0c1dbb07ed7c..3bc43b188294 100644 --- a/test/libevmasm/EVMAssemblyTest.cpp +++ b/test/libevmasm/EVMAssemblyTest.cpp @@ -78,10 +78,13 @@ EVMAssemblyTest::EVMAssemblyTest(std::string const& _filename): "none" ); m_optimizerSettings = Assembly::OptimiserSettings::translateSettings(OptimiserSettings::preset(optimizationPreset)); + size_t defaultExpectedExecutionsPerDeployment = m_optimizerSettings.expectedExecutionsPerDeployment; m_optimizerSettings.expectedExecutionsPerDeployment = m_reader.sizetSetting( "optimizer.expectedExecutionsPerDeployment", m_optimizerSettings.expectedExecutionsPerDeployment ); + m_usingDefaultExpectedExecutionsPerDeployment = + m_optimizerSettings.expectedExecutionsPerDeployment == defaultExpectedExecutionsPerDeployment; auto const optimizerComponentSetting = [&](std::string const& _component, bool& _setting) { _setting = m_reader.boolSetting("optimizer." + _component, _setting); @@ -132,6 +135,14 @@ TestCase::TestResult EVMAssemblyTest::run(std::ostream& _stream, std::string con return checkResult(_stream, _linePrefix, _formatted); } + soltestAssert(evmAssemblyStack.evmAssembly()); + if (!m_usingDefaultExpectedExecutionsPerDeployment && evmAssemblyStack.evmAssembly()->numSubs() == 0) + // This is a common mistake. We can't issue a warning here, so let's report it as an error. + BOOST_THROW_EXCEPTION(std::runtime_error( + "The custom value specified for optimizer.expectedExecutionsPerDeployment has no effect " + "on the creation assembly, which is the only assembly in the test." + )); + try { evmAssemblyStack.assemble(); diff --git a/test/libevmasm/EVMAssemblyTest.h b/test/libevmasm/EVMAssemblyTest.h index 9059fd716d81..9a276ddeb6b4 100644 --- a/test/libevmasm/EVMAssemblyTest.h +++ b/test/libevmasm/EVMAssemblyTest.h @@ -75,6 +75,7 @@ class EVMAssemblyTest: public frontend::test::EVMVersionRestrictedTestCase AssemblyFormat m_assemblyFormat{}; std::string m_selectedOutputs; evmasm::Assembly::OptimiserSettings m_optimizerSettings; + bool m_usingDefaultExpectedExecutionsPerDeployment{}; }; }