EIP-4750: EOF - Functions

CMakeLists.txt

@@ -2,7 +2,7 @@
 # Copyright 2019 The evmone Authors.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.16...3.23)
+cmake_minimum_required(VERSION 3.16...3.24)
 
 if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/evmc/.git)
     message(FATAL_ERROR "Git submodules not initialized, execute:\n  git submodule update --init")

circle.yml

@@ -1,4 +1,6 @@
 version: 2.1
+orbs:
+  win: circleci/windows@5.0
 
 executors:
   lint:
@@ -76,6 +78,12 @@ commands:
           command: |
             curl -L https://github.com/Kitware/CMake/releases/download/v<<parameters.version>>/cmake-<<parameters.version>>-linux-x86_64.tar.gz | sudo tar -xz --strip=1
 
+  checkout_submodules:
+    steps:
+      - run:
+          name: "Update submodules"
+          command: git submodule update --init --recursive
+
   build_silkworm:
     parameters:
       branch:
@@ -145,9 +153,7 @@ commands:
     description: "Build"
     steps:
       - checkout
-      - run:
-          name: "Update submodules"
-          command: git submodule update --init --recursive
+      - checkout_submodules
       - run:
           name: "Environment"
           command: |
@@ -195,6 +201,7 @@ commands:
     steps:
     - run:
         name: "Test"
+        shell: bash
         working_directory: ~/build
         command: ctest -R ${TESTS_FILTER:-'.*'} --schedule-random --output-on-failure --parallel $CMAKE_BUILD_PARALLEL_LEVEL --output-junit ~/test_results/evmone.xml
     - store_test_results:
@@ -241,8 +248,9 @@ commands:
     steps:
       - run:
           name: "Build Package"
+          shell: bash
           working_directory: ~/package
-          command: cmake --build ~/build --target package && mv ~/build/evmone*.tar.gz* .
+          command: cmake --build ~/build --target package && mv ~/build/evmone-*.* .
       - store_artifacts:
           path: ~/package
           destination: package
@@ -286,6 +294,38 @@ jobs:
       - test
       - package
 
+  release-windows:
+    executor: win/server-2022
+    environment:
+      CMAKE_BUILD_TYPE: Release
+      CMAKE_BUILD_PARALLEL_LEVEL: 4
+    steps:
+      - checkout
+      - checkout_submodules
+      - run:
+          name: "Setup environment (bash)"
+          shell: bash
+          command: |
+            echo 'export PATH=$PATH:"/c/Program Files/Microsoft Visual Studio/2022/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin"' >> $BASH_ENV
+      - run:
+          name: 'Configure'
+          shell: powershell
+          command: |
+            $ErrorActionPreference = "Stop"
+            & 'C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\Launch-VsDevShell.ps1' -Arch amd64
+            which cmake
+            cmake -S . -B ~/build -G Ninja -DCMAKE_INSTALL_PREFIX=C:\install -DEVMONE_TESTING=ON
+      - run:
+          name: 'Build'
+          shell: powershell
+          command: |
+            $ErrorActionPreference = "Stop"
+            & 'C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\Launch-VsDevShell.ps1' -Arch amd64
+            cmake --build ~/build
+      - test
+      - package
+
+
   release-macos:
     executor: macos
     environment:
@@ -350,12 +390,12 @@ jobs:
     steps:
       - build
       - download_consensus_tests:
-          rev: v11.1
+          rev: develop
       - run:
           name: "State tests"
           working_directory: ~/build
           # TODO: Some state tests are expected to fail because precompiles are not implemented.
-          command: bin/evmone-statetest ~/tests/GeneralStateTests ~/tests/LegacyTests/Constantinople/GeneralStateTests || true
+          command: EVMONE_PRECOMPILES_STUB=~/project/test/state/precompiles_stub.json bin/evmone-statetest ~/tests/GeneralStateTests ~/tests/LegacyTests/Constantinople/GeneralStateTests
       - collect_coverage_gcc
       - upload_coverage:
           flags: statetests
@@ -505,15 +545,18 @@ workflows:
           filters:
             tags:
               only: /.*/
+      - release-windows:
+          filters:
+            tags:
+              only: /.*/
       - release-macos:
           filters:
-            branches:
-              ignore: /.*/
             tags:
               only: /.*/
       - deploy:
           requires:
             - release-linux
+            - release-windows
             - release-macos
           filters:
             branches:

cmake/Hunter/init.cmake

@@ -7,7 +7,7 @@ set(HUNTER_CONFIGURATION_TYPES Release CACHE STRING "Build type of Hunter packag
 include(HunterGate)
 
 HunterGate(
-    URL "https://github.com/cpp-pm/hunter/archive/v0.24.5.tar.gz"
-    SHA1 "d7279c19372938dbb14c6ed511bdcb6e938ac5df"
+    URL "https://github.com/cpp-pm/hunter/archive/v0.24.11.tar.gz"
+    SHA1 "e49fb20a135675e406e95fbe9a591a630ccbbeaf"
     LOCAL
 )

lib/evmone/CMakeLists.txt

@@ -27,6 +27,7 @@ add_library(evmone
     instructions_traits.hpp
     instructions_xmacro.hpp
     opcodes_helpers.h
+    eips.hpp
     tracing.cpp
     tracing.hpp
     vm.cpp
@@ -41,7 +42,7 @@ if(CABLE_COMPILER_GNULIKE)
     target_compile_options(
         evmone PRIVATE
         -fno-exceptions
-        $<$<CXX_COMPILER_ID:GNU>:-Wstack-usage=2500>
+        $<$<CXX_COMPILER_ID:GNU>:-Wstack-usage=2600>
     )
     if(NOT SANITIZE MATCHES undefined)
         # RTTI can be disabled except for UBSan which checks vptr integrity.

lib/evmone/advanced_execution.cpp

@@ -35,8 +35,9 @@ evmc_result execute(evmc_vm* /*unused*/, const evmc_host_interface* host, evmc_h
     {
         if (rev >= EVMC_SHANGHAI)
         {
-            const auto eof1_header = read_valid_eof1_header(container.begin());
-            analysis = analyze(rev, {&container[eof1_header.code_begin()], eof1_header.code_size});
+            const auto eof1_header = read_valid_eof1_header(container);
+            analysis =
+                analyze(rev, {&container[eof1_header.code_begin(0)], eof1_header.code_sizes[0]});
         }
         else
             // Skip analysis, because it will recognize 01 section id as OP_ADD and return

lib/evmone/advanced_instructions.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "advanced_analysis.hpp"
+#include "eips.hpp"
 #include "instructions.hpp"
 #include "instructions_traits.hpp"
 
@@ -216,7 +217,6 @@ const Instruction* op_undefined(const Instruction*, AdvancedExecutionState& stat
     return state.exit(EVMC_UNDEFINED_INSTRUCTION);
 }
 
-
 constexpr std::array<instruction_exec_fn, 256> instruction_implementations = []() noexcept {
     std::array<instruction_exec_fn, 256> table{};
 
@@ -245,12 +245,22 @@ constexpr std::array<instruction_exec_fn, 256> instruction_implementations = [](
     table[OP_CREATE2] = op_create<OP_CREATE2>;
     table[OP_STATICCALL] = op_call<OP_STATICCALL>;
 
+    table[OP_RJUMP] = op_undefined;
+    table[OP_RJUMPI] = op_undefined;
+    table[OP_RJUMPV] = op_undefined;
+    table[OP_CALLF] = op_undefined;
+    table[OP_RETF] = op_undefined;
+
+    table[OP_DUPN] = op_undefined;
+    table[OP_SWAPN] = op_undefined;
+
     return table;
 }();
 }  // namespace
 
 EVMC_EXPORT const OpTable& get_op_table(evmc_revision rev) noexcept
 {
+    rev = clear_eips(rev);
     static constexpr auto op_tables = []() noexcept {
         std::array<OpTable, EVMC_MAX_REVISION + 1> tables{};
         for (size_t r = EVMC_FRONTIER; r <= EVMC_MAX_REVISION; ++r)

lib/evmone/baseline.cpp

@@ -69,8 +69,19 @@ CodeAnalysis analyze_legacy(bytes_view code)
 
 CodeAnalysis analyze_eof1(bytes_view eof_container, const EOF1Header& header)
 {
-    const auto executable_code = eof_container.substr(header.code_begin(), header.code_size);
-    return {executable_code, analyze_jumpdests(executable_code)};
+    auto beg = header.code_begin(0);
+    auto end = header.code_end(header.code_sizes.size() - 1);
+    const auto executable_code = eof_container.substr(beg, end - beg);
+
+    const auto o = header.code_offsets[0];
+    std::vector<uint16_t> offs;
+    for (auto x : header.code_offsets)
+        offs.push_back(x - o);
+
+    // FIXME: Better way of getting EOF version.
+    auto a = CodeAnalysis{executable_code, analyze_jumpdests(executable_code), eof_container[2]};
+    a.code_offsets = std::move(offs);
+    return a;
 }
 }  // namespace
 
@@ -79,7 +90,7 @@ CodeAnalysis analyze(evmc_revision rev, bytes_view code)
     if (rev < EVMC_SHANGHAI || !is_eof_code(code))
         return analyze_legacy(code);
 
-    const auto eof1_header = read_valid_eof1_header(code.begin());
+    const auto eof1_header = read_valid_eof1_header(code);
     return analyze_eof1(code, eof1_header);
 }
 
@@ -321,7 +332,7 @@ evmc_result execute(const VM& vm, ExecutionState& state, const CodeAnalysis& ana
 
     const auto code = analysis.executable_code;
 
-    const auto& cost_table = get_baseline_cost_table(state.rev);
+    const auto& cost_table = get_baseline_cost_table(state.rev, analysis.eof_version);
 
     auto* tracer = vm.get_tracer();
     if (INTX_UNLIKELY(tracer != nullptr))
@@ -356,6 +367,18 @@ evmc_result execute(const VM& vm, ExecutionState& state, const CodeAnalysis& ana
 evmc_result execute(evmc_vm* c_vm, const evmc_host_interface* host, evmc_host_context* ctx,
     evmc_revision rev, const evmc_message* msg, const uint8_t* code, size_t code_size) noexcept
 {
+    if (rev >= EVMC_SHANGHAI && is_eof_code({code, code_size}))
+    {
+        // TODO(EOF): The initcode must be validated. Doing this just before execution is
+        //   good because validation can be combined with analysis/loading. But consider also
+        //   other places like create instructions.
+        if (validate_eof(rev, {code, code_size}) != EOFValidationError::success)
+        {
+            // TODO(EOF): This should never happen but protects against invalid tests for now.
+            return evmc::Result{EVMC_INTERNAL_ERROR}.release_raw();
+        }
+    }
+
     auto vm = static_cast<VM*>(c_vm);
     const auto jumpdest_map = analyze(rev, {code, code_size});
     auto state =

lib/evmone/baseline.hpp

@@ -25,6 +25,8 @@ class CodeAnalysis
 
     bytes_view executable_code;  ///< Executable code section.
     JumpdestMap jumpdest_map;    ///< Map of valid jump destinations.
+    uint8_t eof_version = 0;     ///< The EOF version, 0 means legacy code.
+    std::vector<uint16_t> code_offsets;
 
 private:
     /// Padded code for faster legacy code execution.
@@ -38,8 +40,8 @@ class CodeAnalysis
         m_padded_code{std::move(padded_code)}
     {}
 
-    CodeAnalysis(bytes_view code, JumpdestMap map)
-      : executable_code{code}, jumpdest_map{std::move(map)}
+    CodeAnalysis(bytes_view code, JumpdestMap map, uint8_t eof_ver)
+      : executable_code{code}, jumpdest_map{std::move(map)}, eof_version{eof_ver}
     {}
 };
 static_assert(std::is_move_constructible_v<CodeAnalysis>);

lib/evmone/baseline_instruction_table.cpp

@@ -3,25 +3,49 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "baseline_instruction_table.hpp"
+#include "eips.hpp"
 #include "instructions_traits.hpp"
 
 namespace evmone::baseline
 {
-const CostTable& get_baseline_cost_table(evmc_revision rev) noexcept
+namespace
 {
-    static constexpr auto cost_tables = []() noexcept {
-        std::array<CostTable, EVMC_MAX_REVISION + 1> tables{};
-        for (size_t r = EVMC_FRONTIER; r <= EVMC_MAX_REVISION; ++r)
+constexpr auto common_cost_tables = []() noexcept {
+    std::array<CostTable, EVMC_MAX_REVISION + 1> tables{};
+    for (size_t r = EVMC_FRONTIER; r <= EVMC_MAX_REVISION; ++r)
+    {
+        auto& table = tables[r];
+        for (size_t i = 0; i < table.size(); ++i)
         {
-            auto& table = tables[r];
-            for (size_t i = 0; i < table.size(); ++i)
-            {
-                table[i] = instr::gas_costs[r][i];  // Include instr::undefined in the table.
-            }
+            table[i] = instr::gas_costs[r][i];  // Include instr::undefined in the table.
         }
-        return tables;
-    }();
+    }
+    return tables;
+}();
 
-    return cost_tables[rev];
+constexpr auto legacy_cost_tables = []() noexcept {
+    auto tables = common_cost_tables;
+    tables[EVMC_SHANGHAI][OP_RJUMP] = instr::undefined;
+    tables[EVMC_SHANGHAI][OP_RJUMPI] = instr::undefined;
+    return tables;
+}();
+
+constexpr auto eof_cost_tables = []() noexcept {
+    auto tables = common_cost_tables;
+    tables[EVMC_SHANGHAI][OP_JUMP] = instr::undefined;
+    tables[EVMC_SHANGHAI][OP_JUMPI] = instr::undefined;
+    tables[EVMC_SHANGHAI][OP_PC] = instr::undefined;
+    tables[EVMC_SHANGHAI][OP_CALLCODE] = instr::undefined;
+    tables[EVMC_SHANGHAI][OP_SELFDESTRUCT] = instr::undefined;
+    return tables;
+}();
+
+}  // namespace
+
+const CostTable& get_baseline_cost_table(evmc_revision rev, uint8_t eof_version) noexcept
+{
+    rev = clear_eips(rev);
+    const auto& tables = (eof_version == 0) ? legacy_cost_tables : eof_cost_tables;
+    return tables[rev];
 }
 }  // namespace evmone::baseline

lib/evmone/baseline_instruction_table.hpp

@@ -10,5 +10,7 @@ namespace evmone::baseline
 {
 using CostTable = std::array<int16_t, 256>;
 
-const CostTable& get_baseline_cost_table(evmc_revision rev) noexcept;
+const CostTable& get_baseline_cost_table(evmc_revision rev, uint8_t eof_version) noexcept;
+
+const CostTable& get_baseline_legacy_cost_table(evmc_revision rev) noexcept;
 }  // namespace evmone::baseline