以太坊原始碼分析(27)core-vm-jumptable-instruction原始碼分析

尹成發表於2018-05-14
原始碼Struct
jumptable. 是一個 [256]operation 的資料結構. 每個下標對應了一種指令, 使用operation來儲存了指令對應的處理邏輯, gas消耗, 堆疊驗證方法, memory使用的大小等功能.
## jumptable

資料結構operation儲存了一條指令的所需要的函式.

    type operation struct {
        // op is the operation function 執行函式
        execute executionFunc
        // gasCost is the gas function and returns the gas required for execution gas消耗函式
        gasCost gasFunc
        // validateStack validates the stack (size) for the operation 堆疊大小驗證函式
        validateStack stackValidationFunc
        // memorySize returns the memory size required for the operation 需要的記憶體大小
        memorySize memorySizeFunc
    
        halts bool // indicates whether the operation shoult halt further execution 表示操作是否停止進一步執行
        jumps bool // indicates whether the program counter should not increment 指示程式計數器是否不增加
        writes bool // determines whether this a state modifying operation 確定這是否是一個狀態修改操作
        valid bool // indication whether the retrieved operation is valid and known 指示檢索到的操作是否有效並且已知
        reverts bool // determines whether the operation reverts state (implicitly halts)確定操作是否恢復狀態（隱式停止）
        returns bool // determines whether the opertions sets the return data content 確定操作是否設定了返回資料內容
    }

指令集, 下面定義了三種指令集,針對三種不同的以太坊版本,

var (
    frontierInstructionSet = NewFrontierInstructionSet()
    homesteadInstructionSet = NewHomesteadInstructionSet()
    byzantiumInstructionSet = NewByzantiumInstructionSet()
)
NewByzantiumInstructionSet 拜占庭版本首先呼叫NewHomesteadInstructionSet創造了前一個版本的指令,然後增加自己特有的指令.STATICCALL ,RETURNDATASIZE ,RETURNDATACOPY ,REVERT
    
    // NewByzantiumInstructionSet returns the frontier, homestead and
    // byzantium instructions.
    func NewByzantiumInstructionSet() [256]operation {
        // instructions that can be executed during the homestead phase.
        instructionSet := NewHomesteadInstructionSet()
        instructionSet[STATICCALL] = operation{
            execute: opStaticCall,
            gasCost: gasStaticCall,
            validateStack: makeStackFunc(6, 1),
            memorySize: memoryStaticCall,
            valid: true,
            returns: true,
        }
        instructionSet[RETURNDATASIZE] = operation{
            execute: opReturnDataSize,
            gasCost: constGasFunc(GasQuickStep),
            validateStack: makeStackFunc(0, 1),
            valid: true,
        }
        instructionSet[RETURNDATACOPY] = operation{
            execute: opReturnDataCopy,
            gasCost: gasReturnDataCopy,
            validateStack: makeStackFunc(3, 0),
            memorySize: memoryReturnDataCopy,
            valid: true,
        }
        instructionSet[REVERT] = operation{
            execute: opRevert,
            gasCost: gasRevert,
            validateStack: makeStackFunc(2, 0),
            memorySize: memoryRevert,
            valid: true,
            reverts: true,
            returns: true,
        }
        return instructionSet
    }

NewHomesteadInstructionSet

    // NewHomesteadInstructionSet returns the frontier and homestead
    // instructions that can be executed during the homestead phase.
    func NewHomesteadInstructionSet() [256]operation {
        instructionSet := NewFrontierInstructionSet()
        instructionSet[DELEGATECALL] = operation{
            execute: opDelegateCall,
            gasCost: gasDelegateCall,
            validateStack: makeStackFunc(6, 1),
            memorySize: memoryDelegateCall,
            valid: true,
            returns: true,
        }
        return instructionSet
    }



## instruction.go
因為指令很多,所以不一一列出來, 只列舉幾個例子. 雖然組合起來的功能可以很複雜,但是單個指令來說,還是比較直觀的.

    func opPc(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
        stack.push(evm.interpreter.intPool.get().SetUint64(*pc))
        return nil, nil
    }
    
    func opMsize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
        stack.push(evm.interpreter.intPool.get().SetInt64(int64(memory.Len())))
        return nil, nil
    }



## gas_table.go
gas_table返回了各種指令消耗的gas的函式
這個函式的返回值基本上只有errGasUintOverflow 整數溢位的錯誤.

    func gasBalance(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
        return gt.Balance, nil
    }
    
    func gasExtCodeSize(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
        return gt.ExtcodeSize, nil
    }
    
    func gasSLoad(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
        return gt.SLoad, nil
    }
    
    func gasExp(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
        expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8)
    
        var (
            gas = expByteLen * gt.ExpByte // no overflow check required. Max is 256 * ExpByte gas
            overflow bool
        )
        if gas, overflow = math.SafeAdd(gas, GasSlowStep); overflow {
            return 0, errGasUintOverflow
        }
        return gas, nil
    }

## interpreter.go 直譯器

資料結構
    
    // Config are the configuration options for the Interpreter
    type Config struct {
        // Debug enabled debugging Interpreter options
        Debug bool
        // EnableJit enabled the JIT VM
        EnableJit bool
        // ForceJit forces the JIT VM
        ForceJit bool
        // Tracer is the op code logger
        Tracer Tracer
        // NoRecursion disabled Interpreter call, callcode,
        // delegate call and create.
        NoRecursion bool
        // Disable gas metering
        DisableGasMetering bool
        // Enable recording of SHA3/keccak preimages
        EnablePreimageRecording bool
        // JumpTable contains the EVM instruction table. This
        // may be left uninitialised and will be set to the default
        // table.
        JumpTable [256]operation
    }
    
    // Interpreter is used to run Ethereum based contracts and will utilise the
    // passed evmironment to query external sources for state information.
    // The Interpreter will run the byte code VM or JIT VM based on the passed
    // configuration.
    type Interpreter struct {
        evm *EVM
        cfg Config
        gasTable params.GasTable // 標識了很多操作的Gas價格
        intPool *intPool
    
        readOnly bool // Whether to throw on stateful modifications
        returnData []byte // Last CALL's return data for subsequent reuse 最後一個函式的返回值
    }

建構函式
    
    // NewInterpreter returns a new instance of the Interpreter.
    func NewInterpreter(evm *EVM, cfg Config) *Interpreter {
        // We use the STOP instruction whether to see
        // the jump table was initialised. If it was not
        // we'll set the default jump table.
        // 用一個STOP指令測試JumpTable是否已經被初始化了, 如果沒有被初始化,那麼設定為預設值
        if !cfg.JumpTable[STOP].valid {
            switch {
            case evm.ChainConfig().IsByzantium(evm.BlockNumber):
                cfg.JumpTable = byzantiumInstructionSet
            case evm.ChainConfig().IsHomestead(evm.BlockNumber):
                cfg.JumpTable = homesteadInstructionSet
            default:
                cfg.JumpTable = frontierInstructionSet
            }
        }
    
        return &Interpreter{
            evm: evm,
            cfg: cfg,
            gasTable: evm.ChainConfig().GasTable(evm.BlockNumber),
            intPool: newIntPool(),
        }
    }


直譯器一共就兩個方法enforceRestrictions方法和Run方法.


    
    func (in *Interpreter) enforceRestrictions(op OpCode, operation operation, stack *Stack) error {
        if in.evm.chainRules.IsByzantium {
            if in.readOnly {
                // If the interpreter is operating in readonly mode, make sure no
                // state-modifying operation is performed. The 3rd stack item
                // for a call operation is the value. Transferring value from one
                // account to the others means the state is modified and should also
                // return with an error.
                if operation.writes || (op == CALL && stack.Back(2).BitLen() > 0) {
                    return errWriteProtection
                }
            }
        }
        return nil
    }
    
    // Run loops and evaluates the contract's code with the given input data and returns
    // the return byte-slice and an error if one occurred.
    // 用給定的入參迴圈執行合約的程式碼，並返回返回的位元組片段，如果發生錯誤則返回錯誤。
    // It's important to note that any errors returned by the interpreter should be
    // considered a revert-and-consume-all-gas operation. No error specific checks
    // should be handled to reduce complexity and errors further down the in.
    // 重要的是要注意，直譯器返回的任何錯誤都會消耗全部gas。 為了減少複雜性,沒有特別的錯誤處理流程。
    func (in *Interpreter) Run(snapshot int, contract *Contract, input []byte) (ret []byte, err error) {
        // Increment the call depth which is restricted to 1024
        in.evm.depth++
        defer func() { in.evm.depth-- }()
    
        // Reset the previous call's return data. It's unimportant to preserve the old buffer
        // as every returning call will return new data anyway.
        in.returnData = nil
    
        // Don't bother with the execution if there's no code.
        if len(contract.Code) == 0 {
            return nil, nil
        }
    
        codehash := contract.CodeHash // codehash is used when doing jump dest caching
        if codehash == (common.Hash{}) {
            codehash = crypto.Keccak256Hash(contract.Code)
        }
    
        var (
            op OpCode // current opcode
            mem = NewMemory() // bound memory
            stack = newstack() // local stack
            // For optimisation reason we're using uint64 as the program counter.
            // It's theoretically possible to go above 2^64. The YP defines the PC
            // to be uint256. Practically much less so feasible.
            pc = uint64(0) // program counter
            cost uint64
            // copies used by tracer
            stackCopy = newstack() // stackCopy needed for Tracer since stack is mutated by 63/64 gas rule
            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
    
        defer func() {
            if err != nil && !logged && in.cfg.Debug {
                in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stackCopy, contract, in.evm.depth, err)
            }
        }()
    
        // The Interpreter main run loop (contextual). This loop runs until either an
        // explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during
        // the execution of one of the operations or until the done flag is set by the
        // parent context.
        // 直譯器的主要迴圈， 直到遇到STOP，RETURN，SELFDESTRUCT指令被執行，或者是遇到任意錯誤，或者說done 標誌被父context設定。
        for atomic.LoadInt32(&in.evm.abort) == 0 {
            // Get the memory location of pc
            // 難道下一個需要執行的指令
            op = contract.GetOp(pc)
    
            if in.cfg.Debug {
                logged = false
                pcCopy = uint64(pc)
                gasCopy = uint64(contract.Gas)
                stackCopy = newstack()
                for _, val := range stack.data {
                    stackCopy.push(val)
                }
            }
    
            // get the operation from the jump table matching the opcode
            // 通過JumpTable拿到對應的operation
            operation := in.cfg.JumpTable[op]
            // 這裡檢查了只讀模式下面不能執行writes指令
            // staticCall的情況下會設定為readonly模式
            if err := in.enforceRestrictions(op, operation, stack); err != nil {
                return nil, err
            }
    
            // if the op is invalid abort the process and return an error
            if !operation.valid { //檢查指令是否非法
                return nil, fmt.Errorf("invalid opcode 0x%x", int(op))
            }
    
            // validate the stack and make sure there enough stack items available
            // to perform the operation
            // 檢查是否有足夠的堆疊空間。 包括入棧和出棧
            if err := operation.validateStack(stack); err != nil {
                return nil, err
            }
    
            var memorySize uint64
            // calculate the new memory size and expand the memory to fit
            // the operation
            if operation.memorySize != nil { // 計算記憶體使用量，需要收費
                memSize, overflow := bigUint64(operation.memorySize(stack))
                if overflow {
                    return nil, errGasUintOverflow
                }
                // memory is expanded in words of 32 bytes. Gas
                // is also calculated in words.
                if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {
                    return nil, errGasUintOverflow
                }
            }
    
            if !in.cfg.DisableGasMetering { //這個引數在本地模擬執行的時候比較有用，可以不消耗或者檢查GAS執行交易並得到返回結果
                // consume the gas and return an error if not enough gas is available.
                // cost is explicitly set so that the capture state defer method cas get the proper cost
                // 計算gas的Cost 並使用，如果不夠，就返回OutOfGas錯誤。
                cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize)
                if err != nil || !contract.UseGas(cost) {
                    return nil, ErrOutOfGas
                }
            }
            if memorySize > 0 { //擴大記憶體範圍
                mem.Resize(memorySize)
            }
    
            if in.cfg.Debug {
                in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, mem, stackCopy, contract, in.evm.depth, err)
                logged = true
            }
    
            // execute the operation
            // 執行命令
            res, err := operation.execute(&pc, in.evm, contract, mem, stack)
            // verifyPool is a build flag. Pool verification makes sure the integrity
            // of the integer pool by comparing values to a default value.
            if verifyPool {
                verifyIntegerPool(in.intPool)
            }
            // if the operation clears the return data (e.g. it has returning data)
            // set the last return to the result of the operation.
            if operation.returns { //如果有返回值，那麼就設定返回值。 注意只有最後一個返回有效果。
                in.returnData = res
            }
    
            switch {
            case err != nil:
                return nil, err
            case operation.reverts:
                return res, errExecutionReverted
            case operation.halts:
                return res, nil
            case !operation.jumps:
                pc++
            }
        }
        return nil, nil
    }




網址：http://www.qukuailianxueyuan.io/



欲領取造幣技術與全套虛擬機器資料

區塊鏈技術交流QQ群：756146052  備註：CSDN

尹成學院微信：備註：CSDN




相關文章