EIP-3779: EVM 更安全的状态控制流

PUSH address
JUMP

TEST_SQUARE:
    jumpdest
    push RTN_SQUARE 
    0x02
    push SQUARE
    jump
RTN_SQUARE
    jumpdest
    swap1
    jump

SQUARE:
    jumpdest
    dup1
    mul
    swap1
    jump

var bytecode      [codeLen]byte
var subMin        [codeLen]int
var subMax        [codeLen]int
var subDelta      [codeLen]int
var visited       [codeLen]bool
var dataStack     [1024]int

// 验证 pc 处字节码控制流的路径
// 并返回该路径上使用的最大堆栈项数
// 否则返回 PC 和错误
//
// 通过从 pc:=0 开始，递归评估整个程序
//
func validate(pc := 0, sp := 0, rp := 0) int, error {
   minStack := 0 
   maxStack := 0 
   deltaStack := 0 
   for pc < codeLen {
      if !isValidInstruction(pc) {
         return 0,0,0,invalid_instruction // 无效指令
      }
      
      // 如果我们之前跳转到这里，则返回以打破循环
      if visited[pc] {

          // 如果增量不同，则堆栈未对齐
          if ??? {
            return 0,0,0,invalid_stack // 无效堆栈
          }
          return minStack, maxStack, sp
      }
      visited[pc] = true
      switch bytecode[pc] {

      // 成功终止
      case STOP:
         return minStack, maxStack, sp
      case RETURN:
         return minStack, maxStack, sp

      case SELFDESTRUCT:
         return minStack, maxStack, sp
      case REVERT:
         return minStack, maxStack, sp
      case INVALID:
         return 0,0,0,invalid_instruction // 无效指令
    
      case RJUMP:

         // 检查有效的跳转目标
         if !isValidJumpdest(jumpdest) {
            return 0,0,0,invalid_destination // 无效目标
         }
         
         // 将 pc 重置为跳转目标
         pc += immediateData(pc)

      case RJUMPI:
      
         // 递归以验证条件的真的一面
         jumpdest = pc + immediateData(pc)
         if !isValidJumpdest(pc + jumpdest) {
            return 0,0,0,invalid_destination // 无效目标
         }
         minRight, maxLeft, deltaRight, err =
            validate(jumpdest, sp, rp)
  
      case RJUMPSUB:

         // 检查有效的跳转目标
         jumpdest = immediateData(pc)
         if !isValidJumpdest(pc + jumpdest) {
            return 0,0,0,invalid_destination // 无效目标
         }

         pc += jumpdest

         // 递归验证子例程调用
         minSub, maxSub, deltaSub, err = validate(jumpdest, sp, rp)
         if err {
            return 0,0,0,err
         }
         subMin[pc] = minSub
         subMax[pc] = maxSub
         subDelta[pc] = deltaSub
         minStack = min(minStack, sp)
         maxStack = max(maxStack, sp)
         pc = advancePC(pc)

      case RETURNSUB:
      
         maxStack = max(maxStack, sp)
         return minStack, maxStack, sp, nil

      /////////////////////////////////////////////////////
      //
      // 以下仅在我们采取
      //
      //    Option 2
      //
      // 并且不弃用 JUMP 和 JUMPI
      //
      case JUMP:
         // 弹出跳转目标
         jumpdest = dataStack[--sp]
         if !valid_jumpdest(jumpdest) {
            return 0,0,0,invalid_destination // 无效目标
         }
         pc = jumpdest
      case JUMPI:
         // 弹出跳转目标和条件
         jumpdest = dataStack[--sp]
         jumpif = dataStack[--sp]
         if sp < 0 {}
            return 0,0,0,stack_underflow // 堆栈下溢
         }
         if !valid_jumpdest(jumpdest) {
            return 0,0,0,invalid_destination // 无效目标
         }

         // 递归以验证条件的真的一面
         if !isValidJumpdest(jumpdest) {
            return 0,0,0,invalid_destination // 无效目标
         }
         maxLeft, err = validate(jumpdest, sp, rp)
         if err {
            return 0,0,0,err
         }
         
         // 递归以验证条件的假的一面
         pc = advance_pc(pc)
         maxRight, err = validate(pc, sp, rp)
         if err {
            return 0,0,0,err
         }
         
         // 两侧都有效，则返回最大值
         maxStack += max(maxLeft, maxRight)
         return minStack, maxStack, sp
      case PUSH1 <= bytecode[pc] && bytecode[pc] <= PUSH32 {
         sp++
         if (sp > 1023) {
            return 0,0,0,stack_overflow // 堆栈溢出
         }
         maxStack = max(maxStack, sp)
         dataStack[sp] = immediateData(pc)
         pc = advancePC(pc)
      case DUP1 <= bytecode[pc] && bytecode[pc] <= DUP32 {
         dup = sp - (bytecode[pc] - DUP1)
         if dup < 0 {
            return 0,0,0,stack_underflow // 堆栈下溢
         }
         sp++
         if (sp > 1023) {
            return 0,0,0,stack_overflow // 堆栈溢出
         }
         maxStack = max(maxStack, sp)
         dataStack[sp] = dataStack[dup]
         pc = advancePC(pc)
      case SWAP1 <= bytecode[pc] && bytecode[pc] <= SWAP32 {
         swap = sp - (bytecode[pc] - SWAP1)
         if swap < 0 {
            return 0,0,0,stack_underflow // 堆栈下溢
         }
         temp := dataStack[swap]
         dataStack[swap] = dataStack[0]
         dataStack[0] = temp
         pc = advancePC(pc)
      //
      /////////////////////////////////////////////////////

      default:

         // 将其他指令应用到堆栈指针
         sp -= removed_items(pc)
         if (sp < 0) {
            return 0,0,0,stack_underflow // 堆栈下溢
         }
         minStack = min(minStack, sp)
         sp += added_items(pc)
         if (sp > 1023) {
            return 0,0,0,stack_overflow // 堆栈溢出
         }
         maxStack = max(maxStack, sp)
         pc = advancePC(pc)
      }
   }

   // 成功终止
   return minStack, maxStack, sp
}