github.com/halybang/go-ethereum@v1.0.5-0.20180325041310-3b262bc1367c/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/wanchain/go-wanchain/common" 24 "github.com/wanchain/go-wanchain/common/math" 25 "github.com/wanchain/go-wanchain/crypto" 26 "github.com/wanchain/go-wanchain/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 74 //case evm.ChainConfig().IsByzantium(evm.BlockNumber): 75 // cfg.JumpTable = byzantiumInstructionSet 76 77 //case evm.ChainConfig().IsHomestead(evm.BlockNumber): 78 // cfg.JumpTable = homesteadInstructionSet 79 80 default: 81 //cfg.JumpTable = frontierInstructionSet 82 cfg.JumpTable = byzantiumInstructionSet //the latest is byzantium 83 84 } 85 86 87 } 88 89 return &Interpreter{ 90 evm: evm, 91 cfg: cfg, 92 gasTable: evm.ChainConfig().GasTable(evm.BlockNumber), 93 intPool: newIntPool(), 94 } 95 } 96 97 func (in *Interpreter) enforceRestrictions(op OpCode, operation operation, stack *Stack) error { 98 99 //if in.evm.chainRules.IsByzantium { 100 if in.readOnly { 101 // If the interpreter is operating in readonly mode, make sure no 102 // state-modifying operation is performed. The 3rd stack item 103 // for a call operation is the value. Transferring value from one 104 // account to the others means the state is modified and should also 105 // return with an error. 106 if operation.writes || (op == CALL && stack.Back(2).BitLen() > 0) { 107 return errWriteProtection 108 } 109 } 110 //} 111 return nil 112 } 113 114 // Run loops and evaluates the contract's code with the given input data and returns 115 // the return byte-slice and an error if one occurred. 116 // 117 // It's important to note that any errors returned by the interpreter should be 118 // considered a revert-and-consume-all-gas operation. No error specific checks 119 // should be handled to reduce complexity and errors further down the in. 120 func (in *Interpreter) Run(snapshot int, contract *Contract, input []byte) (ret []byte, err error) { 121 // Increment the call depth which is restricted to 1024 122 in.evm.depth++ 123 defer func() { in.evm.depth-- }() 124 125 // Reset the previous call's return data. It's unimportant to preserve the old buffer 126 // as every returning call will return new data anyway. 127 in.returnData = nil 128 129 // Don't bother with the execution if there's no code. 130 if len(contract.Code) == 0 { 131 return nil, nil 132 } 133 134 codehash := contract.CodeHash // codehash is used when doing jump dest caching 135 if codehash == (common.Hash{}) { 136 codehash = crypto.Keccak256Hash(contract.Code) 137 } 138 139 var ( 140 op OpCode // current opcode 141 mem = NewMemory() // bound memory 142 stack = newstack() // local stack 143 // For optimisation reason we're using uint64 as the program counter. 144 // It's theoretically possible to go above 2^64. The YP defines the PC 145 // to be uint256. Practically much less so feasible. 146 pc = uint64(0) // program counter 147 cost uint64 148 // copies used by tracer 149 stackCopy = newstack() // stackCopy needed for Tracer since stack is mutated by 63/64 gas rule 150 pcCopy uint64 // needed for the deferred Tracer 151 gasCopy uint64 // for Tracer to log gas remaining before execution 152 logged bool // deferred Tracer should ignore already logged steps 153 ) 154 contract.Input = input 155 156 defer func() { 157 if err != nil && !logged && in.cfg.Debug { 158 in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stackCopy, contract, in.evm.depth, err) 159 } 160 }() 161 162 // The Interpreter main run loop (contextual). This loop runs until either an 163 // explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during 164 // the execution of one of the operations or until the done flag is set by the 165 // parent context. 166 for atomic.LoadInt32(&in.evm.abort) == 0 { 167 // Get the memory location of pc 168 op = contract.GetOp(pc) 169 170 if in.cfg.Debug { 171 logged = false 172 pcCopy = uint64(pc) 173 gasCopy = uint64(contract.Gas) 174 stackCopy = newstack() 175 for _, val := range stack.data { 176 stackCopy.push(val) 177 } 178 } 179 180 // Get the operation from the jump table matching the opcode and validate the 181 // stack and make sure there enough stack items available to perform the operation 182 operation := in.cfg.JumpTable[op] 183 if !operation.valid { 184 return nil, fmt.Errorf("invalid opcode 0x%x", int(op)) 185 } 186 if err := operation.validateStack(stack); err != nil { 187 return nil, err 188 } 189 // If the operation is valid, enforce and write restrictions 190 if err := in.enforceRestrictions(op, operation, stack); err != nil { 191 return nil, err 192 } 193 194 var memorySize uint64 195 // calculate the new memory size and expand the memory to fit 196 // the operation 197 if operation.memorySize != nil { 198 memSize, overflow := bigUint64(operation.memorySize(stack)) 199 if overflow { 200 return nil, errGasUintOverflow 201 } 202 // memory is expanded in words of 32 bytes. Gas 203 // is also calculated in words. 204 if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow { 205 return nil, errGasUintOverflow 206 } 207 } 208 209 if !in.cfg.DisableGasMetering { 210 // consume the gas and return an error if not enough gas is available. 211 // cost is explicitly set so that the capture state defer method cas get the proper cost 212 cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize) 213 if err != nil || !contract.UseGas(cost) { 214 return nil, ErrOutOfGas 215 } 216 } 217 if memorySize > 0 { 218 mem.Resize(memorySize) 219 } 220 221 if in.cfg.Debug { 222 in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, mem, stackCopy, contract, in.evm.depth, err) 223 logged = true 224 } 225 226 // execute the operation 227 res, err := operation.execute(&pc, in.evm, contract, mem, stack) 228 // verifyPool is a build flag. Pool verification makes sure the integrity 229 // of the integer pool by comparing values to a default value. 230 if verifyPool { 231 verifyIntegerPool(in.intPool) 232 } 233 // if the operation clears the return data (e.g. it has returning data) 234 // set the last return to the result of the operation. 235 if operation.returns { 236 in.returnData = res 237 } 238 239 switch { 240 case err != nil: 241 return nil, err 242 case operation.reverts: 243 return res, errExecutionReverted 244 case operation.halts: 245 return res, nil 246 case !operation.jumps: 247 pc++ 248 } 249 } 250 return nil, nil 251 }