Merge pull request #312 from ethereum/renames

Rename some structs

Author: chfast

lib/evmone/analysis.cpp

@@ -39,12 +39,12 @@ struct block_analysis
     }
 };
 
-code_analysis analyze(evmc_revision rev, const uint8_t* code, size_t code_size) noexcept
+AdvancedCodeAnalysis analyze(evmc_revision rev, const uint8_t* code, size_t code_size) noexcept
 {
     const auto& op_tbl = get_op_table(rev);
     const auto opx_beginblock_fn = op_tbl[OPX_BEGINBLOCK].fn;
 
-    code_analysis analysis;
+    AdvancedCodeAnalysis analysis;
 
     const auto max_instrs_size = code_size + 1;
     analysis.instrs.reserve(max_instrs_size);

lib/evmone/analysis.hpp

@@ -17,6 +17,7 @@ namespace evmone
 {
 struct instruction;
 
+/// Compressed information about instruction basic block.
 struct block_info
 {
     /// The total base gas cost of all instructions in the block.
@@ -41,23 +42,24 @@ struct block_info
 };
 static_assert(sizeof(block_info) == 8);
 
-struct code_analysis;
+struct AdvancedCodeAnalysis;
 
-struct execution_state : ExecutionState
+/// The execution state specialized for the Advanced interpreter.
+struct AdvancedExecutionState : ExecutionState
 {
     /// 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;
 
     /// Pointer to code analysis.
-    const code_analysis* analysis = nullptr;
+    const AdvancedCodeAnalysis* analysis = nullptr;
 
-    execution_state() = default;
+    AdvancedExecutionState() = default;
 
-    execution_state(const evmc_message& message, evmc_revision revision,
+    AdvancedExecutionState(const evmc_message& message, evmc_revision revision,
         const evmc_host_interface& host_interface, evmc_host_context* host_ctx,
-        const uint8_t* code_ptr, size_t code_size, const code_analysis& a) noexcept
+        const uint8_t* code_ptr, size_t code_size, const AdvancedCodeAnalysis& a) noexcept
       : ExecutionState{message, revision, host_interface, host_ctx, code_ptr, code_size},
         analysis{&a}
     {}
@@ -72,7 +74,7 @@ struct execution_state : ExecutionState
     /// Resets the contents of the execution_state 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,
-        const uint8_t* code_ptr, size_t code_size, const code_analysis& a) noexcept
+        const uint8_t* code_ptr, size_t code_size, const AdvancedCodeAnalysis& a) noexcept
     {
         ExecutionState::reset(message, revision, host_interface, host_ctx, code_ptr, code_size);
         current_block_cost = 0;
@@ -91,7 +93,7 @@ static_assert(
     sizeof(instruction_argument) == sizeof(uint64_t), "Incorrect size of instruction_argument");
 
 /// The pointer to function implementing an instruction execution.
-using instruction_exec_fn = const instruction* (*)(const instruction*, execution_state&);
+using instruction_exec_fn = const instruction* (*)(const instruction*, AdvancedExecutionState&);
 
 /// The evmone intrinsic opcodes.
 ///
@@ -125,7 +127,7 @@ struct instruction
     explicit constexpr instruction(instruction_exec_fn f) noexcept : fn{f}, arg{} {}
 };
 
-struct code_analysis
+struct AdvancedCodeAnalysis
 {
     std::vector<instruction> instrs;
 
@@ -143,7 +145,7 @@ struct code_analysis
     std::vector<int32_t> jumpdest_targets;
 };
 
-inline int find_jumpdest(const code_analysis& analysis, int offset) noexcept
+inline int find_jumpdest(const AdvancedCodeAnalysis& analysis, int offset) noexcept
 {
     const auto begin = std::begin(analysis.jumpdest_offsets);
     const auto end = std::end(analysis.jumpdest_offsets);
@@ -153,7 +155,7 @@ inline int find_jumpdest(const code_analysis& analysis, int offset) noexcept
                -1;
 }
 
-EVMC_EXPORT code_analysis analyze(
+EVMC_EXPORT AdvancedCodeAnalysis analyze(
     evmc_revision rev, const uint8_t* code, size_t code_size) noexcept;
 
 EVMC_EXPORT const op_table& get_op_table(evmc_revision rev) noexcept;

lib/evmone/execution.cpp

@@ -14,7 +14,7 @@ evmc_result execute(evmc_vm* /*unused*/, const evmc_host_interface* host, evmc_h
     const auto analysis = analyze(rev, code, code_size);
 
     auto state =
-        std::make_unique<execution_state>(*msg, rev, *host, ctx, code, code_size, analysis);
+        std::make_unique<AdvancedExecutionState>(*msg, rev, *host, ctx, code, code_size, analysis);
 
     const auto* instr = &state->analysis->instrs[0];
     while (instr != nullptr)

lib/evmone/instructions.cpp

@@ -11,34 +11,34 @@ namespace evmone
 namespace
 {
 template <void InstrFn(evm_stack&)>
-const instruction* op(const instruction* instr, execution_state& state) noexcept
+const instruction* op(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     InstrFn(state.stack);
     return ++instr;
 }
 
 template <void InstrFn(ExecutionState&)>
-const instruction* op(const instruction* instr, execution_state& state) noexcept
+const instruction* op(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     InstrFn(state);
     return ++instr;
 }
 
 template <evmc_status_code InstrFn(ExecutionState&)>
-const instruction* op(const instruction* instr, execution_state& state) noexcept
+const instruction* op(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     const auto status_code = InstrFn(state);
     if (status_code != EVMC_SUCCESS)
         return state.exit(status_code);
     return ++instr;
 }
 
-const instruction* op_stop(const instruction*, execution_state& state) noexcept
+const instruction* op_stop(const instruction*, AdvancedExecutionState& state) noexcept
 {
     return state.exit(EVMC_SUCCESS);
 }
 
-const instruction* op_sstore(const instruction* instr, execution_state& state) noexcept
+const instruction* op_sstore(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     const auto gas_left_correction = state.current_block_cost - instr->arg.number;
     state.gas_left += gas_left_correction;
@@ -53,7 +53,7 @@ const instruction* op_sstore(const instruction* instr, execution_state& state) n
     return ++instr;
 }
 
-const instruction* op_jump(const instruction*, execution_state& state) noexcept
+const instruction* op_jump(const instruction*, AdvancedExecutionState& state) noexcept
 {
     const auto dst = state.stack.pop();
     auto pc = -1;
@@ -64,7 +64,7 @@ const instruction* op_jump(const instruction*, execution_state& state) noexcept
     return &state.analysis->instrs[static_cast<size_t>(pc)];
 }
 
-const instruction* op_jumpi(const instruction* instr, execution_state& state) noexcept
+const instruction* op_jumpi(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     if (state.stack[1] != 0)
         instr = op_jump(instr, state);
@@ -81,34 +81,34 @@ const instruction* op_jumpi(const instruction* instr, execution_state& state) no
     return instr;
 }
 
-const instruction* op_pc(const instruction* instr, execution_state& state) noexcept
+const instruction* op_pc(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     state.stack.push(instr->arg.number);
     return ++instr;
 }
 
-const instruction* op_gas(const instruction* instr, execution_state& state) noexcept
+const instruction* op_gas(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     const auto correction = state.current_block_cost - instr->arg.number;
     const auto gas = static_cast<uint64_t>(state.gas_left + correction);
     state.stack.push(gas);
     return ++instr;
 }
 
-const instruction* op_push_small(const instruction* instr, execution_state& state) noexcept
+const instruction* op_push_small(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     state.stack.push(instr->arg.small_push_value);
     return ++instr;
 }
 
-const instruction* op_push_full(const instruction* instr, execution_state& state) noexcept
+const instruction* op_push_full(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     state.stack.push(*instr->arg.push_value);
     return ++instr;
 }
 
 template <evmc_opcode LogOp>
-const instruction* op_log(const instruction* instr, execution_state& state) noexcept
+const instruction* op_log(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     constexpr auto num_topics = LogOp - OP_LOG0;
     const auto status_code = log(state, num_topics);
@@ -117,13 +117,13 @@ const instruction* op_log(const instruction* instr, execution_state& state) noex
     return ++instr;
 }
 
-const instruction* op_invalid(const instruction*, execution_state& state) noexcept
+const instruction* op_invalid(const instruction*, AdvancedExecutionState& state) noexcept
 {
     return state.exit(EVMC_INVALID_INSTRUCTION);
 }
 
 template <evmc_status_code status_code>
-const instruction* op_return(const instruction*, execution_state& state) noexcept
+const instruction* op_return(const instruction*, AdvancedExecutionState& state) noexcept
 {
     const auto offset = state.stack[0];
     const auto size = state.stack[1];
@@ -138,7 +138,7 @@ const instruction* op_return(const instruction*, execution_state& state) noexcep
 }
 
 template <evmc_call_kind Kind, bool Static = false>
-const instruction* op_call(const instruction* instr, execution_state& state) noexcept
+const instruction* op_call(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     const auto gas_left_correction = state.current_block_cost - instr->arg.number;
     state.gas_left += gas_left_correction;
@@ -154,7 +154,7 @@ const instruction* op_call(const instruction* instr, execution_state& state) noe
 }
 
 template <evmc_call_kind Kind>
-const instruction* op_create(const instruction* instr, execution_state& state) noexcept
+const instruction* op_create(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     const auto gas_left_correction = state.current_block_cost - instr->arg.number;
     state.gas_left += gas_left_correction;
@@ -169,17 +169,17 @@ const instruction* op_create(const instruction* instr, execution_state& state) n
     return ++instr;
 }
 
-const instruction* op_undefined(const instruction*, execution_state& state) noexcept
+const instruction* op_undefined(const instruction*, AdvancedExecutionState& state) noexcept
 {
     return state.exit(EVMC_UNDEFINED_INSTRUCTION);
 }
 
-const instruction* op_selfdestruct(const instruction*, execution_state& state) noexcept
+const instruction* op_selfdestruct(const instruction*, AdvancedExecutionState& state) noexcept
 {
     return state.exit(selfdestruct(state));
 }
 
-const instruction* opx_beginblock(const instruction* instr, execution_state& state) noexcept
+const instruction* opx_beginblock(const instruction* instr, AdvancedExecutionState& state) noexcept
 {
     auto& block = instr->arg.block;
 

test/unittests/execution_state_test.cpp

@@ -13,11 +13,11 @@ static_assert(!std::is_copy_constructible<evmone::ExecutionState>::value);
 static_assert(!std::is_move_assignable<evmone::ExecutionState>::value);
 static_assert(!std::is_copy_assignable<evmone::ExecutionState>::value);
 
-static_assert(std::is_default_constructible<evmone::execution_state>::value);
-static_assert(!std::is_move_constructible<evmone::execution_state>::value);
-static_assert(!std::is_copy_constructible<evmone::execution_state>::value);
-static_assert(!std::is_move_assignable<evmone::execution_state>::value);
-static_assert(!std::is_copy_assignable<evmone::execution_state>::value);
+static_assert(std::is_default_constructible<evmone::AdvancedExecutionState>::value);
+static_assert(!std::is_move_constructible<evmone::AdvancedExecutionState>::value);
+static_assert(!std::is_copy_constructible<evmone::AdvancedExecutionState>::value);
+static_assert(!std::is_move_assignable<evmone::AdvancedExecutionState>::value);
+static_assert(!std::is_copy_assignable<evmone::AdvancedExecutionState>::value);
 
 TEST(execution_state, construct)
 {
@@ -60,7 +60,7 @@ TEST(execution_state, default_construct)
 
 TEST(execution_state, default_construct_advanced)
 {
-    const evmone::execution_state st;
+    const evmone::AdvancedExecutionState st;
 
     EXPECT_EQ(st.gas_left, 0);
     EXPECT_EQ(st.stack.size(), 0);
@@ -82,9 +82,9 @@ TEST(execution_state, reset_advanced)
 {
     const evmc_message msg{};
     const uint8_t code[]{0xff};
-    evmone::code_analysis analysis;
+    evmone::AdvancedCodeAnalysis analysis;
 
-    evmone::execution_state st;
+    evmone::AdvancedExecutionState st;
     st.gas_left = 1;
     st.stack.push({});
     st.memory.resize(2);
@@ -117,7 +117,7 @@ TEST(execution_state, reset_advanced)
         msg2.gas = 13;
         const evmc_host_interface host_interface2{};
         const uint8_t code2[]{0x80, 0x81};
-        evmone::code_analysis analysis2;
+        evmone::AdvancedCodeAnalysis analysis2;
 
         st.reset(
             msg2, EVMC_HOMESTEAD, host_interface2, nullptr, code2, std::size(code2), analysis2);

test/utils/dump.cpp

@@ -9,7 +9,7 @@
 #include <iomanip>
 #include <iostream>
 
-void dump(const evmone::code_analysis& analysis)
+void dump(const evmone::AdvancedCodeAnalysis& analysis)
 {
     using namespace evmone;
 

test/utils/dump.hpp

@@ -5,4 +5,4 @@
 
 #include <evmone/analysis.hpp>
 
-void dump(const evmone::code_analysis& analysis);
+void dump(const evmone::AdvancedCodeAnalysis& analysis);