roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

reworked stack

Browse Source
This commit is contained in:
obscuren 2015-03-10 00:25:27 +01:00
parent 0795fd2701
commit 9007f2bbdc
6 changed files with 361 additions and 451 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tests/vm/gh_test.go
View File

@ -11,7 +11,6 @@ import (
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/tests/helper"
"github.com/ethereum/go-ethereum/vm"
)
type Account struct {
@ -81,11 +80,6 @@ func RunVmTest(p string, t *testing.T) {
helper.CreateFileTests(t, p, &tests)
for name, test := range tests {
vm.Debug = true
helper.Logger.SetLogLevel(4)
if name != "addmod0" {
continue
}
db, _ := ethdb.NewMemDatabase()
statedb := state.New(nil, db)
for addr, account := range test.Pre {

9
vm/debugger.go
View File

@ -1,10 +1 @@
package vm
import "github.com/ethereum/go-ethereum/state"
type Debugger interface {
BreakHook(step int, op OpCode, mem *Memory, stack *Stack, object *state.StateObject) bool
StepHook(step int, op OpCode, mem *Memory, stack *Stack, object *state.StateObject) bool
BreakPoints() []int64
SetCode(byteCode []byte)
}

86
vm/gas.go Normal file
View File

@ -0,0 +1,86 @@
package vm
import "math/big"
type req struct {
stack int
gas *big.Int
}
var _baseCheck = map[OpCode]req{
// Req stack Gas price
ADD: {2, GasFastestStep},
LT: {2, GasFastestStep},
GT: {2, GasFastestStep},
SLT: {2, GasFastestStep},
SGT: {2, GasFastestStep},
EQ: {2, GasFastestStep},
ISZERO: {1, GasFastestStep},
SUB: {2, GasFastestStep},
AND: {2, GasFastestStep},
OR: {2, GasFastestStep},
XOR: {2, GasFastestStep},
NOT: {1, GasFastestStep},
BYTE: {2, GasFastestStep},
CALLDATALOAD: {1, GasFastestStep},
CALLDATACOPY: {3, GasFastestStep},
MLOAD: {1, GasFastestStep},
MSTORE: {2, GasFastestStep},
MSTORE8: {2, GasFastestStep},
CODECOPY: {3, GasFastestStep},
MUL: {2, GasFastStep},
DIV: {2, GasFastStep},
SDIV: {2, GasFastStep},
MOD: {2, GasFastStep},
SMOD: {2, GasFastStep},
SIGNEXTEND: {2, GasFastStep},
ADDMOD: {3, GasMidStep},
MULMOD: {3, GasMidStep},
JUMP: {1, GasMidStep},
JUMPI: {2, GasSlowStep},
EXP: {2, GasSlowStep},
ADDRESS: {0, GasQuickStep},
ORIGIN: {0, GasQuickStep},
CALLER: {0, GasQuickStep},
CALLVALUE: {0, GasQuickStep},
CODESIZE: {0, GasQuickStep},
GASPRICE: {0, GasQuickStep},
COINBASE: {0, GasQuickStep},
TIMESTAMP: {0, GasQuickStep},
NUMBER: {0, GasQuickStep},
CALLDATASIZE: {0, GasQuickStep},
DIFFICULTY: {0, GasQuickStep},
GASLIMIT: {0, GasQuickStep},
POP: {0, GasQuickStep},
PC: {0, GasQuickStep},
MSIZE: {0, GasQuickStep},
GAS: {0, GasQuickStep},
BLOCKHASH: {1, GasExtStep},
BALANCE: {0, GasExtStep},
EXTCODESIZE: {1, GasExtStep},
EXTCODECOPY: {4, GasExtStep},
SLOAD: {1, GasStorageGet},
SSTORE: {2, Zero},
SHA3: {1, GasSha3Base},
CREATE: {3, GasCreate},
CALL: {7, GasCall},
CALLCODE: {7, GasCall},
JUMPDEST: {0, GasJumpDest},
SUICIDE: {1, Zero},
RETURN: {2, Zero},
}
func baseCheck(op OpCode, stack *stack, gas *big.Int) {
if r, ok := _baseCheck[op]; ok {
stack.require(r.stack)
gas.Add(gas, r.gas)
}
}
func toWordSize(size *big.Int) *big.Int {
tmp := new(big.Int)
tmp.Add(size, u256(31))
tmp.Div(tmp, u256(32))
return tmp
}

72
vm/memory.go Normal file
View File

@ -0,0 +1,72 @@
package vm
import "fmt"
type Memory struct {
store []byte
}
func NewMemory() *Memory {
return &Memory{nil}
}
func (m *Memory) Set(offset, size uint64, value []byte) {
if len(value) > 0 {
totSize := offset + size
lenSize := uint64(len(m.store) - 1)
if totSize > lenSize {
// Calculate the diff between the sizes
diff := totSize - lenSize
if diff > 0 {
// Create a new empty slice and append it
newSlice := make([]byte, diff-1)
// Resize slice
m.store = append(m.store, newSlice...)
}
}
copy(m.store[offset:offset+size], value)
}
}
func (m *Memory) Resize(size uint64) {
if uint64(m.Len()) < size {
m.store = append(m.store, make([]byte, size-uint64(m.Len()))...)
}
}
func (self *Memory) Get(offset, size int64) (cpy []byte) {
if size == 0 {
return nil
}
if len(self.store) > int(offset) {
cpy = make([]byte, size)
copy(cpy, self.store[offset:offset+size])
return
}
return
}
func (m *Memory) Len() int {
return len(m.store)
}
func (m *Memory) Data() []byte {
return m.store
}
func (m *Memory) Print() {
fmt.Printf("### mem %d bytes ###\n", len(m.store))
if len(m.store) > 0 {
addr := 0
for i := 0; i+32 <= len(m.store); i += 32 {
fmt.Printf("%03d: % x\n", addr, m.store[i:i+32])
addr++
}
} else {
fmt.Println("-- empty --")
}
fmt.Println("####################")
}

188
vm/stack.go
View File

@ -5,98 +5,53 @@ import (
"math/big"
)
type OpType int
func newStack() *stack {
return &stack{}
}
const (
tNorm = iota
tData
tExtro
tCrypto
)
type TxCallback func(opType OpType) bool
// Simple push/pop stack mechanism
type Stack struct {
type stack struct {
data []*big.Int
ptr int
}
func NewStack() *Stack {
return &Stack{}
}
func (st *Stack) Data() []*big.Int {
return st.data
}
func (st *Stack) Len() int {
return len(st.data)
}
func (st *Stack) Pop() *big.Int {
str := st.data[len(st.data)-1]
copy(st.data[:len(st.data)-1], st.data[:len(st.data)-1])
st.data = st.data[:len(st.data)-1]
return str
}
func (st *Stack) Popn() (*big.Int, *big.Int) {
ints := st.data[len(st.data)-2:]
copy(st.data[:len(st.data)-2], st.data[:len(st.data)-2])
st.data = st.data[:len(st.data)-2]
return ints[0], ints[1]
}
func (st *Stack) Peek() *big.Int {
str := st.data[len(st.data)-1]
return str
}
func (st *Stack) Peekn() (*big.Int, *big.Int) {
ints := st.data[len(st.data)-2:]
return ints[0], ints[1]
}
func (st *Stack) Swapn(n int) (*big.Int, *big.Int) {
st.data[len(st.data)-n], st.data[len(st.data)-1] = st.data[len(st.data)-1], st.data[len(st.data)-n]
return st.data[len(st.data)-n], st.data[len(st.data)-1]
}
func (st *Stack) Dupn(n int) *big.Int {
st.Push(st.data[len(st.data)-n])
return st.Peek()
}
func (st *Stack) Push(d *big.Int) {
st.data = append(st.data, new(big.Int).Set(d))
}
func (st *Stack) Get(amount *big.Int) []*big.Int {
// offset + size <= len(data)
length := big.NewInt(int64(len(st.data)))
if amount.Cmp(length) <= 0 {
start := new(big.Int).Sub(length, amount)
return st.data[start.Int64():length.Int64()]
func (st *stack) push(d *big.Int) {
if len(st.data) > st.ptr {
st.data[st.ptr] = d
} else {
st.data = append(st.data, d)
}
return nil
st.ptr++
}
func (st *Stack) require(n int) {
if st.Len() < n {
panic(fmt.Sprintf("stack underflow (%d <=> %d)", st.Len(), n))
func (st *stack) pop() (ret *big.Int) {
st.ptr--
ret = st.data[st.ptr]
return
}
func (st *stack) len() int {
return st.ptr
}
func (st *stack) swap(n int) {
st.data[st.len()-n], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-n]
}
func (st *stack) dup(n int) {
st.push(st.data[st.len()-n])
}
func (st *stack) peek() *big.Int {
return st.data[st.len()-1]
}
func (st *stack) require(n int) {
if st.len() < n {
panic(fmt.Sprintf("stack underflow (%d <=> %d)", len(st.data), n))
}
}
func (st *Stack) Print() {
func (st *stack) Print() {
fmt.Println("### stack ###")
if len(st.data) > 0 {
for i, val := range st.data {
@ -107,72 +62,3 @@ func (st *Stack) Print() {
}
fmt.Println("#############")
}
type Memory struct {
store []byte
}
func NewMemory() *Memory {
return &Memory{nil}
}
func (m *Memory) Set(offset, size uint64, value []byte) {
if len(value) > 0 {
totSize := offset + size
lenSize := uint64(len(m.store) - 1)
if totSize > lenSize {
// Calculate the diff between the sizes
diff := totSize - lenSize
if diff > 0 {
// Create a new empty slice and append it
newSlice := make([]byte, diff-1)
// Resize slice
m.store = append(m.store, newSlice...)
}
}
copy(m.store[offset:offset+size], value)
}
}
func (m *Memory) Resize(size uint64) {
if uint64(m.Len()) < size {
m.store = append(m.store, make([]byte, size-uint64(m.Len()))...)
}
}
func (self *Memory) Get(offset, size int64) (cpy []byte) {
if size == 0 {
return nil
}
if len(self.store) > int(offset) {
cpy = make([]byte, size)
copy(cpy, self.store[offset:offset+size])
return
}
return
}
func (m *Memory) Len() int {
return len(m.store)
}
func (m *Memory) Data() []byte {
return m.store
}
func (m *Memory) Print() {
fmt.Printf("### mem %d bytes ###\n", len(m.store))
if len(m.store) > 0 {
addr := 0
for i := 0; i+32 <= len(m.store); i += 32 {
fmt.Printf("%03d: % x\n", addr, m.store[i:i+32])
addr++
}
} else {
fmt.Println("-- empty --")
}
fmt.Println("####################")
}

451
vm/vm.go
View File

@ -19,8 +19,6 @@ type Vm struct {
// For logging
debug bool
Dbg Debugger
BreakPoints []int64
Stepping bool
Fn string
@ -66,10 +64,9 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
destinations = analyseJumpDests(context.Code)
mem = NewMemory()
stack = NewStack()
stack = newStack()
pc uint64 = 0
step = 0
prevStep = 0
statedb = self.env.State()
jump = func(from uint64, to *big.Int) {
@ -93,7 +90,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
}
for {
prevStep = step
// The base for all big integer arithmetic
base := new(big.Int)
@ -101,11 +97,7 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
// Get the memory location of pc
op = context.GetOp(pc)
self.Printf("(pc) %-3d -o- %-14s (m) %-4d (s) %-4d ", pc, op.String(), mem.Len(), stack.Len())
if self.Dbg != nil {
//self.Dbg.Step(self, op, mem, stack, context)
}
self.Printf("(pc) %-3d -o- %-14s (m) %-4d (s) %-4d ", pc, op.String(), mem.Len(), stack.len())
newMemSize, gas := self.calculateGasAndSize(context, caller, op, statedb, mem, stack)
self.Printf("(g) %-3v (%v)", gas, context.Gas)
@ -125,40 +117,40 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
switch op {
// 0x20 range
case ADD:
x, y := stack.Popn()
x, y := stack.pop(), stack.pop()
self.Printf(" %v + %v", y, x)
base.Add(y, x)
base.Add(x, y)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
// pop result back on the stack
stack.push(base)
case SUB:
x, y := stack.Popn()
x, y := stack.pop(), stack.pop()
self.Printf(" %v - %v", y, x)
base.Sub(y, x)
base.Sub(x, y)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
// pop result back on the stack
stack.push(base)
case MUL:
x, y := stack.Popn()
x, y := stack.pop(), stack.pop()
self.Printf(" %v * %v", y, x)
base.Mul(y, x)
base.Mul(x, y)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
// pop result back on the stack
stack.push(base)
case DIV:
x, y := stack.Pop(), stack.Pop()
x, y := stack.pop(), stack.pop()
self.Printf(" %v / %v", x, y)
if y.Cmp(ethutil.Big0) != 0 {
@ -168,10 +160,10 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
// pop result back on the stack
stack.push(base)
case SDIV:
x, y := S256(stack.Pop()), S256(stack.Pop())
x, y := S256(stack.pop()), S256(stack.pop())
self.Printf(" %v / %v", x, y)
@ -191,9 +183,9 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
}
self.Printf(" = %v", base)
stack.Push(base)
stack.push(base)
case MOD:
x, y := stack.Pop(), stack.Pop()
x, y := stack.pop(), stack.pop()
self.Printf(" %v %% %v", x, y)
@ -206,9 +198,9 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
U256(base)
self.Printf(" = %v", base)
stack.Push(base)
stack.push(base)
case SMOD:
x, y := S256(stack.Pop()), S256(stack.Pop())
x, y := S256(stack.pop()), S256(stack.pop())
self.Printf(" %v %% %v", x, y)
@ -228,25 +220,25 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
}
self.Printf(" = %v", base)
stack.Push(base)
stack.push(base)
case EXP:
x, y := stack.Popn()
x, y := stack.pop(), stack.pop()
self.Printf(" %v ** %v", y, x)
self.Printf(" %v ** %v", x, y)
base.Exp(y, x, Pow256)
base.Exp(x, y, Pow256)
U256(base)
self.Printf(" = %v", base)
stack.Push(base)
stack.push(base)
case SIGNEXTEND:
back := stack.Pop().Uint64()
back := stack.pop().Uint64()
if back < 31 {
bit := uint(back*8 + 7)
num := stack.Pop()
num := stack.pop()
mask := new(big.Int).Lsh(ethutil.Big1, bit)
mask.Sub(mask, ethutil.Big1)
if ethutil.BitTest(num, int(bit)) {
@ -259,91 +251,91 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
self.Printf(" = %v", num)
stack.Push(num)
stack.push(num)
}
case NOT:
base.Sub(Pow256, stack.Pop()).Sub(base, ethutil.Big1)
base.Sub(Pow256, stack.pop()).Sub(base, ethutil.Big1)
// Not needed
base = U256(base)
stack.Push(base)
stack.push(base)
case LT:
x, y := stack.Popn()
self.Printf(" %v < %v", y, x)
x, y := stack.pop(), stack.pop()
self.Printf(" %v < %v", x, y)
// x < y
if y.Cmp(x) < 0 {
stack.Push(ethutil.BigTrue)
if x.Cmp(y) < 0 {
stack.push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
}
case GT:
x, y := stack.Popn()
self.Printf(" %v > %v", y, x)
x, y := stack.pop(), stack.pop()
self.Printf(" %v > %v", x, y)
// x > y
if y.Cmp(x) > 0 {
stack.Push(ethutil.BigTrue)
if x.Cmp(y) > 0 {
stack.push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
}
case SLT:
y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v < %v", y, x)
x, y := S256(stack.pop()), S256(stack.pop())
self.Printf(" %v < %v", x, y)
// x < y
if y.Cmp(S256(x)) < 0 {
stack.Push(ethutil.BigTrue)
if x.Cmp(S256(y)) < 0 {
stack.push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
}
case SGT:
y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v > %v", y, x)
x, y := S256(stack.pop()), S256(stack.pop())
self.Printf(" %v > %v", x, y)
// x > y
if y.Cmp(x) > 0 {
stack.Push(ethutil.BigTrue)
if x.Cmp(y) > 0 {
stack.push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
}
case EQ:
x, y := stack.Popn()
x, y := stack.pop(), stack.pop()
self.Printf(" %v == %v", y, x)
// x == y
if x.Cmp(y) == 0 {
stack.Push(ethutil.BigTrue)
stack.push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
}
case ISZERO:
x := stack.Pop()
x := stack.pop()
if x.Cmp(ethutil.BigFalse) > 0 {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
} else {
stack.Push(ethutil.BigTrue)
stack.push(ethutil.BigTrue)
}
// 0x10 range
case AND:
x, y := stack.Popn()
x, y := stack.pop(), stack.pop()
self.Printf(" %v & %v", y, x)
stack.Push(base.And(y, x))
stack.push(base.And(x, y))
case OR:
x, y := stack.Popn()
self.Printf(" %v | %v", y, x)
x, y := stack.pop(), stack.pop()
self.Printf(" %v | %v", x, y)
stack.Push(base.Or(y, x))
stack.push(base.Or(x, y))
case XOR:
x, y := stack.Popn()
self.Printf(" %v ^ %v", y, x)
x, y := stack.pop(), stack.pop()
self.Printf(" %v ^ %v", x, y)
stack.Push(base.Xor(y, x))
stack.push(base.Xor(x, y))
case BYTE:
val, th := stack.Popn()
th, val := stack.pop(), stack.pop()
if th.Cmp(big.NewInt(32)) < 0 {
byt := big.NewInt(int64(ethutil.LeftPadBytes(val.Bytes(), 32)[th.Int64()]))
@ -355,12 +347,12 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
self.Printf(" => 0x%x", base.Bytes())
stack.Push(base)
stack.push(base)
case ADDMOD:
x := stack.Pop()
y := stack.Pop()
z := stack.Pop()
x := stack.pop()
y := stack.pop()
z := stack.pop()
add := new(big.Int).Add(x, y)
if len(z.Bytes()) > 0 { // NOT 0x0
@ -371,12 +363,12 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
self.Printf(" %v + %v %% %v = %v", x, y, z, base)
stack.Push(base)
stack.push(base)
case MULMOD:
x := stack.Pop()
y := stack.Pop()
z := stack.Pop()
x := stack.pop()
y := stack.pop()
z := stack.pop()
mul := new(big.Int).Mul(x, y)
if len(z.Bytes()) > 0 { // NOT 0x0
@ -387,24 +379,24 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
self.Printf(" %v + %v %% %v = %v", x, y, z, base)
stack.Push(base)
stack.push(base)
// 0x20 range
case SHA3:
size, offset := stack.Popn()
size, offset := stack.pop(), stack.pop()
data := crypto.Sha3(mem.Get(offset.Int64(), size.Int64()))
stack.Push(ethutil.BigD(data))
stack.push(ethutil.BigD(data))
self.Printf(" => (%v) %x", size, data)
// 0x30 range
case ADDRESS:
stack.Push(ethutil.BigD(context.Address()))
stack.push(ethutil.BigD(context.Address()))
self.Printf(" => %x", context.Address())
case BALANCE:
addr := stack.Pop().Bytes()
addr := stack.pop().Bytes()
var balance *big.Int
if statedb.GetStateObject(addr) != nil {
balance = statedb.GetBalance(addr)
@ -412,27 +404,27 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
balance = base
}
stack.Push(balance)
stack.push(balance)
self.Printf(" => %v (%x)", balance, addr)
case ORIGIN:
origin := self.env.Origin()
stack.Push(ethutil.BigD(origin))
stack.push(ethutil.BigD(origin))
self.Printf(" => %x", origin)
case CALLER:
caller := context.caller.Address()
stack.Push(ethutil.BigD(caller))
stack.push(ethutil.BigD(caller))
self.Printf(" => %x", caller)
case CALLVALUE:
stack.Push(value)
stack.push(value)
self.Printf(" => %v", value)
case CALLDATALOAD:
var (
offset = stack.Pop()
offset = stack.pop()
data = make([]byte, 32)
lenData = big.NewInt(int64(len(callData)))
)
@ -446,18 +438,18 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
self.Printf(" => 0x%x", data)
stack.Push(ethutil.BigD(data))
stack.push(ethutil.BigD(data))
case CALLDATASIZE:
l := int64(len(callData))
stack.Push(big.NewInt(l))
stack.push(big.NewInt(l))
self.Printf(" => %d", l)
case CALLDATACOPY:
var (
size = uint64(len(callData))
mOff = stack.Pop().Uint64()
cOff = stack.Pop().Uint64()
l = stack.Pop().Uint64()
mOff = stack.pop().Uint64()
cOff = stack.pop().Uint64()
l = stack.pop().Uint64()
)
if cOff > size {
@ -475,7 +467,7 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
case CODESIZE, EXTCODESIZE:
var code []byte
if op == EXTCODESIZE {
addr := stack.Pop().Bytes()
addr := stack.pop().Bytes()
code = statedb.GetCode(addr)
} else {
@ -483,21 +475,21 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
}
l := big.NewInt(int64(len(code)))
stack.Push(l)
stack.push(l)
self.Printf(" => %d", l)
case CODECOPY, EXTCODECOPY:
var code []byte
if op == EXTCODECOPY {
code = statedb.GetCode(stack.Pop().Bytes())
code = statedb.GetCode(stack.pop().Bytes())
} else {
code = context.Code
}
context := NewContext(nil, nil, code, ethutil.Big0, ethutil.Big0)
var (
mOff = stack.Pop().Uint64()
cOff = stack.Pop().Uint64()
l = stack.Pop().Uint64()
mOff = stack.pop().Uint64()
cOff = stack.pop().Uint64()
l = stack.pop().Uint64()
)
codeCopy := context.GetCode(cOff, l)
@ -505,80 +497,80 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy)
case GASPRICE:
stack.Push(context.Price)
stack.push(context.Price)
self.Printf(" => %x", context.Price)
// 0x40 range
case BLOCKHASH:
num := stack.Pop()
num := stack.pop()
n := new(big.Int).Sub(self.env.BlockNumber(), ethutil.Big257)
if num.Cmp(n) > 0 && num.Cmp(self.env.BlockNumber()) < 0 {
stack.Push(ethutil.BigD(self.env.GetHash(num.Uint64())))
stack.push(ethutil.BigD(self.env.GetHash(num.Uint64())))
} else {
stack.Push(ethutil.Big0)
stack.push(ethutil.Big0)
}
self.Printf(" => 0x%x", stack.Peek().Bytes())
self.Printf(" => 0x%x", stack.peek().Bytes())
case COINBASE:
coinbase := self.env.Coinbase()
stack.Push(ethutil.BigD(coinbase))
stack.push(ethutil.BigD(coinbase))
self.Printf(" => 0x%x", coinbase)
case TIMESTAMP:
time := self.env.Time()
stack.Push(big.NewInt(time))
stack.push(big.NewInt(time))
self.Printf(" => 0x%x", time)
case NUMBER:
number := self.env.BlockNumber()
stack.Push(U256(number))
stack.push(U256(number))
self.Printf(" => 0x%x", number.Bytes())
case DIFFICULTY:
difficulty := self.env.Difficulty()
stack.Push(difficulty)
stack.push(difficulty)
self.Printf(" => 0x%x", difficulty.Bytes())
case GASLIMIT:
self.Printf(" => %v", self.env.GasLimit())
stack.Push(self.env.GasLimit())
stack.push(self.env.GasLimit())
// 0x50 range
case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
a := uint64(op - PUSH1 + 1)
byts := context.GetRangeValue(pc+1, a)
// Push value to stack
stack.Push(ethutil.BigD(byts))
// push value to stack
stack.push(ethutil.BigD(byts))
pc += a
step += int(op) - int(PUSH1) + 1
self.Printf(" => 0x%x", byts)
case POP:
stack.Pop()
stack.pop()
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
n := int(op - DUP1 + 1)
stack.Dupn(n)
stack.dup(n)
self.Printf(" => [%d] 0x%x", n, stack.Peek().Bytes())
self.Printf(" => [%d] 0x%x", n, stack.peek().Bytes())
case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
n := int(op - SWAP1 + 2)
x, y := stack.Swapn(n)
stack.swap(n)
self.Printf(" => [%d] %x [0] %x", n, x.Bytes(), y.Bytes())
self.Printf(" => [%d]", n)
case LOG0, LOG1, LOG2, LOG3, LOG4:
n := int(op - LOG0)
topics := make([][]byte, n)
mSize, mStart := stack.Popn()
mStart, mSize := stack.pop(), stack.pop()
for i := 0; i < n; i++ {
topics[i] = ethutil.LeftPadBytes(stack.Pop().Bytes(), 32)
topics[i] = ethutil.LeftPadBytes(stack.pop().Bytes(), 32)
}
data := mem.Get(mStart.Int64(), mSize.Int64())
@ -587,41 +579,40 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
self.Printf(" => %v", log)
case MLOAD:
offset := stack.Pop()
offset := stack.pop()
val := ethutil.BigD(mem.Get(offset.Int64(), 32))
stack.Push(val)
stack.push(val)
self.Printf(" => 0x%x", val.Bytes())
case MSTORE: // Store the value at stack top-1 in to memory at location stack top
// Pop value of the stack
val, mStart := stack.Popn()
// pop value of the stack
mStart, val := stack.pop(), stack.pop()
mem.Set(mStart.Uint64(), 32, ethutil.BigToBytes(val, 256))
self.Printf(" => 0x%x", val)
case MSTORE8:
off := stack.Pop()
val := stack.Pop()
off, val := stack.pop(), stack.pop()
mem.store[off.Int64()] = byte(val.Int64() & 0xff)
self.Printf(" => [%v] 0x%x", off, val)
case SLOAD:
loc := stack.Pop()
loc := stack.pop()
val := ethutil.BigD(statedb.GetState(context.Address(), loc.Bytes()))
stack.Push(val)
stack.push(val)
self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
case SSTORE:
val, loc := stack.Popn()
loc, val := stack.pop(), stack.pop()
statedb.SetState(context.Address(), loc.Bytes(), val)
self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
case JUMP:
jump(pc, stack.Pop())
jump(pc, stack.pop())
continue
case JUMPI:
cond, pos := stack.Popn()
pos, cond := stack.pop(), stack.pop()
if cond.Cmp(ethutil.BigTrue) >= 0 {
jump(pc, pos)
@ -633,19 +624,19 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
case JUMPDEST:
case PC:
stack.Push(big.NewInt(int64(pc)))
stack.push(big.NewInt(int64(pc)))
case MSIZE:
stack.Push(big.NewInt(int64(mem.Len())))
stack.push(big.NewInt(int64(mem.Len())))
case GAS:
stack.Push(context.Gas)
stack.push(context.Gas)
self.Printf(" => %x", context.Gas)
// 0x60 range
case CREATE:
var (
value = stack.Pop()
size, offset = stack.Popn()
value = stack.pop()
offset, size = stack.pop(), stack.pop()
input = mem.Get(offset.Int64(), size.Int64())
gas = new(big.Int).Set(context.Gas)
addr []byte
@ -655,7 +646,7 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
context.UseGas(context.Gas)
ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value)
if suberr != nil {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
self.Printf(" (*) 0x0 %v", suberr)
} else {
@ -668,23 +659,19 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
}
addr = ref.Address()
stack.Push(ethutil.BigD(addr))
stack.push(ethutil.BigD(addr))
}
// Debug hook
if self.Dbg != nil {
self.Dbg.SetCode(context.Code)
}
case CALL, CALLCODE:
gas := stack.Pop()
// Pop gas and value of the stack.
value, addr := stack.Popn()
gas := stack.pop()
// pop gas and value of the stack.
addr, value := stack.pop(), stack.pop()
value = U256(value)
// Pop input size and offset
inSize, inOffset := stack.Popn()
// Pop return size and offset
retSize, retOffset := stack.Popn()
// pop input size and offset
inOffset, inSize := stack.pop(), stack.pop()
// pop return size and offset
retOffset, retSize := stack.pop(), stack.pop()
address := ethutil.Address(addr.Bytes())
self.Printf(" => %x", address).Endl()
@ -707,30 +694,24 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
}
if err != nil {
stack.Push(ethutil.BigFalse)
stack.push(ethutil.BigFalse)
vmlogger.Debugln(err)
} else {
stack.Push(ethutil.BigTrue)
stack.push(ethutil.BigTrue)
mem.Set(retOffset.Uint64(), retSize.Uint64(), ret)
}
self.Printf("resume %x (%v)", context.Address(), context.Gas)
// Debug hook
if self.Dbg != nil {
self.Dbg.SetCode(context.Code)
}
case RETURN:
size, offset := stack.Popn()
offset, size := stack.pop(), stack.pop()
ret := mem.Get(offset.Int64(), size.Int64())
self.Printf(" => [%v, %v] (%d) 0x%x", offset, size, len(ret), ret).Endl()
return context.Return(ret), nil
case SUICIDE:
receiver := statedb.GetOrNewStateObject(stack.Pop().Bytes())
receiver := statedb.GetOrNewStateObject(stack.pop().Bytes())
balance := statedb.GetBalance(context.Address())
self.Printf(" => (%x) %v", receiver.Address()[:4], balance)
@ -753,117 +734,17 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
pc++
self.Endl()
if self.Dbg != nil {
for _, instrNo := range self.Dbg.BreakPoints() {
if pc == uint64(instrNo) {
self.Stepping = true
if !self.Dbg.BreakHook(prevStep, op, mem, stack, statedb.GetStateObject(context.Address())) {
return nil, nil
}
} else if self.Stepping {
if !self.Dbg.StepHook(prevStep, op, mem, stack, statedb.GetStateObject(context.Address())) {
return nil, nil
}
}
}
}
}
}
type req struct {
stack int
gas *big.Int
}
var _baseCheck = map[OpCode]req{
// Req Stack Gas price
ADD: {2, GasFastestStep},
LT: {2, GasFastestStep},
GT: {2, GasFastestStep},
SLT: {2, GasFastestStep},
SGT: {2, GasFastestStep},
EQ: {2, GasFastestStep},
ISZERO: {1, GasFastestStep},
SUB: {2, GasFastestStep},
AND: {2, GasFastestStep},
OR: {2, GasFastestStep},
XOR: {2, GasFastestStep},
NOT: {1, GasFastestStep},
BYTE: {2, GasFastestStep},
CALLDATALOAD: {1, GasFastestStep},
CALLDATACOPY: {3, GasFastestStep},
MLOAD: {1, GasFastestStep},
MSTORE: {2, GasFastestStep},
MSTORE8: {2, GasFastestStep},
CODECOPY: {3, GasFastestStep},
MUL: {2, GasFastStep},
DIV: {2, GasFastStep},
SDIV: {2, GasFastStep},
MOD: {2, GasFastStep},
SMOD: {2, GasFastStep},
SIGNEXTEND: {2, GasFastStep},
ADDMOD: {3, GasMidStep},
MULMOD: {3, GasMidStep},
JUMP: {1, GasMidStep},
JUMPI: {2, GasSlowStep},
EXP: {2, GasSlowStep},
ADDRESS: {0, GasQuickStep},
ORIGIN: {0, GasQuickStep},
CALLER: {0, GasQuickStep},
CALLVALUE: {0, GasQuickStep},
CODESIZE: {0, GasQuickStep},
GASPRICE: {0, GasQuickStep},
COINBASE: {0, GasQuickStep},
TIMESTAMP: {0, GasQuickStep},
NUMBER: {0, GasQuickStep},
CALLDATASIZE: {0, GasQuickStep},
DIFFICULTY: {0, GasQuickStep},
GASLIMIT: {0, GasQuickStep},
POP: {0, GasQuickStep},
PC: {0, GasQuickStep},
MSIZE: {0, GasQuickStep},
GAS: {0, GasQuickStep},
BLOCKHASH: {1, GasExtStep},
BALANCE: {0, GasExtStep},
EXTCODESIZE: {1, GasExtStep},
EXTCODECOPY: {4, GasExtStep},
SLOAD: {1, GasStorageGet},
SSTORE: {2, Zero},
SHA3: {1, GasSha3Base},
CREATE: {3, GasCreate},
CALL: {7, GasCall},
CALLCODE: {7, GasCall},
JUMPDEST: {0, GasJumpDest},
SUICIDE: {1, Zero},
RETURN: {2, Zero},
}
func baseCheck(op OpCode, stack *Stack, gas *big.Int) {
if r, ok := _baseCheck[op]; ok {
stack.require(r.stack)
gas.Add(gas, r.gas)
}
}
func toWordSize(size *big.Int) *big.Int {
tmp := new(big.Int)
tmp.Add(size, u256(31))
tmp.Div(tmp, u256(32))
return tmp
}
func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *Stack) (*big.Int, *big.Int) {
func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int) {
var (
gas = new(big.Int)
newMemSize *big.Int = new(big.Int)
)
baseCheck(op, stack, gas)
// Stack Check, memory resize & gas phase
// stack Check, memory resize & gas phase
switch op {
case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
gas.Set(GasFastestStep)
@ -879,7 +760,7 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo
n := int(op - LOG0)
stack.require(n + 2)
mSize, mStart := stack.Peekn()
mSize, mStart := stack.data[stack.len()-2], stack.data[stack.len()-1]
gas.Add(gas, GasLogBase)
gas.Add(gas, new(big.Int).Mul(big.NewInt(int64(n)), GasLogTopic))
@ -887,12 +768,12 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo
newMemSize = calcMemSize(mStart, mSize)
case EXP:
gas.Add(gas, new(big.Int).Mul(big.NewInt(int64(len(stack.data[stack.Len()-2].Bytes()))), GasExpByte))
gas.Add(gas, new(big.Int).Mul(big.NewInt(int64(len(stack.data[stack.len()-2].Bytes()))), GasExpByte))
case SSTORE:
stack.require(2)
var g *big.Int
y, x := stack.Peekn()
y, x := stack.data[stack.len()-2], stack.data[stack.len()-1]
val := statedb.GetState(context.Address(), x.Bytes())
if len(val) == 0 && len(y.Bytes()) > 0 {
// 0 => non 0
@ -911,51 +792,51 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo
statedb.Refund(self.env.Origin(), RefundSuicide)
}
case MLOAD:
newMemSize = calcMemSize(stack.Peek(), u256(32))
newMemSize = calcMemSize(stack.peek(), u256(32))
case MSTORE8:
newMemSize = calcMemSize(stack.Peek(), u256(1))
newMemSize = calcMemSize(stack.peek(), u256(1))
case MSTORE:
newMemSize = calcMemSize(stack.Peek(), u256(32))
newMemSize = calcMemSize(stack.peek(), u256(32))
case RETURN:
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-2])
case SHA3:
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-2])
words := toWordSize(stack.data[stack.Len()-2])
words := toWordSize(stack.data[stack.len()-2])
gas.Add(gas, words.Mul(words, GasSha3Word))
case CALLDATACOPY:
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-3])
words := toWordSize(stack.data[stack.Len()-3])
words := toWordSize(stack.data[stack.len()-3])
gas.Add(gas, words.Mul(words, GasCopyWord))
case CODECOPY:
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
newMemSize = calcMemSize(stack.peek(), stack.data[stack.len()-3])
words := toWordSize(stack.data[stack.Len()-3])
words := toWordSize(stack.data[stack.len()-3])
gas.Add(gas, words.Mul(words, GasCopyWord))
case EXTCODECOPY:
newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4])
newMemSize = calcMemSize(stack.data[stack.len()-2], stack.data[stack.len()-4])
words := toWordSize(stack.data[stack.Len()-4])
words := toWordSize(stack.data[stack.len()-4])
gas.Add(gas, words.Mul(words, GasCopyWord))
case CREATE:
newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-3])
newMemSize = calcMemSize(stack.data[stack.len()-2], stack.data[stack.len()-3])
case CALL, CALLCODE:
gas.Add(gas, stack.data[stack.Len()-1])
gas.Add(gas, stack.data[stack.len()-1])
if op == CALL {
if self.env.State().GetStateObject(stack.data[stack.Len()-2].Bytes()) == nil {
if self.env.State().GetStateObject(stack.data[stack.len()-2].Bytes()) == nil {
gas.Add(gas, GasCallNewAccount)
}
}
if len(stack.data[stack.Len()-3].Bytes()) > 0 {
if len(stack.data[stack.len()-3].Bytes()) > 0 {
gas.Add(gas, GasCallValueTransfer)
}
x := calcMemSize(stack.data[stack.Len()-6], stack.data[stack.Len()-7])
y := calcMemSize(stack.data[stack.Len()-4], stack.data[stack.Len()-5])
x := calcMemSize(stack.data[stack.len()-6], stack.data[stack.len()-7])
y := calcMemSize(stack.data[stack.len()-4], stack.data[stack.len()-5])
newMemSize = ethutil.BigMax(x, y)
}