WIP

Author: chfast

lib/evmone/analysis.cpp

@@ -11,6 +11,15 @@ namespace evmone
 {
 namespace
 {
+struct block_analysis
+{
+    int gas_cost = 0;
+
+    int stack_req = 0;
+    int stack_max_growth = 0;
+    int stack_change = 0;
+};
+
 inline constexpr evmc_call_kind op2call_kind(uint8_t opcode) noexcept
 {
     switch (opcode)
@@ -52,9 +61,9 @@ code_analysis analyze(
     const auto* instr_table = evmc_get_instruction_metrics_table(rev);
 
     size_t beginblock_instr_index = 0;
-    block_info* block = nullptr;
+    block_analysis block;
+    bool no_block = false;
 
-    int block_stack_change = 0;
     int instr_index = 0;
 
     const auto code_end = code + code_size;
@@ -65,15 +74,18 @@ code_analysis analyze(
 
         const bool jumpdest = opcode == OP_JUMPDEST;
 
-        if (!block || jumpdest)
+        if (no_block || jumpdest)
         {
+            block = {};
+            no_block = false;
+
             // Create BEGINBLOCK instruction which either replaces JUMPDEST or is injected
             // in case there is no JUMPDEST.
             beginblock_instr_index = analysis.instrs.size();
             analysis.instrs.emplace_back(fns[OPX_BEGINBLOCK]);
 
             // Start new block.
-            block_stack_change = 0;
+            block.stack_change = 0;
 
             if (jumpdest)  // Add the jumpdest to the map.
             {
@@ -85,25 +97,24 @@ code_analysis analyze(
         }
 
         auto& instr = jumpdest ? analysis.instrs.back() : analysis.instrs.emplace_back(fns[opcode]);
-        block = &analysis.instrs[beginblock_instr_index].arg.block;
+        //        block = &analysis.instrs[beginblock_instr_index].arg.block;
 
         const auto metrics = instr_table[opcode];
         const auto instr_stack_req = metrics.num_stack_arguments;
         const auto instr_stack_change = metrics.num_stack_returned_items - instr_stack_req;
 
         // TODO: Define a block_analysis struct with regular ints for analysis.
         //       Compress it when block is closed.
-        auto stack_req = instr_stack_req - block_stack_change;
-        if (stack_req > std::numeric_limits<decltype(block->stack_req)>::max())
-            stack_req = std::numeric_limits<decltype(block->stack_req)>::max();
+        auto stack_req = instr_stack_req - block.stack_change;
+        if (stack_req > std::numeric_limits<decltype(block.stack_req)>::max())
+            stack_req = std::numeric_limits<decltype(block.stack_req)>::max();
 
-        block->stack_req = std::max(block->stack_req, static_cast<int16_t>(stack_req));
-        block_stack_change += instr_stack_change;
-        block->stack_max_growth =
-            static_cast<int16_t>(std::max(int{block->stack_max_growth}, block_stack_change));
+        block.stack_req = std::max(block.stack_req, stack_req);
+        block.stack_change += instr_stack_change;
+        block.stack_max_growth = std::max(block.stack_max_growth, block.stack_change);
 
         if (metrics.gas_cost > 0)  // can be -1 for undefined instruction
-            block->gas_cost += metrics.gas_cost;
+            block.gas_cost += metrics.gas_cost;
 
         switch (opcode)
         {
@@ -161,7 +172,7 @@ code_analysis analyze(
             break;
 
         case OP_GAS:
-            instr.arg.p.number = block->gas_cost;
+            instr.arg.p.number = block.gas_cost;
             break;
 
         case OP_CALL:
@@ -170,7 +181,7 @@ code_analysis analyze(
         case OP_STATICCALL:
         case OP_CREATE:
         case OP_CREATE2:
-            instr.arg.p.number = block->gas_cost;
+            instr.arg.p.number = block.gas_cost;
             instr.arg.p.call_kind =
                 op2call_kind(opcode == OP_STATICCALL ? uint8_t{OP_CALL} : opcode);
             break;
@@ -195,13 +206,13 @@ code_analysis analyze(
         case OP_RETURN:
         case OP_REVERT:
         case OP_SELFDESTRUCT:
-            block = nullptr;
+            no_block = true;
             break;
         }
     }
 
     // Not terminated block or empty code.
-    if (block || code_size == 0 || code[code_size - 1] == OP_JUMPI)
+    if (!no_block || code_size == 0 || code[code_size - 1] == OP_JUMPI)
         analysis.instrs.emplace_back(fns[OP_STOP]);
 
     // FIXME: assert(analysis.instrs.size() <= max_instrs_size);