588 lines
16 KiB
Go
588 lines
16 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
package vm
|
|
|
|
import (
|
|
"math/big"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/state"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
)
|
|
|
|
type instrFn func(instr instruction, env Environment, context *Context, memory *Memory, stack *stack)
|
|
type instrExFn func(instr instruction, ret *big.Int, env Environment, context *Context, memory *Memory, stack *stack)
|
|
|
|
type instruction struct {
|
|
op OpCode
|
|
pc uint64
|
|
fn instrFn
|
|
specFn instrExFn
|
|
data *big.Int
|
|
|
|
gas *big.Int
|
|
spop int
|
|
spush int
|
|
}
|
|
|
|
func opStaticJump(instr instruction, ret *big.Int, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
ret.Set(instr.data)
|
|
}
|
|
|
|
func opAdd(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
stack.push(U256(new(big.Int).Add(x, y)))
|
|
}
|
|
|
|
func opSub(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
stack.push(U256(new(big.Int).Sub(x, y)))
|
|
}
|
|
|
|
func opMul(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
stack.push(U256(new(big.Int).Mul(x, y)))
|
|
}
|
|
|
|
func opDiv(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
if y.Cmp(common.Big0) != 0 {
|
|
base.Div(x, y)
|
|
}
|
|
|
|
// pop result back on the stack
|
|
stack.push(U256(base))
|
|
}
|
|
|
|
func opSdiv(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
x, y := S256(stack.pop()), S256(stack.pop())
|
|
|
|
if y.Cmp(common.Big0) == 0 {
|
|
base.Set(common.Big0)
|
|
} else {
|
|
n := new(big.Int)
|
|
if new(big.Int).Mul(x, y).Cmp(common.Big0) < 0 {
|
|
n.SetInt64(-1)
|
|
} else {
|
|
n.SetInt64(1)
|
|
}
|
|
|
|
base.Div(x.Abs(x), y.Abs(y)).Mul(base, n)
|
|
|
|
U256(base)
|
|
}
|
|
|
|
stack.push(base)
|
|
}
|
|
|
|
func opMod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
if y.Cmp(common.Big0) == 0 {
|
|
base.Set(common.Big0)
|
|
} else {
|
|
base.Mod(x, y)
|
|
}
|
|
|
|
U256(base)
|
|
|
|
stack.push(base)
|
|
}
|
|
|
|
func opSmod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
x, y := S256(stack.pop()), S256(stack.pop())
|
|
|
|
if y.Cmp(common.Big0) == 0 {
|
|
base.Set(common.Big0)
|
|
} else {
|
|
n := new(big.Int)
|
|
if x.Cmp(common.Big0) < 0 {
|
|
n.SetInt64(-1)
|
|
} else {
|
|
n.SetInt64(1)
|
|
}
|
|
|
|
base.Mod(x.Abs(x), y.Abs(y)).Mul(base, n)
|
|
|
|
U256(base)
|
|
}
|
|
|
|
stack.push(base)
|
|
}
|
|
|
|
func opExp(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
base.Exp(x, y, Pow256)
|
|
|
|
U256(base)
|
|
|
|
stack.push(base)
|
|
}
|
|
|
|
func opSignExtend(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
back := stack.pop()
|
|
if back.Cmp(big.NewInt(31)) < 0 {
|
|
bit := uint(back.Uint64()*8 + 7)
|
|
num := stack.pop()
|
|
mask := new(big.Int).Lsh(common.Big1, bit)
|
|
mask.Sub(mask, common.Big1)
|
|
if common.BitTest(num, int(bit)) {
|
|
num.Or(num, mask.Not(mask))
|
|
} else {
|
|
num.And(num, mask)
|
|
}
|
|
|
|
num = U256(num)
|
|
|
|
stack.push(num)
|
|
}
|
|
}
|
|
|
|
func opNot(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(U256(new(big.Int).Not(stack.pop())))
|
|
}
|
|
|
|
func opLt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
// x < y
|
|
if x.Cmp(y) < 0 {
|
|
stack.push(common.BigTrue)
|
|
} else {
|
|
stack.push(common.BigFalse)
|
|
}
|
|
}
|
|
|
|
func opGt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
// x > y
|
|
if x.Cmp(y) > 0 {
|
|
stack.push(common.BigTrue)
|
|
} else {
|
|
stack.push(common.BigFalse)
|
|
}
|
|
}
|
|
|
|
func opSlt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := S256(stack.pop()), S256(stack.pop())
|
|
|
|
// x < y
|
|
if x.Cmp(S256(y)) < 0 {
|
|
stack.push(common.BigTrue)
|
|
} else {
|
|
stack.push(common.BigFalse)
|
|
}
|
|
}
|
|
|
|
func opSgt(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := S256(stack.pop()), S256(stack.pop())
|
|
|
|
// x > y
|
|
if x.Cmp(y) > 0 {
|
|
stack.push(common.BigTrue)
|
|
} else {
|
|
stack.push(common.BigFalse)
|
|
}
|
|
}
|
|
|
|
func opEq(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
// x == y
|
|
if x.Cmp(y) == 0 {
|
|
stack.push(common.BigTrue)
|
|
} else {
|
|
stack.push(common.BigFalse)
|
|
}
|
|
}
|
|
|
|
func opIszero(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x := stack.pop()
|
|
if x.Cmp(common.BigFalse) > 0 {
|
|
stack.push(common.BigFalse)
|
|
} else {
|
|
stack.push(common.BigTrue)
|
|
}
|
|
}
|
|
|
|
func opAnd(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
stack.push(new(big.Int).And(x, y))
|
|
}
|
|
func opOr(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
stack.push(new(big.Int).Or(x, y))
|
|
}
|
|
func opXor(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
x, y := stack.pop(), stack.pop()
|
|
|
|
stack.push(new(big.Int).Xor(x, y))
|
|
}
|
|
func opByte(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
th, val := stack.pop(), stack.pop()
|
|
|
|
if th.Cmp(big.NewInt(32)) < 0 {
|
|
byt := big.NewInt(int64(common.LeftPadBytes(val.Bytes(), 32)[th.Int64()]))
|
|
|
|
base.Set(byt)
|
|
} else {
|
|
base.Set(common.BigFalse)
|
|
}
|
|
|
|
stack.push(base)
|
|
}
|
|
func opAddmod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
x := stack.pop()
|
|
y := stack.pop()
|
|
z := stack.pop()
|
|
|
|
if z.Cmp(Zero) > 0 {
|
|
add := new(big.Int).Add(x, y)
|
|
base.Mod(add, z)
|
|
|
|
base = U256(base)
|
|
}
|
|
|
|
stack.push(base)
|
|
}
|
|
func opMulmod(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
base := new(big.Int)
|
|
x := stack.pop()
|
|
y := stack.pop()
|
|
z := stack.pop()
|
|
|
|
if z.Cmp(Zero) > 0 {
|
|
mul := new(big.Int).Mul(x, y)
|
|
base.Mod(mul, z)
|
|
|
|
U256(base)
|
|
}
|
|
|
|
stack.push(base)
|
|
}
|
|
|
|
func opSha3(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
offset, size := stack.pop(), stack.pop()
|
|
hash := crypto.Sha3(memory.Get(offset.Int64(), size.Int64()))
|
|
|
|
stack.push(common.BigD(hash))
|
|
}
|
|
|
|
func opAddress(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(common.Bytes2Big(context.Address().Bytes()))
|
|
}
|
|
|
|
func opBalance(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
addr := common.BigToAddress(stack.pop())
|
|
balance := env.State().GetBalance(addr)
|
|
|
|
stack.push(new(big.Int).Set(balance))
|
|
}
|
|
|
|
func opOrigin(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(env.Origin().Big())
|
|
}
|
|
|
|
func opCaller(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(common.Bytes2Big(context.caller.Address().Bytes()))
|
|
}
|
|
|
|
func opCallValue(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(new(big.Int).Set(context.value))
|
|
}
|
|
|
|
func opCalldataLoad(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(common.Bytes2Big(getData(context.Input, stack.pop(), common.Big32)))
|
|
}
|
|
|
|
func opCalldataSize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(big.NewInt(int64(len(context.Input))))
|
|
}
|
|
|
|
func opCalldataCopy(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
var (
|
|
mOff = stack.pop()
|
|
cOff = stack.pop()
|
|
l = stack.pop()
|
|
)
|
|
memory.Set(mOff.Uint64(), l.Uint64(), getData(context.Input, cOff, l))
|
|
}
|
|
|
|
func opExtCodeSize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
addr := common.BigToAddress(stack.pop())
|
|
l := big.NewInt(int64(len(env.State().GetCode(addr))))
|
|
stack.push(l)
|
|
}
|
|
|
|
func opCodeSize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
l := big.NewInt(int64(len(context.Code)))
|
|
stack.push(l)
|
|
}
|
|
|
|
func opCodeCopy(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
var (
|
|
mOff = stack.pop()
|
|
cOff = stack.pop()
|
|
l = stack.pop()
|
|
)
|
|
codeCopy := getData(context.Code, cOff, l)
|
|
|
|
memory.Set(mOff.Uint64(), l.Uint64(), codeCopy)
|
|
}
|
|
|
|
func opExtCodeCopy(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
var (
|
|
addr = common.BigToAddress(stack.pop())
|
|
mOff = stack.pop()
|
|
cOff = stack.pop()
|
|
l = stack.pop()
|
|
)
|
|
codeCopy := getData(env.State().GetCode(addr), cOff, l)
|
|
|
|
memory.Set(mOff.Uint64(), l.Uint64(), codeCopy)
|
|
}
|
|
|
|
func opGasprice(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(new(big.Int).Set(context.Price))
|
|
}
|
|
|
|
func opBlockhash(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
num := stack.pop()
|
|
|
|
n := new(big.Int).Sub(env.BlockNumber(), common.Big257)
|
|
if num.Cmp(n) > 0 && num.Cmp(env.BlockNumber()) < 0 {
|
|
stack.push(env.GetHash(num.Uint64()).Big())
|
|
} else {
|
|
stack.push(common.Big0)
|
|
}
|
|
}
|
|
|
|
func opCoinbase(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(env.Coinbase().Big())
|
|
}
|
|
|
|
func opTimestamp(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(new(big.Int).SetUint64(env.Time()))
|
|
}
|
|
|
|
func opNumber(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(U256(env.BlockNumber()))
|
|
}
|
|
|
|
func opDifficulty(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(new(big.Int).Set(env.Difficulty()))
|
|
}
|
|
|
|
func opGasLimit(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(new(big.Int).Set(env.GasLimit()))
|
|
}
|
|
|
|
func opPop(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.pop()
|
|
}
|
|
|
|
func opPush(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(new(big.Int).Set(instr.data))
|
|
}
|
|
|
|
func opDup(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.dup(int(instr.data.Int64()))
|
|
}
|
|
|
|
func opSwap(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.swap(int(instr.data.Int64()))
|
|
}
|
|
|
|
func opLog(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
n := int(instr.data.Int64())
|
|
topics := make([]common.Hash, n)
|
|
mStart, mSize := stack.pop(), stack.pop()
|
|
for i := 0; i < n; i++ {
|
|
topics[i] = common.BigToHash(stack.pop())
|
|
}
|
|
|
|
d := memory.Get(mStart.Int64(), mSize.Int64())
|
|
log := state.NewLog(context.Address(), topics, d, env.BlockNumber().Uint64())
|
|
env.AddLog(log)
|
|
}
|
|
|
|
func opMload(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
offset := stack.pop()
|
|
val := common.BigD(memory.Get(offset.Int64(), 32))
|
|
stack.push(val)
|
|
}
|
|
|
|
func opMstore(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
// pop value of the stack
|
|
mStart, val := stack.pop(), stack.pop()
|
|
memory.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256))
|
|
}
|
|
|
|
func opMstore8(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
off, val := stack.pop().Int64(), stack.pop().Int64()
|
|
memory.store[off] = byte(val & 0xff)
|
|
}
|
|
|
|
func opSload(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
loc := common.BigToHash(stack.pop())
|
|
val := env.State().GetState(context.Address(), loc).Big()
|
|
stack.push(val)
|
|
}
|
|
|
|
func opSstore(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
loc := common.BigToHash(stack.pop())
|
|
val := stack.pop()
|
|
|
|
env.State().SetState(context.Address(), loc, common.BigToHash(val))
|
|
}
|
|
|
|
func opJump(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
}
|
|
func opJumpi(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
}
|
|
func opJumpdest(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
}
|
|
|
|
func opPc(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(instr.data)
|
|
}
|
|
|
|
func opMsize(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(big.NewInt(int64(memory.Len())))
|
|
}
|
|
|
|
func opGas(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
stack.push(new(big.Int).Set(context.Gas))
|
|
}
|
|
|
|
func opCreate(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
var (
|
|
value = stack.pop()
|
|
offset, size = stack.pop(), stack.pop()
|
|
input = memory.Get(offset.Int64(), size.Int64())
|
|
gas = new(big.Int).Set(context.Gas)
|
|
addr common.Address
|
|
)
|
|
|
|
context.UseGas(context.Gas)
|
|
ret, suberr, ref := env.Create(context, input, gas, context.Price, value)
|
|
if suberr != nil {
|
|
stack.push(common.BigFalse)
|
|
|
|
} else {
|
|
// gas < len(ret) * Createinstr.dataGas == NO_CODE
|
|
dataGas := big.NewInt(int64(len(ret)))
|
|
dataGas.Mul(dataGas, params.CreateDataGas)
|
|
if context.UseGas(dataGas) {
|
|
ref.SetCode(ret)
|
|
}
|
|
addr = ref.Address()
|
|
|
|
stack.push(addr.Big())
|
|
|
|
}
|
|
}
|
|
|
|
func opCall(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
gas := stack.pop()
|
|
// pop gas and value of the stack.
|
|
addr, value := stack.pop(), stack.pop()
|
|
value = U256(value)
|
|
// pop input size and offset
|
|
inOffset, inSize := stack.pop(), stack.pop()
|
|
// pop return size and offset
|
|
retOffset, retSize := stack.pop(), stack.pop()
|
|
|
|
address := common.BigToAddress(addr)
|
|
|
|
// Get the arguments from the memory
|
|
args := memory.Get(inOffset.Int64(), inSize.Int64())
|
|
|
|
if len(value.Bytes()) > 0 {
|
|
gas.Add(gas, params.CallStipend)
|
|
}
|
|
|
|
ret, err := env.Call(context, address, args, gas, context.Price, value)
|
|
|
|
if err != nil {
|
|
stack.push(common.BigFalse)
|
|
|
|
} else {
|
|
stack.push(common.BigTrue)
|
|
|
|
memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
|
|
}
|
|
}
|
|
|
|
func opCallCode(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
gas := stack.pop()
|
|
// pop gas and value of the stack.
|
|
addr, value := stack.pop(), stack.pop()
|
|
value = U256(value)
|
|
// pop input size and offset
|
|
inOffset, inSize := stack.pop(), stack.pop()
|
|
// pop return size and offset
|
|
retOffset, retSize := stack.pop(), stack.pop()
|
|
|
|
address := common.BigToAddress(addr)
|
|
|
|
// Get the arguments from the memory
|
|
args := memory.Get(inOffset.Int64(), inSize.Int64())
|
|
|
|
if len(value.Bytes()) > 0 {
|
|
gas.Add(gas, params.CallStipend)
|
|
}
|
|
|
|
ret, err := env.CallCode(context, address, args, gas, context.Price, value)
|
|
|
|
if err != nil {
|
|
stack.push(common.BigFalse)
|
|
|
|
} else {
|
|
stack.push(common.BigTrue)
|
|
|
|
memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
|
|
}
|
|
}
|
|
|
|
func opReturn(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {}
|
|
func opStop(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {}
|
|
|
|
func opSuicide(instr instruction, env Environment, context *Context, memory *Memory, stack *stack) {
|
|
receiver := env.State().GetOrNewStateObject(common.BigToAddress(stack.pop()))
|
|
balance := env.State().GetBalance(context.Address())
|
|
|
|
receiver.AddBalance(balance)
|
|
|
|
env.State().Delete(context.Address())
|
|
}
|