Remove gas_left from ExecutionState

lib/evmone/advanced_analysis.hpp

@@ -80,6 +80,7 @@ class Stack
 /// The execution state specialized for the Advanced interpreter.
 struct AdvancedExecutionState : ExecutionState
 {
+    int64_t gas_left = 0;
     Stack stack;
 
     /// The gas cost of the current block.
@@ -93,6 +94,7 @@ struct AdvancedExecutionState : ExecutionState
         const evmc_host_interface& host_interface, evmc_host_context* host_ctx,
         bytes_view _code) noexcept
       : ExecutionState{message, revision, host_interface, host_ctx, _code},
+        gas_left{message.gas},
         stack{stack_space.bottom()}
     {}
 
@@ -109,6 +111,7 @@ struct AdvancedExecutionState : ExecutionState
         bytes_view _code) noexcept
     {
         ExecutionState::reset(message, revision, host_interface, host_ctx, _code);
+        gas_left = message.gas;
         stack.reset(stack_space.bottom());
         analysis.advanced = nullptr;  // For consistency with previous behavior.
         current_block_cost = 0;

lib/evmone/baseline.cpp

@@ -223,13 +223,11 @@ template <Opcode Op>
 
 
 template <bool TracingEnabled>
-void dispatch(const CostTable& cost_table, ExecutionState& state, const uint8_t* code,
-    Tracer* tracer = nullptr) noexcept
+int64_t dispatch(const CostTable& cost_table, ExecutionState& state, int64_t gas,
+    const uint8_t* code, Tracer* tracer = nullptr) noexcept
 {
     const auto stack_bottom = state.stack_space.bottom();
 
-    auto gas = state.gas_left;
-
     // Code iterator and stack top pointer for interpreter loop.
     Position position{code, stack_bottom};
 
@@ -255,8 +253,7 @@ void dispatch(const CostTable& cost_table, ExecutionState& state, const uint8_t*
         if (const auto next = invoke<OPCODE>(cost_table, stack_bottom, position, gas, state); \
             next.code_it == nullptr)                                                          \
         {                                                                                     \
-            state.gas_left = gas;                                                             \
-            return;                                                                           \
+            return gas;                                                                       \
         }                                                                                     \
         else                                                                                  \
         {                                                                                     \
@@ -271,16 +268,15 @@ void dispatch(const CostTable& cost_table, ExecutionState& state, const uint8_t*
 
         default:
             state.status = EVMC_UNDEFINED_INSTRUCTION;
-            state.gas_left = gas;
-            return;
+            return gas;
         }
     }
     INTX_UNREACHABLE();
 }
 
 #if EVMONE_CGOTO_SUPPORTED
-void dispatch_cgoto(
-    const CostTable& cost_table, ExecutionState& state, const uint8_t* code) noexcept
+int64_t dispatch_cgoto(
+    const CostTable& cost_table, ExecutionState& state, int64_t gas, const uint8_t* code) noexcept
 {
 #pragma GCC diagnostic ignored "-Wpedantic"
 
@@ -300,17 +296,14 @@ void dispatch_cgoto(
     // Code iterator and stack top pointer for interpreter loop.
     Position position{code, stack_bottom};
 
-    auto gas = state.gas_left;
-
     goto* cgoto_table[*position.code_it];
 
 #define ON_OPCODE(OPCODE)                                                                 \
     TARGET_##OPCODE : ASM_COMMENT(OPCODE);                                                \
     if (const auto next = invoke<OPCODE>(cost_table, stack_bottom, position, gas, state); \
         next.code_it == nullptr)                                                          \
     {                                                                                     \
-        state.gas_left = gas;                                                             \
-        return;                                                                           \
+        return gas;                                                                       \
     }                                                                                     \
     else                                                                                  \
     {                                                                                     \
@@ -325,12 +318,13 @@ void dispatch_cgoto(
 
 TARGET_OP_UNDEFINED:
     state.status = EVMC_UNDEFINED_INSTRUCTION;
-    state.gas_left = gas;
+    return gas;
 }
 #endif
 }  // namespace
 
-evmc_result execute(const VM& vm, ExecutionState& state, const CodeAnalysis& analysis) noexcept
+evmc_result execute(
+    const VM& vm, int64_t gas, ExecutionState& state, const CodeAnalysis& analysis) noexcept
 {
     state.analysis.baseline = &analysis;  // Assign code analysis for instruction implementations.
 
@@ -342,20 +336,19 @@ evmc_result execute(const VM& vm, ExecutionState& state, const CodeAnalysis& ana
     if (INTX_UNLIKELY(tracer != nullptr))
     {
         tracer->notify_execution_start(state.rev, *state.msg, analysis.executable_code);
-        dispatch<true>(cost_table, state, code.data(), tracer);
+        gas = dispatch<true>(cost_table, state, gas, code.data(), tracer);
     }
     else
     {
 #if EVMONE_CGOTO_SUPPORTED
         if (vm.cgoto)
-            dispatch_cgoto(cost_table, state, code.data());
+            gas = dispatch_cgoto(cost_table, state, gas, code.data());
         else
 #endif
-            dispatch<false>(cost_table, state, code.data());
+            gas = dispatch<false>(cost_table, state, gas, code.data());
     }
 
-    const auto gas_left =
-        (state.status == EVMC_SUCCESS || state.status == EVMC_REVERT) ? state.gas_left : 0;
+    const auto gas_left = (state.status == EVMC_SUCCESS || state.status == EVMC_REVERT) ? gas : 0;
     const auto gas_refund = (state.status == EVMC_SUCCESS) ? state.gas_refund : 0;
 
     assert(state.output_size != 0 || state.output_offset == 0);
@@ -375,6 +368,6 @@ evmc_result execute(evmc_vm* c_vm, const evmc_host_interface* host, evmc_host_co
     const auto jumpdest_map = analyze(rev, {code, code_size});
     auto state =
         std::make_unique<ExecutionState>(*msg, rev, *host, ctx, bytes_view{code, code_size});
-    return execute(*vm, *state, jumpdest_map);
+    return execute(*vm, msg->gas, *state, jumpdest_map);
 }
 }  // namespace evmone::baseline

lib/evmone/baseline.hpp

@@ -58,7 +58,7 @@ evmc_result execute(evmc_vm* vm, const evmc_host_interface* host, evmc_host_cont
 
 /// Executes in Baseline interpreter on the given external and initialized state.
 EVMC_EXPORT evmc_result execute(
-    const VM&, ExecutionState& state, const CodeAnalysis& analysis) noexcept;
+    const VM&, int64_t gas_limit, ExecutionState& state, const CodeAnalysis& analysis) noexcept;
 
 }  // namespace baseline
 }  // namespace evmone

lib/evmone/execution_state.hpp

@@ -125,7 +125,6 @@ class Memory
 class ExecutionState
 {
 public:
-    int64_t gas_left = 0;
     int64_t gas_refund = 0;
     Memory memory;
     const evmc_message* msg = nullptr;
@@ -166,19 +165,14 @@ class ExecutionState
     ExecutionState(const evmc_message& message, evmc_revision revision,
         const evmc_host_interface& host_interface, evmc_host_context* host_ctx,
         bytes_view _code) noexcept
-      : gas_left{message.gas},
-        msg{&message},
-        host{host_interface, host_ctx},
-        rev{revision},
-        original_code{_code}
+      : msg{&message}, host{host_interface, host_ctx}, rev{revision}, original_code{_code}
     {}
 
     /// Resets the contents of the ExecutionState so that it could be reused.
     void reset(const evmc_message& message, evmc_revision revision,
         const evmc_host_interface& host_interface, evmc_host_context* host_ctx,
         bytes_view _code) noexcept
     {
-        gas_left = message.gas;
         gas_refund = 0;
         memory.clear();
         msg = &message;

test/bench/helpers.hpp

@@ -65,7 +65,7 @@ inline evmc::Result baseline_execute(evmc::VM& c_vm, ExecutionState& exec_state,
 {
     const auto& vm = *static_cast<evmone::VM*>(c_vm.get_raw_pointer());
     exec_state.reset(msg, rev, host.get_interface(), host.to_context(), code);
-    return evmc::Result{baseline::execute(vm, exec_state, analysis)};
+    return evmc::Result{baseline::execute(vm, msg.gas, exec_state, analysis)};
 }
 
 inline evmc::Result evmc_execute(evmc::VM& vm, FakeExecutionState& /*exec_state*/,

test/unittests/execution_state_test.cpp

@@ -28,7 +28,6 @@ TEST(execution_state, construct)
     const evmone::ExecutionState st{
         msg, EVMC_MAX_REVISION, host_interface, nullptr, {code, std::size(code)}};
 
-    EXPECT_EQ(st.gas_left, -1);
     EXPECT_EQ(st.memory.size(), 0);
     EXPECT_EQ(st.msg, &msg);
     EXPECT_EQ(st.rev, EVMC_MAX_REVISION);
@@ -42,7 +41,6 @@ TEST(execution_state, default_construct)
 {
     const evmone::ExecutionState st;
 
-    EXPECT_EQ(st.gas_left, 0);
     EXPECT_EQ(st.memory.size(), 0);
     EXPECT_EQ(st.msg, nullptr);
     EXPECT_EQ(st.rev, EVMC_FRONTIER);