github.com/humaniq/go-ethereum@v1.6.8-0.20171225131628-061223a13848/core/vm/interpreter.go (about) 1 // Copyright 2014 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package vm 18 19 import ( 20 "fmt" 21 "sync/atomic" 22 23 "github.com/ethereum/go-ethereum/common" 24 "github.com/ethereum/go-ethereum/common/math" 25 "github.com/ethereum/go-ethereum/crypto" 26 "github.com/ethereum/go-ethereum/params" 27 ) 28 29 // Config are the configuration options for the Interpreter 30 type Config struct { 31 // Debug enabled debugging Interpreter options 32 Debug bool 33 // EnableJit enabled the JIT VM 34 EnableJit bool 35 // ForceJit forces the JIT VM 36 ForceJit bool 37 // Tracer is the op code logger 38 Tracer Tracer 39 // NoRecursion disabled Interpreter call, callcode, 40 // delegate call and create. 41 NoRecursion bool 42 // Disable gas metering 43 DisableGasMetering bool 44 // Enable recording of SHA3/keccak preimages 45 EnablePreimageRecording bool 46 // JumpTable contains the EVM instruction table. This 47 // may be left uninitialised and will be set to the default 48 // table. 49 JumpTable [256]operation 50 } 51 52 // Interpreter is used to run Ethereum based contracts and will utilise the 53 // passed evmironment to query external sources for state information. 54 // The Interpreter will run the byte code VM or JIT VM based on the passed 55 // configuration. 56 type Interpreter struct { 57 evm *EVM 58 cfg Config 59 gasTable params.GasTable 60 intPool *intPool 61 62 readOnly bool // Whether to throw on stateful modifications 63 returnData []byte // Last CALL's return data for subsequent reuse 64 } 65 66 // NewInterpreter returns a new instance of the Interpreter. 67 func NewInterpreter(evm *EVM, cfg Config) *Interpreter { 68 // We use the STOP instruction whether to see 69 // the jump table was initialised. If it was not 70 // we'll set the default jump table. 71 if !cfg.JumpTable[STOP].valid { 72 switch { 73 case evm.ChainConfig().IsByzantium(evm.BlockNumber): 74 cfg.JumpTable = byzantiumInstructionSet 75 case evm.ChainConfig().IsHomestead(evm.BlockNumber): 76 cfg.JumpTable = homesteadInstructionSet 77 default: 78 cfg.JumpTable = frontierInstructionSet 79 } 80 } 81 82 return &Interpreter{ 83 evm: evm, 84 cfg: cfg, 85 gasTable: evm.ChainConfig().GasTable(evm.BlockNumber), 86 intPool: newIntPool(), 87 } 88 } 89 90 func (in *Interpreter) enforceRestrictions(op OpCode, operation operation, stack *Stack) error { 91 if in.evm.chainRules.IsByzantium { 92 if in.readOnly { 93 // If the interpreter is operating in readonly mode, make sure no 94 // state-modifying operation is performed. The 3rd stack item 95 // for a call operation is the value. Transferring value from one 96 // account to the others means the state is modified and should also 97 // return with an error. 98 if operation.writes || (op == CALL && stack.Back(2).BitLen() > 0) { 99 return errWriteProtection 100 } 101 } 102 } 103 return nil 104 } 105 106 // Run loops and evaluates the contract's code with the given input data and returns 107 // the return byte-slice and an error if one occurred. 108 // 109 // It's important to note that any errors returned by the interpreter should be 110 // considered a revert-and-consume-all-gas operation except for 111 // errExecutionReverted which means revert-and-keep-gas-left. 112 func (in *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err error) { 113 // Increment the call depth which is restricted to 1024 114 in.evm.depth++ 115 defer func() { in.evm.depth-- }() 116 117 // Reset the previous call's return data. It's unimportant to preserve the old buffer 118 // as every returning call will return new data anyway. 119 in.returnData = nil 120 121 // Don't bother with the execution if there's no code. 122 if len(contract.Code) == 0 { 123 return nil, nil 124 } 125 126 codehash := contract.CodeHash // codehash is used when doing jump dest caching 127 if codehash == (common.Hash{}) { 128 codehash = crypto.Keccak256Hash(contract.Code) 129 } 130 131 var ( 132 op OpCode // current opcode 133 mem = NewMemory() // bound memory 134 stack = newstack() // local stack 135 // For optimisation reason we're using uint64 as the program counter. 136 // It's theoretically possible to go above 2^64. The YP defines the PC 137 // to be uint256. Practically much less so feasible. 138 pc = uint64(0) // program counter 139 cost uint64 140 // copies used by tracer 141 pcCopy uint64 // needed for the deferred Tracer 142 gasCopy uint64 // for Tracer to log gas remaining before execution 143 logged bool // deferred Tracer should ignore already logged steps 144 ) 145 contract.Input = input 146 147 if in.cfg.Debug { 148 defer func() { 149 if err != nil { 150 if !logged { 151 in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err) 152 } else { 153 in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err) 154 } 155 } 156 }() 157 } 158 // The Interpreter main run loop (contextual). This loop runs until either an 159 // explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during 160 // the execution of one of the operations or until the done flag is set by the 161 // parent context. 162 for atomic.LoadInt32(&in.evm.abort) == 0 { 163 if in.cfg.Debug { 164 // Capture pre-execution values for tracing. 165 logged, pcCopy, gasCopy = false, pc, contract.Gas 166 } 167 168 // Get the operation from the jump table and validate the stack to ensure there are 169 // enough stack items available to perform the operation. 170 op = contract.GetOp(pc) 171 operation := in.cfg.JumpTable[op] 172 if !operation.valid { 173 return nil, fmt.Errorf("invalid opcode 0x%x", int(op)) 174 } 175 if err := operation.validateStack(stack); err != nil { 176 return nil, err 177 } 178 // If the operation is valid, enforce and write restrictions 179 if err := in.enforceRestrictions(op, operation, stack); err != nil { 180 return nil, err 181 } 182 183 var memorySize uint64 184 // calculate the new memory size and expand the memory to fit 185 // the operation 186 if operation.memorySize != nil { 187 memSize, overflow := bigUint64(operation.memorySize(stack)) 188 if overflow { 189 return nil, errGasUintOverflow 190 } 191 // memory is expanded in words of 32 bytes. Gas 192 // is also calculated in words. 193 if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow { 194 return nil, errGasUintOverflow 195 } 196 } 197 198 if !in.cfg.DisableGasMetering { 199 // consume the gas and return an error if not enough gas is available. 200 // cost is explicitly set so that the capture state defer method cas get the proper cost 201 cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize) 202 if err != nil || !contract.UseGas(cost) { 203 return nil, ErrOutOfGas 204 } 205 } 206 if memorySize > 0 { 207 mem.Resize(memorySize) 208 } 209 210 if in.cfg.Debug { 211 in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err) 212 logged = true 213 } 214 215 // execute the operation 216 res, err := operation.execute(&pc, in.evm, contract, mem, stack) 217 // verifyPool is a build flag. Pool verification makes sure the integrity 218 // of the integer pool by comparing values to a default value. 219 if verifyPool { 220 verifyIntegerPool(in.intPool) 221 } 222 // if the operation clears the return data (e.g. it has returning data) 223 // set the last return to the result of the operation. 224 if operation.returns { 225 in.returnData = res 226 } 227 228 switch { 229 case err != nil: 230 return nil, err 231 case operation.reverts: 232 return res, errExecutionReverted 233 case operation.halts: 234 return res, nil 235 case !operation.jumps: 236 pc++ 237 } 238 } 239 return nil, nil 240 }