github.com/AlohaMobile/go-ethereum@v1.9.7/core/vm/instructions.go (about)

     1  // Copyright 2015 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  	"errors"
    21  	"math/big"
    22  
    23  	"github.com/ethereum/go-ethereum/common"
    24  	"github.com/ethereum/go-ethereum/common/math"
    25  	"github.com/ethereum/go-ethereum/core/types"
    26  	"github.com/ethereum/go-ethereum/params"
    27  	"golang.org/x/crypto/sha3"
    28  )
    29  
    30  var (
    31  	bigZero                  = new(big.Int)
    32  	tt255                    = math.BigPow(2, 255)
    33  	errWriteProtection       = errors.New("evm: write protection")
    34  	errReturnDataOutOfBounds = errors.New("evm: return data out of bounds")
    35  	errExecutionReverted     = errors.New("evm: execution reverted")
    36  	errMaxCodeSizeExceeded   = errors.New("evm: max code size exceeded")
    37  	errInvalidJump           = errors.New("evm: invalid jump destination")
    38  )
    39  
    40  func opAdd(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
    41  	x, y := stack.pop(), stack.peek()
    42  	math.U256(y.Add(x, y))
    43  
    44  	interpreter.intPool.put(x)
    45  	return nil, nil
    46  }
    47  
    48  func opSub(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
    49  	x, y := stack.pop(), stack.peek()
    50  	math.U256(y.Sub(x, y))
    51  
    52  	interpreter.intPool.put(x)
    53  	return nil, nil
    54  }
    55  
    56  func opMul(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
    57  	x, y := stack.pop(), stack.pop()
    58  	stack.push(math.U256(x.Mul(x, y)))
    59  
    60  	interpreter.intPool.put(y)
    61  
    62  	return nil, nil
    63  }
    64  
    65  func opDiv(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
    66  	x, y := stack.pop(), stack.peek()
    67  	if y.Sign() != 0 {
    68  		math.U256(y.Div(x, y))
    69  	} else {
    70  		y.SetUint64(0)
    71  	}
    72  	interpreter.intPool.put(x)
    73  	return nil, nil
    74  }
    75  
    76  func opSdiv(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
    77  	x, y := math.S256(stack.pop()), math.S256(stack.pop())
    78  	res := interpreter.intPool.getZero()
    79  
    80  	if y.Sign() == 0 || x.Sign() == 0 {
    81  		stack.push(res)
    82  	} else {
    83  		if x.Sign() != y.Sign() {
    84  			res.Div(x.Abs(x), y.Abs(y))
    85  			res.Neg(res)
    86  		} else {
    87  			res.Div(x.Abs(x), y.Abs(y))
    88  		}
    89  		stack.push(math.U256(res))
    90  	}
    91  	interpreter.intPool.put(x, y)
    92  	return nil, nil
    93  }
    94  
    95  func opMod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
    96  	x, y := stack.pop(), stack.pop()
    97  	if y.Sign() == 0 {
    98  		stack.push(x.SetUint64(0))
    99  	} else {
   100  		stack.push(math.U256(x.Mod(x, y)))
   101  	}
   102  	interpreter.intPool.put(y)
   103  	return nil, nil
   104  }
   105  
   106  func opSmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   107  	x, y := math.S256(stack.pop()), math.S256(stack.pop())
   108  	res := interpreter.intPool.getZero()
   109  
   110  	if y.Sign() == 0 {
   111  		stack.push(res)
   112  	} else {
   113  		if x.Sign() < 0 {
   114  			res.Mod(x.Abs(x), y.Abs(y))
   115  			res.Neg(res)
   116  		} else {
   117  			res.Mod(x.Abs(x), y.Abs(y))
   118  		}
   119  		stack.push(math.U256(res))
   120  	}
   121  	interpreter.intPool.put(x, y)
   122  	return nil, nil
   123  }
   124  
   125  func opExp(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   126  	base, exponent := stack.pop(), stack.pop()
   127  	// some shortcuts
   128  	cmpToOne := exponent.Cmp(big1)
   129  	if cmpToOne < 0 { // Exponent is zero
   130  		// x ^ 0 == 1
   131  		stack.push(base.SetUint64(1))
   132  	} else if base.Sign() == 0 {
   133  		// 0 ^ y, if y != 0, == 0
   134  		stack.push(base.SetUint64(0))
   135  	} else if cmpToOne == 0 { // Exponent is one
   136  		// x ^ 1 == x
   137  		stack.push(base)
   138  	} else {
   139  		stack.push(math.Exp(base, exponent))
   140  		interpreter.intPool.put(base)
   141  	}
   142  	interpreter.intPool.put(exponent)
   143  	return nil, nil
   144  }
   145  
   146  func opSignExtend(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   147  	back := stack.pop()
   148  	if back.Cmp(big.NewInt(31)) < 0 {
   149  		bit := uint(back.Uint64()*8 + 7)
   150  		num := stack.pop()
   151  		mask := back.Lsh(common.Big1, bit)
   152  		mask.Sub(mask, common.Big1)
   153  		if num.Bit(int(bit)) > 0 {
   154  			num.Or(num, mask.Not(mask))
   155  		} else {
   156  			num.And(num, mask)
   157  		}
   158  
   159  		stack.push(math.U256(num))
   160  	}
   161  
   162  	interpreter.intPool.put(back)
   163  	return nil, nil
   164  }
   165  
   166  func opNot(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   167  	x := stack.peek()
   168  	math.U256(x.Not(x))
   169  	return nil, nil
   170  }
   171  
   172  func opLt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   173  	x, y := stack.pop(), stack.peek()
   174  	if x.Cmp(y) < 0 {
   175  		y.SetUint64(1)
   176  	} else {
   177  		y.SetUint64(0)
   178  	}
   179  	interpreter.intPool.put(x)
   180  	return nil, nil
   181  }
   182  
   183  func opGt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   184  	x, y := stack.pop(), stack.peek()
   185  	if x.Cmp(y) > 0 {
   186  		y.SetUint64(1)
   187  	} else {
   188  		y.SetUint64(0)
   189  	}
   190  	interpreter.intPool.put(x)
   191  	return nil, nil
   192  }
   193  
   194  func opSlt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   195  	x, y := stack.pop(), stack.peek()
   196  
   197  	xSign := x.Cmp(tt255)
   198  	ySign := y.Cmp(tt255)
   199  
   200  	switch {
   201  	case xSign >= 0 && ySign < 0:
   202  		y.SetUint64(1)
   203  
   204  	case xSign < 0 && ySign >= 0:
   205  		y.SetUint64(0)
   206  
   207  	default:
   208  		if x.Cmp(y) < 0 {
   209  			y.SetUint64(1)
   210  		} else {
   211  			y.SetUint64(0)
   212  		}
   213  	}
   214  	interpreter.intPool.put(x)
   215  	return nil, nil
   216  }
   217  
   218  func opSgt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   219  	x, y := stack.pop(), stack.peek()
   220  
   221  	xSign := x.Cmp(tt255)
   222  	ySign := y.Cmp(tt255)
   223  
   224  	switch {
   225  	case xSign >= 0 && ySign < 0:
   226  		y.SetUint64(0)
   227  
   228  	case xSign < 0 && ySign >= 0:
   229  		y.SetUint64(1)
   230  
   231  	default:
   232  		if x.Cmp(y) > 0 {
   233  			y.SetUint64(1)
   234  		} else {
   235  			y.SetUint64(0)
   236  		}
   237  	}
   238  	interpreter.intPool.put(x)
   239  	return nil, nil
   240  }
   241  
   242  func opEq(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   243  	x, y := stack.pop(), stack.peek()
   244  	if x.Cmp(y) == 0 {
   245  		y.SetUint64(1)
   246  	} else {
   247  		y.SetUint64(0)
   248  	}
   249  	interpreter.intPool.put(x)
   250  	return nil, nil
   251  }
   252  
   253  func opIszero(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   254  	x := stack.peek()
   255  	if x.Sign() > 0 {
   256  		x.SetUint64(0)
   257  	} else {
   258  		x.SetUint64(1)
   259  	}
   260  	return nil, nil
   261  }
   262  
   263  func opAnd(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   264  	x, y := stack.pop(), stack.pop()
   265  	stack.push(x.And(x, y))
   266  
   267  	interpreter.intPool.put(y)
   268  	return nil, nil
   269  }
   270  
   271  func opOr(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   272  	x, y := stack.pop(), stack.peek()
   273  	y.Or(x, y)
   274  
   275  	interpreter.intPool.put(x)
   276  	return nil, nil
   277  }
   278  
   279  func opXor(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   280  	x, y := stack.pop(), stack.peek()
   281  	y.Xor(x, y)
   282  
   283  	interpreter.intPool.put(x)
   284  	return nil, nil
   285  }
   286  
   287  func opByte(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   288  	th, val := stack.pop(), stack.peek()
   289  	if th.Cmp(common.Big32) < 0 {
   290  		b := math.Byte(val, 32, int(th.Int64()))
   291  		val.SetUint64(uint64(b))
   292  	} else {
   293  		val.SetUint64(0)
   294  	}
   295  	interpreter.intPool.put(th)
   296  	return nil, nil
   297  }
   298  
   299  func opAddmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   300  	x, y, z := stack.pop(), stack.pop(), stack.pop()
   301  	if z.Cmp(bigZero) > 0 {
   302  		x.Add(x, y)
   303  		x.Mod(x, z)
   304  		stack.push(math.U256(x))
   305  	} else {
   306  		stack.push(x.SetUint64(0))
   307  	}
   308  	interpreter.intPool.put(y, z)
   309  	return nil, nil
   310  }
   311  
   312  func opMulmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   313  	x, y, z := stack.pop(), stack.pop(), stack.pop()
   314  	if z.Cmp(bigZero) > 0 {
   315  		x.Mul(x, y)
   316  		x.Mod(x, z)
   317  		stack.push(math.U256(x))
   318  	} else {
   319  		stack.push(x.SetUint64(0))
   320  	}
   321  	interpreter.intPool.put(y, z)
   322  	return nil, nil
   323  }
   324  
   325  // opSHL implements Shift Left
   326  // The SHL instruction (shift left) pops 2 values from the stack, first arg1 and then arg2,
   327  // and pushes on the stack arg2 shifted to the left by arg1 number of bits.
   328  func opSHL(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   329  	// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
   330  	shift, value := math.U256(stack.pop()), math.U256(stack.peek())
   331  	defer interpreter.intPool.put(shift) // First operand back into the pool
   332  
   333  	if shift.Cmp(common.Big256) >= 0 {
   334  		value.SetUint64(0)
   335  		return nil, nil
   336  	}
   337  	n := uint(shift.Uint64())
   338  	math.U256(value.Lsh(value, n))
   339  
   340  	return nil, nil
   341  }
   342  
   343  // opSHR implements Logical Shift Right
   344  // The SHR instruction (logical shift right) pops 2 values from the stack, first arg1 and then arg2,
   345  // and pushes on the stack arg2 shifted to the right by arg1 number of bits with zero fill.
   346  func opSHR(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   347  	// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
   348  	shift, value := math.U256(stack.pop()), math.U256(stack.peek())
   349  	defer interpreter.intPool.put(shift) // First operand back into the pool
   350  
   351  	if shift.Cmp(common.Big256) >= 0 {
   352  		value.SetUint64(0)
   353  		return nil, nil
   354  	}
   355  	n := uint(shift.Uint64())
   356  	math.U256(value.Rsh(value, n))
   357  
   358  	return nil, nil
   359  }
   360  
   361  // opSAR implements Arithmetic Shift Right
   362  // The SAR instruction (arithmetic shift right) pops 2 values from the stack, first arg1 and then arg2,
   363  // and pushes on the stack arg2 shifted to the right by arg1 number of bits with sign extension.
   364  func opSAR(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   365  	// Note, S256 returns (potentially) a new bigint, so we're popping, not peeking this one
   366  	shift, value := math.U256(stack.pop()), math.S256(stack.pop())
   367  	defer interpreter.intPool.put(shift) // First operand back into the pool
   368  
   369  	if shift.Cmp(common.Big256) >= 0 {
   370  		if value.Sign() >= 0 {
   371  			value.SetUint64(0)
   372  		} else {
   373  			value.SetInt64(-1)
   374  		}
   375  		stack.push(math.U256(value))
   376  		return nil, nil
   377  	}
   378  	n := uint(shift.Uint64())
   379  	value.Rsh(value, n)
   380  	stack.push(math.U256(value))
   381  
   382  	return nil, nil
   383  }
   384  
   385  func opSha3(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   386  	offset, size := stack.pop(), stack.pop()
   387  	data := memory.GetPtr(offset.Int64(), size.Int64())
   388  
   389  	if interpreter.hasher == nil {
   390  		interpreter.hasher = sha3.NewLegacyKeccak256().(keccakState)
   391  	} else {
   392  		interpreter.hasher.Reset()
   393  	}
   394  	interpreter.hasher.Write(data)
   395  	interpreter.hasher.Read(interpreter.hasherBuf[:])
   396  
   397  	evm := interpreter.evm
   398  	if evm.vmConfig.EnablePreimageRecording {
   399  		evm.StateDB.AddPreimage(interpreter.hasherBuf, data)
   400  	}
   401  	stack.push(interpreter.intPool.get().SetBytes(interpreter.hasherBuf[:]))
   402  
   403  	interpreter.intPool.put(offset, size)
   404  	return nil, nil
   405  }
   406  
   407  func opAddress(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   408  	stack.push(interpreter.intPool.get().SetBytes(contract.Address().Bytes()))
   409  	return nil, nil
   410  }
   411  
   412  func opBalance(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   413  	slot := stack.peek()
   414  	slot.Set(interpreter.evm.StateDB.GetBalance(common.BigToAddress(slot)))
   415  	return nil, nil
   416  }
   417  
   418  func opOrigin(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   419  	stack.push(interpreter.intPool.get().SetBytes(interpreter.evm.Origin.Bytes()))
   420  	return nil, nil
   421  }
   422  
   423  func opCaller(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   424  	stack.push(interpreter.intPool.get().SetBytes(contract.Caller().Bytes()))
   425  	return nil, nil
   426  }
   427  
   428  func opCallValue(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   429  	stack.push(interpreter.intPool.get().Set(contract.value))
   430  	return nil, nil
   431  }
   432  
   433  func opCallDataLoad(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   434  	stack.push(interpreter.intPool.get().SetBytes(getDataBig(contract.Input, stack.pop(), big32)))
   435  	return nil, nil
   436  }
   437  
   438  func opCallDataSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   439  	stack.push(interpreter.intPool.get().SetInt64(int64(len(contract.Input))))
   440  	return nil, nil
   441  }
   442  
   443  func opCallDataCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   444  	var (
   445  		memOffset  = stack.pop()
   446  		dataOffset = stack.pop()
   447  		length     = stack.pop()
   448  	)
   449  	memory.Set(memOffset.Uint64(), length.Uint64(), getDataBig(contract.Input, dataOffset, length))
   450  
   451  	interpreter.intPool.put(memOffset, dataOffset, length)
   452  	return nil, nil
   453  }
   454  
   455  func opReturnDataSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   456  	stack.push(interpreter.intPool.get().SetUint64(uint64(len(interpreter.returnData))))
   457  	return nil, nil
   458  }
   459  
   460  func opReturnDataCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   461  	var (
   462  		memOffset  = stack.pop()
   463  		dataOffset = stack.pop()
   464  		length     = stack.pop()
   465  
   466  		end = interpreter.intPool.get().Add(dataOffset, length)
   467  	)
   468  	defer interpreter.intPool.put(memOffset, dataOffset, length, end)
   469  
   470  	if !end.IsUint64() || uint64(len(interpreter.returnData)) < end.Uint64() {
   471  		return nil, errReturnDataOutOfBounds
   472  	}
   473  	memory.Set(memOffset.Uint64(), length.Uint64(), interpreter.returnData[dataOffset.Uint64():end.Uint64()])
   474  
   475  	return nil, nil
   476  }
   477  
   478  func opExtCodeSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   479  	slot := stack.peek()
   480  	slot.SetUint64(uint64(interpreter.evm.StateDB.GetCodeSize(common.BigToAddress(slot))))
   481  
   482  	return nil, nil
   483  }
   484  
   485  func opCodeSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   486  	l := interpreter.intPool.get().SetInt64(int64(len(contract.Code)))
   487  	stack.push(l)
   488  
   489  	return nil, nil
   490  }
   491  
   492  func opCodeCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   493  	var (
   494  		memOffset  = stack.pop()
   495  		codeOffset = stack.pop()
   496  		length     = stack.pop()
   497  	)
   498  	codeCopy := getDataBig(contract.Code, codeOffset, length)
   499  	memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
   500  
   501  	interpreter.intPool.put(memOffset, codeOffset, length)
   502  	return nil, nil
   503  }
   504  
   505  func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   506  	var (
   507  		addr       = common.BigToAddress(stack.pop())
   508  		memOffset  = stack.pop()
   509  		codeOffset = stack.pop()
   510  		length     = stack.pop()
   511  	)
   512  	codeCopy := getDataBig(interpreter.evm.StateDB.GetCode(addr), codeOffset, length)
   513  	memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
   514  
   515  	interpreter.intPool.put(memOffset, codeOffset, length)
   516  	return nil, nil
   517  }
   518  
   519  // opExtCodeHash returns the code hash of a specified account.
   520  // There are several cases when the function is called, while we can relay everything
   521  // to `state.GetCodeHash` function to ensure the correctness.
   522  //   (1) Caller tries to get the code hash of a normal contract account, state
   523  // should return the relative code hash and set it as the result.
   524  //
   525  //   (2) Caller tries to get the code hash of a non-existent account, state should
   526  // return common.Hash{} and zero will be set as the result.
   527  //
   528  //   (3) Caller tries to get the code hash for an account without contract code,
   529  // state should return emptyCodeHash(0xc5d246...) as the result.
   530  //
   531  //   (4) Caller tries to get the code hash of a precompiled account, the result
   532  // should be zero or emptyCodeHash.
   533  //
   534  // It is worth noting that in order to avoid unnecessary create and clean,
   535  // all precompile accounts on mainnet have been transferred 1 wei, so the return
   536  // here should be emptyCodeHash.
   537  // If the precompile account is not transferred any amount on a private or
   538  // customized chain, the return value will be zero.
   539  //
   540  //   (5) Caller tries to get the code hash for an account which is marked as suicided
   541  // in the current transaction, the code hash of this account should be returned.
   542  //
   543  //   (6) Caller tries to get the code hash for an account which is marked as deleted,
   544  // this account should be regarded as a non-existent account and zero should be returned.
   545  func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   546  	slot := stack.peek()
   547  	address := common.BigToAddress(slot)
   548  	if interpreter.evm.StateDB.Empty(address) {
   549  		slot.SetUint64(0)
   550  	} else {
   551  		slot.SetBytes(interpreter.evm.StateDB.GetCodeHash(address).Bytes())
   552  	}
   553  	return nil, nil
   554  }
   555  
   556  func opGasprice(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   557  	stack.push(interpreter.intPool.get().Set(interpreter.evm.GasPrice))
   558  	return nil, nil
   559  }
   560  
   561  func opBlockhash(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   562  	num := stack.pop()
   563  
   564  	n := interpreter.intPool.get().Sub(interpreter.evm.BlockNumber, common.Big257)
   565  	if num.Cmp(n) > 0 && num.Cmp(interpreter.evm.BlockNumber) < 0 {
   566  		stack.push(interpreter.evm.GetHash(num.Uint64()).Big())
   567  	} else {
   568  		stack.push(interpreter.intPool.getZero())
   569  	}
   570  	interpreter.intPool.put(num, n)
   571  	return nil, nil
   572  }
   573  
   574  func opCoinbase(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   575  	stack.push(interpreter.intPool.get().SetBytes(interpreter.evm.Coinbase.Bytes()))
   576  	return nil, nil
   577  }
   578  
   579  func opTimestamp(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   580  	stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.Time)))
   581  	return nil, nil
   582  }
   583  
   584  func opNumber(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   585  	stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.BlockNumber)))
   586  	return nil, nil
   587  }
   588  
   589  func opDifficulty(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   590  	stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.Difficulty)))
   591  	return nil, nil
   592  }
   593  
   594  func opGasLimit(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   595  	stack.push(math.U256(interpreter.intPool.get().SetUint64(interpreter.evm.GasLimit)))
   596  	return nil, nil
   597  }
   598  
   599  func opPop(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   600  	interpreter.intPool.put(stack.pop())
   601  	return nil, nil
   602  }
   603  
   604  func opMload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   605  	v := stack.peek()
   606  	offset := v.Int64()
   607  	v.SetBytes(memory.GetPtr(offset, 32))
   608  	return nil, nil
   609  }
   610  
   611  func opMstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   612  	// pop value of the stack
   613  	mStart, val := stack.pop(), stack.pop()
   614  	memory.Set32(mStart.Uint64(), val)
   615  
   616  	interpreter.intPool.put(mStart, val)
   617  	return nil, nil
   618  }
   619  
   620  func opMstore8(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   621  	off, val := stack.pop().Int64(), stack.pop().Int64()
   622  	memory.store[off] = byte(val & 0xff)
   623  
   624  	return nil, nil
   625  }
   626  
   627  func opSload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   628  	loc := stack.peek()
   629  	val := interpreter.evm.StateDB.GetState(contract.Address(), common.BigToHash(loc))
   630  	loc.SetBytes(val.Bytes())
   631  	return nil, nil
   632  }
   633  
   634  func opSstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   635  	loc := common.BigToHash(stack.pop())
   636  	val := stack.pop()
   637  	interpreter.evm.StateDB.SetState(contract.Address(), loc, common.BigToHash(val))
   638  
   639  	interpreter.intPool.put(val)
   640  	return nil, nil
   641  }
   642  
   643  func opJump(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   644  	pos := stack.pop()
   645  	if !contract.validJumpdest(pos) {
   646  		return nil, errInvalidJump
   647  	}
   648  	*pc = pos.Uint64()
   649  
   650  	interpreter.intPool.put(pos)
   651  	return nil, nil
   652  }
   653  
   654  func opJumpi(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   655  	pos, cond := stack.pop(), stack.pop()
   656  	if cond.Sign() != 0 {
   657  		if !contract.validJumpdest(pos) {
   658  			return nil, errInvalidJump
   659  		}
   660  		*pc = pos.Uint64()
   661  	} else {
   662  		*pc++
   663  	}
   664  
   665  	interpreter.intPool.put(pos, cond)
   666  	return nil, nil
   667  }
   668  
   669  func opJumpdest(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   670  	return nil, nil
   671  }
   672  
   673  func opPc(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   674  	stack.push(interpreter.intPool.get().SetUint64(*pc))
   675  	return nil, nil
   676  }
   677  
   678  func opMsize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   679  	stack.push(interpreter.intPool.get().SetInt64(int64(memory.Len())))
   680  	return nil, nil
   681  }
   682  
   683  func opGas(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   684  	stack.push(interpreter.intPool.get().SetUint64(contract.Gas))
   685  	return nil, nil
   686  }
   687  
   688  func opCreate(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   689  	var (
   690  		value        = stack.pop()
   691  		offset, size = stack.pop(), stack.pop()
   692  		input        = memory.GetCopy(offset.Int64(), size.Int64())
   693  		gas          = contract.Gas
   694  	)
   695  	if interpreter.evm.chainRules.IsEIP150 {
   696  		gas -= gas / 64
   697  	}
   698  
   699  	contract.UseGas(gas)
   700  	res, addr, returnGas, suberr := interpreter.evm.Create(contract, input, gas, value)
   701  	// Push item on the stack based on the returned error. If the ruleset is
   702  	// homestead we must check for CodeStoreOutOfGasError (homestead only
   703  	// rule) and treat as an error, if the ruleset is frontier we must
   704  	// ignore this error and pretend the operation was successful.
   705  	if interpreter.evm.chainRules.IsHomestead && suberr == ErrCodeStoreOutOfGas {
   706  		stack.push(interpreter.intPool.getZero())
   707  	} else if suberr != nil && suberr != ErrCodeStoreOutOfGas {
   708  		stack.push(interpreter.intPool.getZero())
   709  	} else {
   710  		stack.push(interpreter.intPool.get().SetBytes(addr.Bytes()))
   711  	}
   712  	contract.Gas += returnGas
   713  	interpreter.intPool.put(value, offset, size)
   714  
   715  	if suberr == errExecutionReverted {
   716  		return res, nil
   717  	}
   718  	return nil, nil
   719  }
   720  
   721  func opCreate2(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   722  	var (
   723  		endowment    = stack.pop()
   724  		offset, size = stack.pop(), stack.pop()
   725  		salt         = stack.pop()
   726  		input        = memory.GetCopy(offset.Int64(), size.Int64())
   727  		gas          = contract.Gas
   728  	)
   729  
   730  	// Apply EIP150
   731  	gas -= gas / 64
   732  	contract.UseGas(gas)
   733  	res, addr, returnGas, suberr := interpreter.evm.Create2(contract, input, gas, endowment, salt)
   734  	// Push item on the stack based on the returned error.
   735  	if suberr != nil {
   736  		stack.push(interpreter.intPool.getZero())
   737  	} else {
   738  		stack.push(interpreter.intPool.get().SetBytes(addr.Bytes()))
   739  	}
   740  	contract.Gas += returnGas
   741  	interpreter.intPool.put(endowment, offset, size, salt)
   742  
   743  	if suberr == errExecutionReverted {
   744  		return res, nil
   745  	}
   746  	return nil, nil
   747  }
   748  
   749  func opCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   750  	// Pop gas. The actual gas in interpreter.evm.callGasTemp.
   751  	interpreter.intPool.put(stack.pop())
   752  	gas := interpreter.evm.callGasTemp
   753  	// Pop other call parameters.
   754  	addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
   755  	toAddr := common.BigToAddress(addr)
   756  	value = math.U256(value)
   757  	// Get the arguments from the memory.
   758  	args := memory.GetPtr(inOffset.Int64(), inSize.Int64())
   759  
   760  	if value.Sign() != 0 {
   761  		gas += params.CallStipend
   762  	}
   763  	ret, returnGas, err := interpreter.evm.Call(contract, toAddr, args, gas, value)
   764  	if err != nil {
   765  		stack.push(interpreter.intPool.getZero())
   766  	} else {
   767  		stack.push(interpreter.intPool.get().SetUint64(1))
   768  	}
   769  	if err == nil || err == errExecutionReverted {
   770  		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
   771  	}
   772  	contract.Gas += returnGas
   773  
   774  	interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize)
   775  	return ret, nil
   776  }
   777  
   778  func opCallCode(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   779  	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
   780  	interpreter.intPool.put(stack.pop())
   781  	gas := interpreter.evm.callGasTemp
   782  	// Pop other call parameters.
   783  	addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
   784  	toAddr := common.BigToAddress(addr)
   785  	value = math.U256(value)
   786  	// Get arguments from the memory.
   787  	args := memory.GetPtr(inOffset.Int64(), inSize.Int64())
   788  
   789  	if value.Sign() != 0 {
   790  		gas += params.CallStipend
   791  	}
   792  	ret, returnGas, err := interpreter.evm.CallCode(contract, toAddr, args, gas, value)
   793  	if err != nil {
   794  		stack.push(interpreter.intPool.getZero())
   795  	} else {
   796  		stack.push(interpreter.intPool.get().SetUint64(1))
   797  	}
   798  	if err == nil || err == errExecutionReverted {
   799  		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
   800  	}
   801  	contract.Gas += returnGas
   802  
   803  	interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize)
   804  	return ret, nil
   805  }
   806  
   807  func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   808  	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
   809  	interpreter.intPool.put(stack.pop())
   810  	gas := interpreter.evm.callGasTemp
   811  	// Pop other call parameters.
   812  	addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
   813  	toAddr := common.BigToAddress(addr)
   814  	// Get arguments from the memory.
   815  	args := memory.GetPtr(inOffset.Int64(), inSize.Int64())
   816  
   817  	ret, returnGas, err := interpreter.evm.DelegateCall(contract, toAddr, args, gas)
   818  	if err != nil {
   819  		stack.push(interpreter.intPool.getZero())
   820  	} else {
   821  		stack.push(interpreter.intPool.get().SetUint64(1))
   822  	}
   823  	if err == nil || err == errExecutionReverted {
   824  		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
   825  	}
   826  	contract.Gas += returnGas
   827  
   828  	interpreter.intPool.put(addr, inOffset, inSize, retOffset, retSize)
   829  	return ret, nil
   830  }
   831  
   832  func opStaticCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   833  	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
   834  	interpreter.intPool.put(stack.pop())
   835  	gas := interpreter.evm.callGasTemp
   836  	// Pop other call parameters.
   837  	addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
   838  	toAddr := common.BigToAddress(addr)
   839  	// Get arguments from the memory.
   840  	args := memory.GetPtr(inOffset.Int64(), inSize.Int64())
   841  
   842  	ret, returnGas, err := interpreter.evm.StaticCall(contract, toAddr, args, gas)
   843  	if err != nil {
   844  		stack.push(interpreter.intPool.getZero())
   845  	} else {
   846  		stack.push(interpreter.intPool.get().SetUint64(1))
   847  	}
   848  	if err == nil || err == errExecutionReverted {
   849  		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
   850  	}
   851  	contract.Gas += returnGas
   852  
   853  	interpreter.intPool.put(addr, inOffset, inSize, retOffset, retSize)
   854  	return ret, nil
   855  }
   856  
   857  func opReturn(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   858  	offset, size := stack.pop(), stack.pop()
   859  	ret := memory.GetPtr(offset.Int64(), size.Int64())
   860  
   861  	interpreter.intPool.put(offset, size)
   862  	return ret, nil
   863  }
   864  
   865  func opRevert(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   866  	offset, size := stack.pop(), stack.pop()
   867  	ret := memory.GetPtr(offset.Int64(), size.Int64())
   868  
   869  	interpreter.intPool.put(offset, size)
   870  	return ret, nil
   871  }
   872  
   873  func opStop(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   874  	return nil, nil
   875  }
   876  
   877  func opSuicide(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   878  	balance := interpreter.evm.StateDB.GetBalance(contract.Address())
   879  	interpreter.evm.StateDB.AddBalance(common.BigToAddress(stack.pop()), balance)
   880  
   881  	interpreter.evm.StateDB.Suicide(contract.Address())
   882  	return nil, nil
   883  }
   884  
   885  // following functions are used by the instruction jump  table
   886  
   887  // make log instruction function
   888  func makeLog(size int) executionFunc {
   889  	return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   890  		topics := make([]common.Hash, size)
   891  		mStart, mSize := stack.pop(), stack.pop()
   892  		for i := 0; i < size; i++ {
   893  			topics[i] = common.BigToHash(stack.pop())
   894  		}
   895  
   896  		d := memory.GetCopy(mStart.Int64(), mSize.Int64())
   897  		interpreter.evm.StateDB.AddLog(&types.Log{
   898  			Address: contract.Address(),
   899  			Topics:  topics,
   900  			Data:    d,
   901  			// This is a non-consensus field, but assigned here because
   902  			// core/state doesn't know the current block number.
   903  			BlockNumber: interpreter.evm.BlockNumber.Uint64(),
   904  		})
   905  
   906  		interpreter.intPool.put(mStart, mSize)
   907  		return nil, nil
   908  	}
   909  }
   910  
   911  // opPush1 is a specialized version of pushN
   912  func opPush1(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   913  	var (
   914  		codeLen = uint64(len(contract.Code))
   915  		integer = interpreter.intPool.get()
   916  	)
   917  	*pc += 1
   918  	if *pc < codeLen {
   919  		stack.push(integer.SetUint64(uint64(contract.Code[*pc])))
   920  	} else {
   921  		stack.push(integer.SetUint64(0))
   922  	}
   923  	return nil, nil
   924  }
   925  
   926  // make push instruction function
   927  func makePush(size uint64, pushByteSize int) executionFunc {
   928  	return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   929  		codeLen := len(contract.Code)
   930  
   931  		startMin := codeLen
   932  		if int(*pc+1) < startMin {
   933  			startMin = int(*pc + 1)
   934  		}
   935  
   936  		endMin := codeLen
   937  		if startMin+pushByteSize < endMin {
   938  			endMin = startMin + pushByteSize
   939  		}
   940  
   941  		integer := interpreter.intPool.get()
   942  		stack.push(integer.SetBytes(common.RightPadBytes(contract.Code[startMin:endMin], pushByteSize)))
   943  
   944  		*pc += size
   945  		return nil, nil
   946  	}
   947  }
   948  
   949  // make dup instruction function
   950  func makeDup(size int64) executionFunc {
   951  	return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   952  		stack.dup(interpreter.intPool, int(size))
   953  		return nil, nil
   954  	}
   955  }
   956  
   957  // make swap instruction function
   958  func makeSwap(size int64) executionFunc {
   959  	// switch n + 1 otherwise n would be swapped with n
   960  	size++
   961  	return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
   962  		stack.swap(int(size))
   963  		return nil, nil
   964  	}
   965  }