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  }