Merge branch 'master' into overflow

Author: pdobacz

.clang-tidy

@@ -1,70 +1,70 @@
 FormatStyle: file
 HeaderFilterRegex: 'lib/evmone/|test/state/'
 WarningsAsErrors: '*'
-Checks: >
-  bugprone-*,
-  -bugprone-assignment-in-if-condition,
-  -bugprone-easily-swappable-parameters,
-  -bugprone-implicit-widening-of-multiplication-result,
-  -bugprone-unchecked-optional-access,
-  cert-dcl21-cpp,
-  cert-dcl50-cpp,
-  cert-dcl58-cpp,
-  cert-env33-c,
-  cert-err33-c,
-  cert-err34-c,
-  cert-err52-cpp,
-  cert-err60-cpp,
-  cert-flp30-c,
-  cert-mem57-cpp,
-  cert-msc50-cpp,
-  cert-msc51-cpp,
-  cert-oop57-cpp,
-  cert-oop58-cpp,
-  clang-analyzer-*,
-  cppcoreguidelines-*,
-  -cppcoreguidelines-avoid-c-arrays,
-  -cppcoreguidelines-avoid-const-or-ref-data-members,
-  -cppcoreguidelines-avoid-goto,
-  -cppcoreguidelines-avoid-magic-numbers,
-  -cppcoreguidelines-avoid-non-const-global-variables,
-  -cppcoreguidelines-macro-usage,
-  -cppcoreguidelines-no-malloc,
-  -cppcoreguidelines-non-private-member-variables-in-classes,
-  -cppcoreguidelines-owning-memory,
-  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-  -cppcoreguidelines-pro-bounds-constant-array-index,
-  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
-  -cppcoreguidelines-pro-type-reinterpret-cast,
-  -cppcoreguidelines-pro-type-static-cast-downcast,
-  -cppcoreguidelines-pro-type-union-access,
-  -cppcoreguidelines-pro-type-vararg,
-  -cppcoreguidelines-special-member-functions,
-  google-global-names-in-headers,
-  google-runtime-int,
-  hicpp-exception-baseclass,
-  hicpp-multiway-paths-covered,
-  hicpp-no-assembler,
-  misc-*,
-  -misc-include-cleaner,
-  -misc-non-private-member-variables-in-classes,
-  -misc-use-anonymous-namespace,
-  modernize-*,
-  -modernize-avoid-c-arrays,
-  -modernize-use-trailing-return-type,
-  performance-*,
-  -performance-enum-size,
-  portability-*,
-  readability-*,
-  -readability-braces-around-statements,
-  -readability-else-after-return,
-  -readability-function-cognitive-complexity,
-  -readability-function-size,
-  -readability-identifier-length,
-  -readability-magic-numbers,
-  -readability-named-parameter,
-  -readability-qualified-auto,
-  -readability-uppercase-literal-suffix,
+Checks:
+  - "bugprone-*"
+  - "-bugprone-assignment-in-if-condition"
+  - "-bugprone-easily-swappable-parameters"
+  - "-bugprone-implicit-widening-of-multiplication-result"
+  - "-bugprone-unchecked-optional-access"
+  - "cert-dcl21-cpp"
+  - "cert-dcl50-cpp"
+  - "cert-dcl58-cpp"
+  - "cert-env33-c"
+  - "cert-err33-c"
+  - "cert-err34-c"
+  - "cert-err52-cpp"
+  - "cert-err60-cpp"
+  - "cert-flp30-c"
+  - "cert-mem57-cpp"
+  - "cert-msc50-cpp"
+  - "cert-msc51-cpp"
+  - "cert-oop57-cpp"
+  - "cert-oop58-cpp"
+  - "clang-analyzer-*"
+  - "cppcoreguidelines-*"
+  - "-cppcoreguidelines-avoid-c-arrays"
+  - "-cppcoreguidelines-avoid-const-or-ref-data-members"
+  - "-cppcoreguidelines-avoid-goto"
+  - "-cppcoreguidelines-avoid-magic-numbers"
+  - "-cppcoreguidelines-avoid-non-const-global-variables"
+  - "-cppcoreguidelines-macro-usage"
+  - "-cppcoreguidelines-no-malloc"
+  - "-cppcoreguidelines-non-private-member-variables-in-classes"
+  - "-cppcoreguidelines-owning-memory"
+  - "-cppcoreguidelines-pro-bounds-array-to-pointer-decay"
+  - "-cppcoreguidelines-pro-bounds-constant-array-index"
+  - "-cppcoreguidelines-pro-bounds-pointer-arithmetic"
+  - "-cppcoreguidelines-pro-type-reinterpret-cast"
+  - "-cppcoreguidelines-pro-type-static-cast-downcast"
+  - "-cppcoreguidelines-pro-type-union-access"
+  - "-cppcoreguidelines-pro-type-vararg"
+  - "-cppcoreguidelines-special-member-functions"
+  - "google-global-names-in-headers"
+  - "google-runtime-int"
+  - "hicpp-exception-baseclass"
+  - "hicpp-multiway-paths-covered"
+  - "hicpp-no-assembler"
+  - "misc-*"
+  - "-misc-include-cleaner"
+  - "-misc-non-private-member-variables-in-classes"
+  - "-misc-use-anonymous-namespace"
+  - "modernize-*"
+  - "-modernize-avoid-c-arrays"
+  - "-modernize-use-trailing-return-type"
+  - "performance-*"
+  - "-performance-enum-size"
+  - "portability-*"
+  - "readability-*"
+  - "-readability-braces-around-statements"
+  - "-readability-else-after-return"
+  - "-readability-function-cognitive-complexity"
+  - "-readability-function-size"
+  - "-readability-identifier-length"
+  - "-readability-magic-numbers"
+  - "-readability-named-parameter"
+  - "-readability-qualified-auto"
+  - "-readability-uppercase-literal-suffix"
 
 CheckOptions:
   readability-identifier-naming.ClassCase: CamelCase

evmc

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "execution_state.hpp"
+#include "instructions.hpp"
 #include "instructions_opcodes.hpp"
 #include <evmc/evmc.hpp>
 #include <evmc/utils.h>
@@ -30,74 +31,38 @@ struct BlockInfo
 };
 static_assert(sizeof(BlockInfo) == 8);
 
-/// The view/controller for EVM stack.
-class Stack
-{
-public:
-    /// The pointer to the top item.
-    /// This is never null.
-    uint256* top_item = nullptr;
-
-private:
-    /// The pointer to the stack space "bottom".
-    uint256* m_bottom = nullptr;
-
-public:
-    /// Init with the provided stack space.
-    explicit Stack(uint256* stack_space_bottom) noexcept { reset(stack_space_bottom); }
-
-    /// The current number of items on the stack.
-    [[nodiscard]] int size() const noexcept { return static_cast<int>(top_item - m_bottom); }
-
-    /// Returns the reference to the top item.
-    // NOLINTNEXTLINE(readability-make-member-function-const)
-    [[nodiscard]] uint256& top() noexcept { return *top_item; }
-
-    /// Returns the reference to the stack item on given position from the stack top.
-    // NOLINTNEXTLINE(readability-make-member-function-const)
-    [[nodiscard]] uint256& operator[](int index) noexcept { return *(top_item - index); }
-
-    /// Returns the const reference to the stack item on given position from the stack top.
-    [[nodiscard]] const uint256& operator[](int index) const noexcept
-    {
-        return *(top_item - index);
-    }
-
-    /// Pushes an item on the stack. The stack limit is not checked.
-    void push(const uint256& item) noexcept { *++top_item = item; }
-
-    /// Returns an item popped from the top of the stack.
-    uint256 pop() noexcept { return *top_item--; }
-
-    /// Empties the stack by resetting the top item pointer to the new provided stack space.
-    void reset(uint256* stack_space_bottom) noexcept
-    {
-        m_bottom = stack_space_bottom;
-        top_item = m_bottom;
-    }
-};
 
 /// The execution state specialized for the Advanced interpreter.
 struct AdvancedExecutionState : ExecutionState
 {
     int64_t gas_left = 0;
-    Stack stack;
+
+    /// Pointer to the stack top.
+    StackTop stack = stack_space.bottom();
 
     /// The gas cost of the current block.
     ///
     /// This is only needed to correctly calculate the "current gas left" value.
     uint32_t current_block_cost = 0;
 
-    AdvancedExecutionState() noexcept : stack{stack_space.bottom()} {}
+    AdvancedExecutionState() noexcept = default;
 
     AdvancedExecutionState(const evmc_message& message, evmc_revision revision,
         const evmc_host_interface& host_interface, evmc_host_context* host_ctx, bytes_view _code,
         bytes_view _data) noexcept
       : ExecutionState{message, revision, host_interface, host_ctx, _code, _data},
-        gas_left{message.gas},
-        stack{stack_space.bottom()}
+        gas_left{message.gas}
     {}
 
+    /// Computes the current EVM stack height.
+    [[nodiscard]] int stack_size() noexcept
+    {
+        return static_cast<int>((&stack.top() - stack_space.bottom()));
+    }
+
+    /// Adjust the EVM stack height by given change.
+    void adjust_stack_size(int change) noexcept { stack = &stack.top() + change; }
+
     /// Terminates the execution with the given status code.
     const Instruction* exit(evmc_status_code status_code) noexcept
     {
@@ -112,7 +77,7 @@ struct AdvancedExecutionState : ExecutionState
     {
         ExecutionState::reset(message, revision, host_interface, host_ctx, _code, _data);
         gas_left = message.gas;
-        stack.reset(stack_space.bottom());
+        stack = stack_space.bottom();
         analysis.advanced = nullptr;  // For consistency with previous behavior.
         current_block_cost = 0;
     }

lib/evmone/advanced_analysis.hpp

@@ -17,40 +17,40 @@ using namespace evmone::instr;
 template <Opcode Op, void CoreFn(StackTop) noexcept = core::impl<Op>>
 inline void impl(AdvancedExecutionState& state) noexcept
 {
-    CoreFn(state.stack.top_item);
-    state.stack.top_item += instr::traits[Op].stack_height_change;
+    CoreFn(state.stack);
+    state.adjust_stack_size(instr::traits[Op].stack_height_change);
 }
 
 template <Opcode Op, void CoreFn(StackTop, ExecutionState&) noexcept = core::impl<Op>>
 inline void impl(AdvancedExecutionState& state) noexcept
 {
-    CoreFn(state.stack.top_item, state);
-    state.stack.top_item += instr::traits[Op].stack_height_change;
+    CoreFn(state.stack, state);
+    state.adjust_stack_size(instr::traits[Op].stack_height_change);
 }
 
 template <Opcode Op, evmc_status_code CoreFn(StackTop, ExecutionState&) noexcept = core::impl<Op>>
 inline evmc_status_code impl(AdvancedExecutionState& state) noexcept
 {
-    const auto status = CoreFn(state.stack.top_item, state);
-    state.stack.top_item += instr::traits[Op].stack_height_change;
+    const auto status = CoreFn(state.stack, state);
+    state.adjust_stack_size(instr::traits[Op].stack_height_change);
     return status;
 }
 
 template <Opcode Op,
     evmc_status_code CoreFn(StackTop, int64_t&, ExecutionState&) noexcept = core::impl<Op>>
 inline evmc_status_code impl(AdvancedExecutionState& state) noexcept
 {
-    const auto status = CoreFn(state.stack.top_item, state.gas_left, state);
-    state.stack.top_item += instr::traits[Op].stack_height_change;
+    const auto status = CoreFn(state.stack, state.gas_left, state);
+    state.adjust_stack_size(instr::traits[Op].stack_height_change);
     return status;
 }
 
 template <Opcode Op, Result CoreFn(StackTop, int64_t, ExecutionState&) noexcept = core::impl<Op>>
 inline evmc_status_code impl(AdvancedExecutionState& state) noexcept
 {
-    const auto status = CoreFn(state.stack.top_item, state.gas_left, state);
+    const auto status = CoreFn(state.stack, state.gas_left, state);
     state.gas_left = status.gas_left;
-    state.stack.top_item += instr::traits[Op].stack_height_change;
+    state.adjust_stack_size(instr::traits[Op].stack_height_change);
     return status.status;
 }
 
@@ -59,39 +59,39 @@ template <Opcode Op,
 inline TermResult impl(AdvancedExecutionState& state) noexcept
 {
     // Stack height adjustment may be omitted.
-    return CoreFn(state.stack.top_item, state.gas_left, state);
+    return CoreFn(state.stack, state.gas_left, state);
 }
 
 template <Opcode Op,
     Result CoreFn(StackTop, int64_t, ExecutionState&, code_iterator&) noexcept = core::impl<Op>>
 inline Result impl(AdvancedExecutionState& state, code_iterator pos) noexcept
 {
     // Stack height adjustment may be omitted.
-    return CoreFn(state.stack.top_item, state.gas_left, state, pos);
+    return CoreFn(state.stack, state.gas_left, state, pos);
 }
 
 template <Opcode Op,
     TermResult CoreFn(StackTop, int64_t, ExecutionState&, code_iterator) noexcept = core::impl<Op>>
 inline TermResult impl(AdvancedExecutionState& state, code_iterator pos) noexcept
 {
     // Stack height adjustment may be omitted.
-    return CoreFn(state.stack.top_item, state.gas_left, state, pos);
+    return CoreFn(state.stack, state.gas_left, state, pos);
 }
 
 template <Opcode Op,
     code_iterator CoreFn(StackTop, ExecutionState&, code_iterator) noexcept = core::impl<Op>>
 inline code_iterator impl(AdvancedExecutionState& state, code_iterator pos) noexcept
 {
-    const auto new_pos = CoreFn(state.stack.top_item, state, pos);
-    state.stack.top_item += instr::traits[Op].stack_height_change;
+    const auto new_pos = CoreFn(state.stack, state, pos);
+    state.adjust_stack_size(instr::traits[Op].stack_height_change);
     return new_pos;
 }
 
 template <Opcode Op, code_iterator CoreFn(StackTop, code_iterator) noexcept = core::impl<Op>>
 inline code_iterator impl(AdvancedExecutionState& state, code_iterator pos) noexcept
 {
-    const auto new_pos = CoreFn(state.stack.top_item, pos);
-    state.stack.top_item += instr::traits[Op].stack_height_change;
+    const auto new_pos = CoreFn(state.stack, pos);
+    state.adjust_stack_size(instr::traits[Op].stack_height_change);
     return new_pos;
 }
 /// @}
@@ -163,10 +163,9 @@ const Instruction* opx_beginblock(const Instruction* instr, AdvancedExecutionSta
     if ((state.gas_left -= block.gas_cost) < 0)
         return state.exit(EVMC_OUT_OF_GAS);
 
-    if (static_cast<int>(state.stack.size()) < block.stack_req)
+    if (const auto stack_size = state.stack_size(); stack_size < block.stack_req)
         return state.exit(EVMC_STACK_UNDERFLOW);
-
-    if (static_cast<int>(state.stack.size()) + block.stack_max_growth > StackSpace::limit)
+    else if (stack_size + block.stack_max_growth > StackSpace::limit)
         return state.exit(EVMC_STACK_OVERFLOW);
 
     state.current_block_cost = block.gas_cost;
@@ -189,12 +188,12 @@ const Instruction* op_jumpi(const Instruction* instr, AdvancedExecutionState& st
     if (state.stack[1] != 0)
     {
         instr = op_jump(instr, state);  // target
-        state.stack.pop();              // condition
+        (void)state.stack.pop();        // condition
     }
     else
     {
-        state.stack.pop();                     // target
-        state.stack.pop();                     // condition
+        (void)state.stack.pop();               // target
+        (void)state.stack.pop();               // condition
         instr = opx_beginblock(instr, state);  // follow-by block
     }
     return instr;

lib/evmone/advanced_instructions.cpp

@@ -7,13 +7,11 @@
 #include <evmc/evmc.h>
 #include <evmc/utils.h>
 #include <memory>
-#include <string_view>
 #include <vector>
 
 namespace evmone
 {
-using bytes_view = std::basic_string_view<uint8_t>;
-
+using evmc::bytes_view;
 class ExecutionState;
 class VM;