【源码阅读】evmⅠ-编程知识

代码位置如下：

参考link
以太坊中有一个很重要的用途是智能合约，而其中evm模块是实现了执行智能合约的虚拟机。evm可以逐条解析执行智能合约的指令。
evm中的核心对象是EVM，代表一个以太坊虚拟机。其内部主要依赖：解释器Interoreter（循环解释执行给定的合约指令，直接遇到退出指令)、配置和状态数据库StateDB（用来提供数据的永久存储和查询）

1、创建EVM

前提是在core/state_processor.go中使用ApplyTransaction函数来处理交易。在这个函数里面，需要创建一个EVM来执行交易中的数据。
使用NewEVM函数来实现创建。

func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM

主要包括：

ctx: 提供访问当前区块链数据和挖矿环境的函数和数据
statedb: 以太坊状态数据库对象
chainConfig: 当前节点的区块链配置信息
vmConfig: 虚拟机配置信息
解释器
而解释器的创建是通过函数NewEVMInterpreter实现的。该函数首先要根据以太坊的版本不同，为jumpTable字段进行不同的填充。

2、创建合约

使用EVM.Create函数来创建合约。通过当前合约的创建者地址和其账户中的 Nonce 值，计算出来一个地址值，作为合约的地址。然后将这个地址和其它参数传给 EVM.create 方法。同一份合约代码，每次创建合约时得到的合约地址都是不一样的，因为合约是通过发送交易创建，而每发送一次交易 Nonce 值都会改变。

func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {contractAddr = crypto.CreateAddress(caller.Address(), evm.StateDB.GetNonce(caller.Address()))return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr, CREATE)
}

而EVM.create函数才是主要内容。

func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, value *uint256.Int, address common.Address, typ OpCode) ([]byte, common.Address, uint64, error)

在函数的第一部分，需要进行判断，包括合约的递归调用次数depth是否在限制之内、以及创建者是否有足够的以太币。每次创建完成就需要将创建者的nonce值加一，这样每一次创建合约的地址才会不一样。

	if evm.depth > int(params.CallCreateDepth) {return nil, common.Address{}, gas, ErrDepth}if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {return nil, common.Address{}, gas, ErrInsufficientBalance}nonce := evm.StateDB.GetNonce(caller.Address())if nonce+1 < nonce {return nil, common.Address{}, gas, ErrNonceUintOverflow}evm.StateDB.SetNonce(caller.Address(), nonce+1)

在完成一系列的判断之后，需要创建合约账户，将交易中规定的金额转到账户中，如果账户已经存在就返回错误。

	if evm.chainRules.IsBerlin {evm.StateDB.AddAddressToAccessList(address)}// Ensure there's no existing contract already at the designated addresscontractHash := evm.StateDB.GetCodeHash(address)if evm.StateDB.GetNonce(address) != 0 || (contractHash != (common.Hash{}) && contractHash != types.EmptyCodeHash) {return nil, common.Address{}, 0, ErrContractAddressCollision}// Create a new account on the statesnapshot := evm.StateDB.Snapshot()evm.StateDB.CreateAccount(address)if evm.chainRules.IsEIP158 {evm.StateDB.SetNonce(address, 1)}evm.Context.Transfer(evm.StateDB, caller.Address(), address, value)

在第三部分中需要创建一个contract对象，其中包括合约在执行过程中的必要信息，比如合约的创建者、合约的地址等。具体函数在contract.go文件里面。在合约创建之后，需要调用run函数来运行合约。如果合约运行成功，并且代码长度没有超过限制MaxCodeSize，就会将合约代码存储到stateDB中的合约账户中并且消耗一定的gas。因为在编译器阶段，会向源代码中插入其它代码，所以存储的是运行后的返回码。

//判断长度
if err == nil && evm.chainRules.IsEIP158 && len(ret) > params.MaxCodeSize {err = ErrMaxCodeSizeExceeded}// Reject code starting with 0xEF if EIP-3541 is enabled.if err == nil && len(ret) >= 1 && ret[0] == 0xEF && evm.chainRules.IsLondon {err = ErrInvalidCode}//没有错误就写入数据库if err == nil {createDataGas := uint64(len(ret)) * params.CreateDataGasif contract.UseGas(createDataGas) {evm.StateDB.SetCode(address, ret)} else {err = ErrCodeStoreOutOfGas}}

2.1执行合约创建

主要实现在interpreter中的Run函数。首先迭代次数depth的增加和减少是在解释器中实现的，使用到了defer延迟函数。
之后我们判断readOnly和in.readOnly，只有当readOnly为真（即我们需要设置为只读）并且in.readOnly为假（即当前不处于只读状态）时，才会执行大括号内的代码。

	if readOnly && !in.readOnly {in.readOnly = truedefer func() { in.readOnly = false }()}

以太坊虚拟机的工作流程：
由solidity语言编写的智能合约，通过编译器编译成bytecode，之后发到以太坊上，以太坊底层通过evm模块支持合约的执行和调用，调用时根据合约获取代码，即合约的字节码，生成环境后载入到 EVM 执行。
所以需要opcode操作码和mem存储以及为了应对高并发情况下的栈资源问题，代码中创建了stack来保存一些被创造但未使用的栈空间。
主要函数内容以及解释如下：

	for {//如果处于调试模式，那么会记录执行前的状态信息，包括程序计数器（pc）、剩余的gas和操作的成本。if debug {// Capture pre-execution values for tracing.logged, pcCopy, gasCopy = false, pc, contract.Gas}// Get the operation from the jump table and validate the stack to ensure there are// enough stack items available to perform the operation.//从合约中获取当前程序计数器指向的操作op = contract.GetOp(pc)//从操作表中获取对应的操作operation := in.table[op]//获取操作的固定gas成本cost = operation.constantGas // For tracing// Validate stack 对stack进行验证if sLen := stack.len(); sLen < operation.minStack {return nil, &ErrStackUnderflow{stackLen: sLen, required: operation.minStack}} else if sLen > operation.maxStack {return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack}}//如果剩余的gas不足以执行这个操作，那么返回错误if !contract.UseGas(cost) {return nil, ErrOutOfGas}//如果操作有动态的gas成本，那么计算新的内存大小并扩展内存以适应操作if operation.dynamicGas != nil {// All ops with a dynamic memory usage also has a dynamic gas cost.var memorySize uint64if operation.memorySize != nil {memSize, overflow := operation.memorySize(stack)if overflow {return nil, ErrGasUintOverflow}if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {return nil, ErrGasUintOverflow}}var dynamicCost uint64//计算动态的gas成本dynamicCost, err = operation.dynamicGas(in.evm, contract, stack, mem, memorySize)cost += dynamicCost // for tracing//如果计算过程中出现错误或者剩余的gas不足以支付动态的gas成本，那么返回错误if err != nil || !contract.UseGas(dynamicCost) {return nil, ErrOutOfGas}//如果处于调试模式，那么记录执行后的状态信息if debug {in.evm.Config.Tracer.CaptureState(pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)logged = true}if memorySize > 0 {mem.Resize(memorySize)}} else if debug {in.evm.Config.Tracer.CaptureState(pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)logged = true}// 执行操作res, err = operation.execute(&pc, in, callContext)if err != nil {break}//将程序计数器加一，准备执行下一个操作pc++}