以太坊源码解读（21）EVM 解释器

之前我们说到EVM解释器是面对Contract对象的，不论是Contract的创建还是调用，都会通过run()函数来调用Interpreter的Run()方法。该方法初始化执行过程中所需要的一些变量，然后进入堆栈操作的主循环。

一、Interpreter.Run()

a. 初始化执行循环中的中间变量

if in.intPool == nil {
    in.intPool = poolOfIntPools.get()
    defer func() {
        poolOfIntPools.put(in.intPool)
        in.intPool = nil
    }()
}

// Increment the call depth which is restricted to 1024
in.evm.depth++
defer func() { in.evm.depth-- }()

// 将readOnly设置为true，如果调用方法是静态调用，则设置为只读，一旦不是出现写操作，则退出
if readOnly && !in.readOnly {
    in.readOnly = true
    defer func() { in.readOnly = false }()
}

// 清空之前Call调用的结果
in.returnData = nil

// 如果合约代码为空则直接退出
if len(contract.Code) == 0 {
    return nil, nil
}

var (
    op    OpCode        // 当前的指令集
    mem   = NewMemory() // 新建内存
    stack = newstack()  // 新建堆栈
    pc   = uint64(0) // program counter
    cost uint64

    pcCopy  uint64 // needed for the deferred Tracer
    gasCopy uint64 // for Tracer to log gas remaining before execution
    logged  bool   // deferred Tracer should ignore already logged steps
)
// 设置合约输入参数
contract.Input = input

// Reclaim the stack as an int pool when the execution stops
defer func() { in.intPool.put(stack.data...) }()

b. 进入主循环 1-根据pc获取一条指令 2-检查堆栈上的参数 是否服符合指令函数的要求 3-如果当前解释器是只读的，如果当前指令是写指令，可能导致世界状态改变，直接退出循环 4-计算指令所需要的内存大小 5-获取这个指令需要gas消耗，然后从交易余额中扣除当前指令的消耗，如果余额不足，直接返回 6-内存大小调整到合适大小 7-执行指令 8-处理指令的返回值

for atomic.LoadInt32(&in.evm.abort) == 0 {
    // 第一步：根据pc获取一条指令
    op = contract.GetOp(pc)
    // 第二步：根据指令从JumpTable中获得操作码
    operation := in.cfg.JumpTable[op]
    // 检查-1：操作码是否有效
    if !operation.valid {
        return nil, fmt.Errorf("invalid opcode 0x%x", int(op))
    }
    // 检查-2：检查堆栈上的参数是否符合指令函数的要求
    if err := operation.validateStack(stack); err != nil {
        return nil, err
    }
    // 第三步：如果当前解释器是只读的，若碰到写指令，则直接退出
    if err := in.enforceRestrictions(op, operation, stack); err != nil {
        return nil, err
    }

    var memorySize uint64
    // 第四步：计算指令需要的内存大小
    if operation.memorySize != nil {
        // 先判断内存大小是否足够
        memSize, overflow := bigUint64(operation.memorySize(stack))
        if overflow {
            return nil, errGasUintOverflow
        }
        // 如果足够则以32 bytes为单位进行内存扩充，并计算gas
        if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {
            return nil, errGasUintOverflow
        }
    }
    // 第五步：获取指令所需要的gas，然后从交易余额中扣除，如果余额不足，直接返回
    cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize)
    if err != nil || !contract.UseGas(cost) {
        return nil, ErrOutOfGas
    }
    // 第六步：重新调整刚才获得的SafeSize的内存大小
    if memorySize > 0 {
        mem.Resize(memorySize)
    }
    // 第七步：重要！！！！执行指令！！！！！
    res, err := operation.execute(&pc, in, contract, mem, stack)
    // 检查intPool的完整性
    if verifyPool {
        verifyIntegerPool(in.intPool)
    }
    // 如果指令定义returns为true，将返回值复制给解释器的returnData成员
    if operation.returns {
        in.returnData = res
    }
    // 第八步：处理返回值
    switch {
    case err != nil:  // 返回指令执行错误，直接返回
        return nil, err
    case operation.reverts:9  // revert指令返回
        return res, errExecutionReverted
    case operation.halts:  // 如果指令为终止指令，直接退出（STOP,RETURN,SELFDESTRUCT）
        return res, nil
    case !operation.jumps:  // 如果不是跳转指令，pc自增，进行下一条指令运行，重新循环
        pc++
    }
}

总体来说，解释器执行循环的过程如下图：

二、EVM指令与操作

我们先看下EVM模块的代码结构：

evm.go	        定义了EVM运行环境结构体，并实现 转账处理 这些比较高级的，跟交易本身有关的功能
vm/evm.go	定义了EVM结构体，提供Create和Call方法，作为虚拟机的入口，分别对应创建合约和执行合约代码
vm/interpreter.go   虚拟机的调度器，开始真正的解析执行合约代码
vm/opcodes.go	    定义了虚拟机指令码（操作码）
vm/instructions.go  绝大部分的操作码对应的实现都在这里
vm/gas_table.go	    绝大部分操作码所需的gas都在这里计算
vm/jump_table.go    定义了operation，就是将opcode和gas计算函数、具体实现函数等关联起来
vm/stack.go	evm所需要的栈
vm/memory.go	evm的内存结构
vm/intpool.go	*big.Int的池子，主要是性能上的考虑，跟业务逻辑无关

从上图来看，opcodes中储存的是所有指令码，比如ADD的指令码就是0x01。jump_table定义了每一个指令对应的指令码、gas花费；instructions中是所有的指令执行函数的实现，通过这些函数来对堆栈stack进行操作，比如pop()、push()等。

当一个contract对象传入interpreter模块，首先调用了contract的GetOp(n)方法，其内部调用了GetByte(n)方法，从而从Contract对象的Code中拿到n对应的指令。参数n就是我们上面再Run()函数中定义的pc，是一个程序的计数器。每次指令执行后都会让pc++，从而调用下一个指令，除非指令执行到最后是退出函数，比如return、stop或selfDestruct。

// GetOp returns the n'th element in the contract's byte array
func (c *Contract) GetOp(n uint64) OpCode {
	return OpCode(c.GetByte(n))
}

// GetByte returns the n'th byte in the contract's byte array
func (c *Contract) GetByte(n uint64) byte {
	if n < uint64(len(c.Code)) {
		return c.Code[n]
	}
	return 0
}

三、基于堆栈的虚拟机

虚拟机实际上是从软件层面对物理机器的模拟，但以太坊虚拟机相对于我们日常常见到的狭义的虚拟机如vmware或者v-box不同，仅仅是为了模拟对字节码的取指令、译码、执行和结果储存返回等操作，这些步骤跟真实物理机器上的概念都很类似。当然，不管虚拟机怎么实现，最终都还是要依靠物理资源。

如今虚拟机的实现方式有两种，一种就是基于栈的，另一种是基于寄存器的。基于栈的虚拟机有JVM，CPython等，而基于寄存器的有Dalvik以及Lua5.0。这两种实现方式虽然机制不同，但最终都要实现： 1、从内存中取指令； 2、译码，将指令转义成特定的操作； 3、执行，也就是在栈或者寄存器中进行计算； 4、返回计算结果。

我们这里简单通过一张图回顾上面那个ADD指令的执行，了解一下基于栈的计算如何执行，以便我们能对以太坊EVM的原理有很深的理解。

加入我们栈上先PUSH了3和4在栈顶，现在当收到ADD指令时，调用opAdd()函数。先执行x=stack.pop()，将栈顶的3取出并赋值给x，删除栈顶的3，然后执行y = stack.peek()，取出此时栈顶的4但是不删除。然后执行y.Add(x,y)得到y==7，再讲7压如栈顶。

当然，上述过程任然是抽象的，是经过译码后的内容。原代码是[]bytes类型的数据，这里就暂时不做介绍了。这涉及到了solidity的原理，后面我会抽个时间总结一下，solidty如何将合约代码转成字节码，而字节码又是如何在EVM中进行译码的。