Merge pull request #341 from ethereum/baseline_instruction_table

baseline: Use custom instruction table

Author: chfast

lib/evmone/CMakeLists.txt

@@ -13,6 +13,8 @@ add_library(evmone
     analysis.hpp
     baseline.cpp
     baseline.hpp
+    baseline_instruction_table.cpp
+    baseline_instruction_table.hpp
     execution.cpp
     execution.hpp
     instruction_traits.hpp

lib/evmone/baseline.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "baseline.hpp"
+#include "baseline_instruction_table.hpp"
 #include "execution_state.hpp"
 #include "instructions.hpp"
 #include "vm.hpp"
@@ -84,12 +85,12 @@ inline void op_return(ExecutionState& state) noexcept
     state.status = StatusCode;
 }
 
-inline evmc_status_code check_requirements(const char* const* instruction_names,
-    const evmc_instruction_metrics* instruction_metrics, ExecutionState& state, uint8_t op) noexcept
+inline evmc_status_code check_requirements(
+    const InstructionTable& instruction_table, ExecutionState& state, uint8_t op) noexcept
 {
-    const auto metrics = instruction_metrics[op];
+    const auto metrics = instruction_table[op];
 
-    if (instruction_names[op] == nullptr)
+    if (metrics.gas_cost == instr::undefined)
         return EVMC_UNDEFINED_INSTRUCTION;
 
     if ((state.gas_left -= metrics.gas_cost) < 0)
@@ -98,7 +99,7 @@ inline evmc_status_code check_requirements(const char* const* instruction_names,
     const auto stack_size = state.stack.size();
     if (stack_size < metrics.stack_height_required)
         return EVMC_STACK_UNDERFLOW;
-    if (stack_size + metrics.stack_height_change > Stack::limit)
+    if (stack_size == Stack::limit && metrics.can_overflow_stack)
         return EVMC_STACK_OVERFLOW;
 
     return EVMC_SUCCESS;
@@ -114,8 +115,7 @@ evmc_result execute(const VM& vm, ExecutionState& state, const CodeAnalysis& ana
     if constexpr (TracingEnabled)
         tracer->notify_execution_start(state.rev, *state.msg, state.code);
 
-    const auto instruction_names = evmc_get_instruction_names_table(state.rev);
-    const auto instruction_metrics = evmc_get_instruction_metrics_table(state.rev);
+    const auto& instruction_table = get_baseline_instruction_table(state.rev);
 
     const auto* const code = state.code.data();
     auto pc = code;
@@ -129,7 +129,7 @@ evmc_result execute(const VM& vm, ExecutionState& state, const CodeAnalysis& ana
         }
 
         const auto op = *pc;
-        const auto status = check_requirements(instruction_names, instruction_metrics, state, op);
+        const auto status = check_requirements(instruction_table, state, op);
         if (status != EVMC_SUCCESS)
         {
             state.status = status;

lib/evmone/baseline_instruction_table.cpp

@@ -0,0 +1,52 @@
+// evmone: Fast Ethereum Virtual Machine implementation
+// Copyright 2020 The evmone Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+#include "baseline_instruction_table.hpp"
+#include "instruction_traits.hpp"
+#include <cassert>
+
+namespace evmone
+{
+namespace
+{
+template <evmc_revision Rev>
+constexpr InstructionTable create_instruction_table() noexcept
+{
+    InstructionTable table{};
+    for (size_t i = 0; i < table.size(); ++i)
+    {
+        auto& t = table[i];
+        const auto gas_cost = instr::gas_costs<Rev>[i];
+        t.gas_cost = gas_cost;  // Include instr::undefined in the table.
+        t.stack_height_required = instr::traits[i].stack_height_required;
+
+        // Because any instruction can increase stack height at most of 1,
+        // stack overflow can only happen if stack height is already at the limit.
+        assert(instr::traits[i].stack_height_change <= 1);
+        t.can_overflow_stack = instr::traits[i].stack_height_change > 0;
+    }
+    return table;
+}
+
+constexpr InstructionTable instruction_tables[] = {
+    create_instruction_table<EVMC_FRONTIER>(),
+    create_instruction_table<EVMC_HOMESTEAD>(),
+    create_instruction_table<EVMC_TANGERINE_WHISTLE>(),
+    create_instruction_table<EVMC_SPURIOUS_DRAGON>(),
+    create_instruction_table<EVMC_BYZANTIUM>(),
+    create_instruction_table<EVMC_CONSTANTINOPLE>(),
+    create_instruction_table<EVMC_PETERSBURG>(),
+    create_instruction_table<EVMC_ISTANBUL>(),
+    create_instruction_table<EVMC_BERLIN>(),
+    create_instruction_table<EVMC_LONDON>(),
+};
+static_assert(std::size(instruction_tables) == EVMC_MAX_REVISION + 1,
+    "instruction table entry missing for an EVMC revision");
+}  // namespace
+
+const InstructionTable& get_baseline_instruction_table(evmc_revision rev) noexcept
+{
+    return instruction_tables[rev];
+}
+}  // namespace evmone

lib/evmone/baseline_instruction_table.hpp

@@ -0,0 +1,21 @@
+// evmone: Fast Ethereum Virtual Machine implementation
+// Copyright 2020 The evmone Authors.
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <evmc/evmc.h>
+#include <array>
+
+namespace evmone
+{
+struct InstructionTableEntry
+{
+    int16_t gas_cost;
+    int8_t stack_height_required;
+    bool can_overflow_stack;
+};
+
+using InstructionTable = std::array<InstructionTableEntry, 256>;
+
+const InstructionTable& get_baseline_instruction_table(evmc_revision rev) noexcept;
+}  // namespace evmone