From f0ec75123747424ab2606fe6ef650b13520fac22 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 6 Jan 2015 20:22:31 +0100 Subject: Updated tests --- vm/common.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'vm') diff --git a/vm/common.go b/vm/common.go index acf18eede..f19b0fe4b 100644 --- a/vm/common.go +++ b/vm/common.go @@ -49,7 +49,7 @@ var ( S256 = ethutil.S256 ) -const MaxCallDepth = 1024 +const MaxCallDepth = 1025 func calcMemSize(off, l *big.Int) *big.Int { if l.Cmp(ethutil.Big0) == 0 { -- cgit v1.2.3 From 5c8c0ae04e83389e3b97c527c11c819f219e344d Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 9 Jan 2015 15:30:46 +0100 Subject: Fixed size 0 bug --- vm/stack.go | 4 ++++ vm/vm_debug.go | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) (limited to 'vm') diff --git a/vm/stack.go b/vm/stack.go index b9eaa10cd..f20470db3 100644 --- a/vm/stack.go +++ b/vm/stack.go @@ -152,6 +152,10 @@ func (m *Memory) Get(offset, size int64) []byte { } func (self *Memory) Geti(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]) diff --git a/vm/vm_debug.go b/vm/vm_debug.go index 92e4154e4..656487c9b 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -34,7 +34,7 @@ func NewDebugVm(env Environment) *DebugVm { lt = LogTyDiff } - return &DebugVm{env: env, logTy: lt, Recoverable: true} + return &DebugVm{env: env, logTy: lt, Recoverable: false} } func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { -- cgit v1.2.3 From 6eb455032cdf9fec37f7a2abfc833de64003beca Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 9 Jan 2015 15:32:14 +0100 Subject: recover --- vm/vm_debug.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'vm') diff --git a/vm/vm_debug.go b/vm/vm_debug.go index 656487c9b..92e4154e4 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -34,7 +34,7 @@ func NewDebugVm(env Environment) *DebugVm { lt = LogTyDiff } - return &DebugVm{env: env, logTy: lt, Recoverable: false} + return &DebugVm{env: env, logTy: lt, Recoverable: true} } func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { -- cgit v1.2.3 From 905b8cc82f3dc29131f45ccf29bd1d6c967fe132 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 9 Jan 2015 17:38:35 +0100 Subject: mem fixes for vm. Changed uncle inclusion tests --- vm/stack.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'vm') diff --git a/vm/stack.go b/vm/stack.go index f20470db3..e31f3eb57 100644 --- a/vm/stack.go +++ b/vm/stack.go @@ -142,6 +142,10 @@ func (m *Memory) Resize(size uint64) { } func (m *Memory) Get(offset, size int64) []byte { + if size == 0 { + return nil + } + if len(m.store) > int(offset) { end := int(math.Min(float64(len(m.store)), float64(offset+size))) -- cgit v1.2.3 From 8c7b764d47ce55ba6abe437ae8232cc537c4e0d9 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 9 Jan 2015 21:18:34 +0100 Subject: updated tests --- vm/stack.go | 17 +---------------- vm/vm_debug.go | 2 +- 2 files changed, 2 insertions(+), 17 deletions(-) (limited to 'vm') diff --git a/vm/stack.go b/vm/stack.go index e31f3eb57..a9aafdb9d 100644 --- a/vm/stack.go +++ b/vm/stack.go @@ -2,7 +2,6 @@ package vm import ( "fmt" - "math" "math/big" ) @@ -141,21 +140,7 @@ func (m *Memory) Resize(size uint64) { } } -func (m *Memory) Get(offset, size int64) []byte { - if size == 0 { - return nil - } - - if len(m.store) > int(offset) { - end := int(math.Min(float64(len(m.store)), float64(offset+size))) - - return m.store[offset:end] - } - - return nil -} - -func (self *Memory) Geti(offset, size int64) (cpy []byte) { +func (self *Memory) Get(offset, size int64) (cpy []byte) { if size == 0 { return nil } diff --git a/vm/vm_debug.go b/vm/vm_debug.go index 92e4154e4..04ba8190d 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -583,7 +583,7 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * topics[i] = ethutil.LeftPadBytes(stack.Pop().Bytes(), 32) } - data := mem.Geti(mStart.Int64(), mSize.Int64()) + data := mem.Get(mStart.Int64(), mSize.Int64()) log := &Log{context.Address(), topics, data} self.env.AddLog(log) -- cgit v1.2.3 From 00348756bce00c2d19f16ce8df5eff7a62f5cfc6 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 12 Jan 2015 13:49:47 +0100 Subject: updated tests --- vm/context.go | 7 +++++++ vm/vm_debug.go | 13 ++----------- 2 files changed, 9 insertions(+), 11 deletions(-) (limited to 'vm') diff --git a/vm/context.go b/vm/context.go index d14df1aa7..b48f1a657 100644 --- a/vm/context.go +++ b/vm/context.go @@ -61,6 +61,13 @@ func (c *Context) GetRangeValue(x, size uint64) []byte { return ethutil.LeftPadBytes(c.Code[x:y], int(size)) } +func (c *Context) GetCode(x, size uint64) []byte { + x = uint64(math.Min(float64(x), float64(len(c.Code)))) + y := uint64(math.Min(float64(x+size), float64(len(c.Code)))) + + return ethutil.RightPadBytes(c.Code[x:y], int(size)) +} + func (c *Context) Return(ret []byte) []byte { // Return the remaining gas to the caller c.caller.ReturnGas(c.Gas, c.Price) diff --git a/vm/vm_debug.go b/vm/vm_debug.go index 04ba8190d..eec8c518f 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -2,7 +2,6 @@ package vm import ( "fmt" - "math" "math/big" "github.com/ethereum/go-ethereum/crypto" @@ -491,21 +490,13 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * } else { code = context.Code } - + context := NewContext(nil, nil, code, ethutil.Big0, ethutil.Big0) var ( - size = uint64(len(code)) mOff = stack.Pop().Uint64() cOff = stack.Pop().Uint64() l = stack.Pop().Uint64() ) - - if cOff > size { - cOff = 0 - l = 0 - } else if cOff+l > size { - l = uint64(math.Min(float64(cOff+l), float64(size))) - } - codeCopy := code[cOff : cOff+l] + codeCopy := context.GetCode(cOff, l) mem.Set(mOff, l, codeCopy) -- cgit v1.2.3 From 75cd9cd2de315f8680ff6a382e9b3bd48e17ecad Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 12 Jan 2015 14:40:40 +0100 Subject: updated tests --- vm/vm_debug.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'vm') diff --git a/vm/vm_debug.go b/vm/vm_debug.go index eec8c518f..fee42d3d8 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -743,9 +743,7 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * default: vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op) - context.ReturnGas(big.NewInt(1), nil) - - return context.Return(nil), fmt.Errorf("Invalid opcode %x", op) + panic(fmt.Errorf("Invalid opcode %x", op)) } pc++ -- cgit v1.2.3 From 8a1b51c716abdc21a8af43282e106d77eda3706b Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 12 Jan 2015 16:13:30 +0100 Subject: updated tests --- vm/vm_debug.go | 40 ++++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 18 deletions(-) (limited to 'vm') diff --git a/vm/vm_debug.go b/vm/vm_debug.go index fee42d3d8..81db45f19 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -48,6 +48,12 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * }) context := NewContext(caller, me, code, gas, price) + vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData) + + if p := Precompiled[string(me.Address())]; p != nil { + return self.RunPrecompiled(p, callData, context) + } + if self.Recoverable { // Recover from any require exception defer func() { @@ -64,10 +70,6 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * }() } - if p := Precompiled[string(me.Address())]; p != nil { - return self.RunPrecompiled(p, callData, context) - } - var ( op OpCode @@ -94,8 +96,6 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * } ) - vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData) - // Don't bother with the execution if there's no code. if len(code) == 0 { return context.Return(nil), nil @@ -368,12 +368,14 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * y := stack.Pop() z := stack.Pop() - base.Add(x, y) - base.Mod(base, z) + add := new(big.Int).Add(x, y) + if len(z.Bytes()) > 0 { // NOT 0x0 + base.Mod(add, z) - U256(base) + U256(base) + } - self.Printf(" = %v", base) + self.Printf(" %v + %v %% %v = %v", x, y, z, base) stack.Push(base) case MULMOD: @@ -382,12 +384,14 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * y := stack.Pop() z := stack.Pop() - base.Mul(x, y) - base.Mod(base, z) + mul := new(big.Int).Mul(x, y) + if len(z.Bytes()) > 0 { // NOT 0x0 + base.Mod(mul, z) - U256(base) + U256(base) + } - self.Printf(" = %v", base) + self.Printf(" %v + %v %% %v = %v", x, y, z, base) stack.Push(base) @@ -541,6 +545,8 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * self.Printf(" => 0x%x", difficulty.Bytes()) case GASLIMIT: + self.Printf(" => %v", self.env.GasLimit()) + stack.Push(self.env.GasLimit()) // 0x50 range @@ -933,13 +939,11 @@ func (self *DebugVm) RunPrecompiled(p *PrecompiledAccount, callData []byte, cont return context.Return(ret), nil } else { - self.Endl() + self.Printf("NATIVE_FUNC => failed").Endl() tmp := new(big.Int).Set(context.Gas) - context.UseGas(context.Gas) - - return context.Return(nil), OOG(gas, tmp) + panic(OOG(gas, tmp).Error()) } } -- cgit v1.2.3 From ba225017c4c1b60dff57ad56da4e8972812a17e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Bylica?= Date: Mon, 12 Jan 2015 19:40:14 +0100 Subject: JitVm struct stub. Forwards calls to DebugVm. --- vm/common.go | 1 + vm/vm.go | 2 ++ vm/vm_jit.go | 31 +++++++++++++++++++++++++++++++ 3 files changed, 34 insertions(+) create mode 100644 vm/vm_jit.go (limited to 'vm') diff --git a/vm/common.go b/vm/common.go index f19b0fe4b..ed250dab1 100644 --- a/vm/common.go +++ b/vm/common.go @@ -14,6 +14,7 @@ type Type int const ( StandardVmTy Type = iota DebugVmTy + JitVmTy MaxVmTy ) diff --git a/vm/vm.go b/vm/vm.go index a5ea297b3..b795bb86e 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -15,6 +15,8 @@ func New(env Environment, typ Type) VirtualMachine { switch typ { case DebugVmTy: return NewDebugVm(env) + case JitVmTy: + return NewJitVm(env) default: return &Vm{env: env} } diff --git a/vm/vm_jit.go b/vm/vm_jit.go new file mode 100644 index 000000000..c715abab0 --- /dev/null +++ b/vm/vm_jit.go @@ -0,0 +1,31 @@ +package vm + +import "math/big" + +type JitVm struct { + env Environment + backup *DebugVm +} + +func NewJitVm(env Environment) *JitVm { + backupVm := NewDebugVm(env) + return &JitVm{env: env, backup: backupVm} +} + +func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { + return self.backup.Run(me, caller, code, value, gas, price, callData) +} + +func (self *JitVm) Printf(format string, v ...interface{}) VirtualMachine { + return self.backup.Printf(format, v) +} + +func (self *JitVm) Endl() VirtualMachine { + return self.backup.Endl() +} + +func (self *JitVm) Env() Environment { + return self.env +} + +//go is nice \ No newline at end of file -- cgit v1.2.3 From 750d70c2024784227c8ac920d651c337c2de207e Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 13 Jan 2015 00:25:45 +0100 Subject: updated tests --- vm/vm_debug.go | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) (limited to 'vm') diff --git a/vm/vm_debug.go b/vm/vm_debug.go index 81db45f19..255faefb0 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -50,10 +50,6 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData) - if p := Precompiled[string(me.Address())]; p != nil { - return self.RunPrecompiled(p, callData, context) - } - if self.Recoverable { // Recover from any require exception defer func() { @@ -70,6 +66,10 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * }() } + if p := Precompiled[string(me.Address())]; p != nil { + return self.RunPrecompiled(p, callData, context) + } + var ( op OpCode @@ -513,10 +513,12 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * // 0x40 range case BLOCKHASH: num := stack.Pop() - if num.Cmp(new(big.Int).Sub(self.env.BlockNumber(), ethutil.Big256)) < 0 { - stack.Push(ethutil.Big0) - } else { + + n := U256(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()))) + } else { + stack.Push(ethutil.Big0) } self.Printf(" => 0x%x", stack.Peek().Bytes()) -- cgit v1.2.3 From 4704a0a288af89795e251db98eb253de117ff031 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 13 Jan 2015 10:30:52 +0100 Subject: remove pre compiled for tests --- vm/address.go | 57 +++++++++++++++++++++++++++++++-------------------------- 1 file changed, 31 insertions(+), 26 deletions(-) (limited to 'vm') diff --git a/vm/address.go b/vm/address.go index be4284421..1c9369ab7 100644 --- a/vm/address.go +++ b/vm/address.go @@ -20,32 +20,37 @@ func (self PrecompiledAccount) Call(in []byte) []byte { return self.fn(in) } -var Precompiled = map[string]*PrecompiledAccount{ - // ECRECOVER - string(ethutil.LeftPadBytes([]byte{1}, 20)): &PrecompiledAccount{func(l int) *big.Int { - return GasEcrecover - }, ecrecoverFunc}, - - // SHA256 - string(ethutil.LeftPadBytes([]byte{2}, 20)): &PrecompiledAccount{func(l int) *big.Int { - n := big.NewInt(int64(l+31)/32 + 1) - n.Mul(n, GasSha256) - return n - }, sha256Func}, - - // RIPEMD160 - string(ethutil.LeftPadBytes([]byte{3}, 20)): &PrecompiledAccount{func(l int) *big.Int { - n := big.NewInt(int64(l+31)/32 + 1) - n.Mul(n, GasRipemd) - return n - }, ripemd160Func}, - - string(ethutil.LeftPadBytes([]byte{4}, 20)): &PrecompiledAccount{func(l int) *big.Int { - n := big.NewInt(int64(l+31)/32 + 1) - n.Mul(n, GasMemCpy) - - return n - }, memCpy}, +var Precompiled = PrecompiledContracts() + +// XXX Could set directly. Testing requires resetting and setting of pre compiled contracts. +func PrecompiledContracts() map[string]*PrecompiledAccount { + return map[string]*PrecompiledAccount{ + // ECRECOVER + string(ethutil.LeftPadBytes([]byte{1}, 20)): &PrecompiledAccount{func(l int) *big.Int { + return GasEcrecover + }, ecrecoverFunc}, + + // SHA256 + string(ethutil.LeftPadBytes([]byte{2}, 20)): &PrecompiledAccount{func(l int) *big.Int { + n := big.NewInt(int64(l+31)/32 + 1) + n.Mul(n, GasSha256) + return n + }, sha256Func}, + + // RIPEMD160 + string(ethutil.LeftPadBytes([]byte{3}, 20)): &PrecompiledAccount{func(l int) *big.Int { + n := big.NewInt(int64(l+31)/32 + 1) + n.Mul(n, GasRipemd) + return n + }, ripemd160Func}, + + string(ethutil.LeftPadBytes([]byte{4}, 20)): &PrecompiledAccount{func(l int) *big.Int { + n := big.NewInt(int64(l+31)/32 + 1) + n.Mul(n, GasMemCpy) + + return n + }, memCpy}, + } } func sha256Func(in []byte) []byte { -- cgit v1.2.3 From 82beaabf6a8b5a146a38e1d6a31a78157c79a0cf Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 13 Jan 2015 14:57:51 +0100 Subject: Fixed consensus issue --- vm/vm_debug.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'vm') diff --git a/vm/vm_debug.go b/vm/vm_debug.go index 255faefb0..5949ea5d9 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -663,8 +663,8 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * context.UseGas(context.Gas) - ret, err, ref := self.env.Create(context, addr, input, gas, price, value) - if err != nil { + ret, suberr, ref := self.env.Create(context, addr, input, gas, price, value) + if suberr != nil { stack.Push(ethutil.BigFalse) self.Printf("CREATE err %v", err) -- cgit v1.2.3 From bb55307a9d8fa73b0fbc0727f8b80925a87627b7 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 13 Jan 2015 20:31:31 +0100 Subject: Updated tests --- vm/vm_debug.go | 24 +++++++----------------- 1 file changed, 7 insertions(+), 17 deletions(-) (limited to 'vm') diff --git a/vm/vm_debug.go b/vm/vm_debug.go index 5949ea5d9..44137568e 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -643,32 +643,21 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * case CREATE: var ( - err error value = stack.Pop() size, offset = stack.Popn() input = mem.Get(offset.Int64(), size.Int64()) gas = new(big.Int).Set(context.Gas) - - // Snapshot the current stack so we are able to - // revert back to it later. - //snapshot = self.env.State().Copy() + addr []byte ) - // Generate a new address - n := statedb.GetNonce(context.Address()) - addr := crypto.CreateAddress(context.Address(), n) - statedb.SetNonce(context.Address(), n+1) - - self.Printf(" (*) %x", addr).Endl() - context.UseGas(context.Gas) - - ret, suberr, ref := self.env.Create(context, addr, input, gas, price, value) + ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value) if suberr != nil { stack.Push(ethutil.BigFalse) - self.Printf("CREATE err %v", err) + self.Printf(" (*) 0x0 %v", suberr) } else { + // gas < len(ret) * CreateDataGas == NO_CODE dataGas := big.NewInt(int64(len(ret))) dataGas.Mul(dataGas, GasCreateByte) @@ -676,11 +665,12 @@ func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price * ref.SetCode(ret) msg.Output = ret } + addr = ref.Address() stack.Push(ethutil.BigD(addr)) - } - self.Endl() + self.Printf(" (*) %x", addr) + } // Debug hook if self.Dbg != nil { -- cgit v1.2.3 From 89c69a1d257daf973690a7fb96d2aa2b9d0849ec Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 19 Jan 2015 11:18:34 +0100 Subject: VmDebug => StdVm --- vm/common.go | 5 +- vm/vm.go | 967 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- vm/vm_debug.go | 961 -------------------------------------------------------- vm/vm_jit.go | 8 +- 4 files changed, 951 insertions(+), 990 deletions(-) delete mode 100644 vm/vm_debug.go (limited to 'vm') diff --git a/vm/common.go b/vm/common.go index ed250dab1..ff187001f 100644 --- a/vm/common.go +++ b/vm/common.go @@ -9,11 +9,10 @@ import ( var vmlogger = logger.NewLogger("VM") -type Type int +type Type byte const ( - StandardVmTy Type = iota - DebugVmTy + StdVmTy Type = iota JitVmTy MaxVmTy diff --git a/vm/vm.go b/vm/vm.go index b795bb86e..6aa39797e 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -1,38 +1,961 @@ package vm -import "math/big" +import ( + "fmt" + "math/big" -// BIG FAT WARNING. THIS VM IS NOT YET IS USE! -// I want to get all VM tests pass first before updating this VM + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/state" +) type Vm struct { - env Environment - err error - depth int + env Environment + + logTy byte + logStr string + + err error + + // Debugging + Dbg Debugger + + BreakPoints []int64 + Stepping bool + Fn string + + Recoverable bool +} + +func NewVm(env Environment) *Vm { + lt := LogTyPretty + if ethutil.Config.Diff { + lt = LogTyDiff + } + + return &Vm{env: env, logTy: lt, Recoverable: true} +} + +func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { + self.env.SetDepth(self.env.Depth() + 1) + + msg := self.env.State().Manifest().AddMessage(&state.Message{ + To: me.Address(), From: caller.Address(), + Input: callData, + Origin: self.env.Origin(), + Timestamp: self.env.Time(), Coinbase: self.env.Coinbase(), Number: self.env.BlockNumber(), + Value: value, + }) + context := NewContext(caller, me, code, gas, price) + + vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData) + + if self.Recoverable { + // Recover from any require exception + defer func() { + if r := recover(); r != nil { + self.Printf(" %v", r).Endl() + + context.UseGas(context.Gas) + + ret = context.Return(nil) + + err = fmt.Errorf("%v", r) + + } + }() + } + + if p := Precompiled[string(me.Address())]; p != nil { + return self.RunPrecompiled(p, callData, context) + } + + var ( + op OpCode + + destinations = analyseJumpDests(context.Code) + mem = NewMemory() + stack = NewStack() + pc uint64 = 0 + step = 0 + prevStep = 0 + statedb = self.env.State() + + jump = func(from uint64, to *big.Int) { + p := to.Uint64() + + nop := context.GetOp(p) + if !destinations.Has(p) { + panic(fmt.Sprintf("invalid jump destination (%v) %v", nop, p)) + } + + self.Printf(" ~> %v", to) + pc = to.Uint64() + + self.Endl() + } + ) + + // Don't bother with the execution if there's no code. + if len(code) == 0 { + return context.Return(nil), nil + } + + for { + prevStep = step + // The base for all big integer arithmetic + base := new(big.Int) + + step++ + // 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()) + + newMemSize, gas := self.calculateGasAndSize(context, caller, op, statedb, mem, stack) + + self.Printf("(g) %-3v (%v)", gas, context.Gas) + + if !context.UseGas(gas) { + self.Endl() + + tmp := new(big.Int).Set(context.Gas) + + context.UseGas(context.Gas) + + return context.Return(nil), OOG(gas, tmp) + } + + mem.Resize(newMemSize.Uint64()) + + switch op { + // 0x20 range + case ADD: + x, y := stack.Popn() + self.Printf(" %v + %v", y, x) + + base.Add(y, x) + + U256(base) + + self.Printf(" = %v", base) + // Pop result back on the stack + stack.Push(base) + case SUB: + x, y := stack.Popn() + self.Printf(" %v - %v", y, x) + + base.Sub(y, x) + + U256(base) + + self.Printf(" = %v", base) + // Pop result back on the stack + stack.Push(base) + case MUL: + x, y := stack.Popn() + self.Printf(" %v * %v", y, x) + + base.Mul(y, x) + + U256(base) + + self.Printf(" = %v", base) + // Pop result back on the stack + stack.Push(base) + case DIV: + x, y := stack.Pop(), stack.Pop() + self.Printf(" %v / %v", x, y) + + if y.Cmp(ethutil.Big0) != 0 { + base.Div(x, y) + } + + U256(base) + + self.Printf(" = %v", base) + // Pop result back on the stack + stack.Push(base) + case SDIV: + x, y := S256(stack.Pop()), S256(stack.Pop()) + + self.Printf(" %v / %v", x, y) + + if y.Cmp(ethutil.Big0) == 0 { + base.Set(ethutil.Big0) + } else { + n := new(big.Int) + if new(big.Int).Mul(x, y).Cmp(ethutil.Big0) < 0 { + n.SetInt64(-1) + } else { + n.SetInt64(1) + } + + base.Div(x.Abs(x), y.Abs(y)).Mul(base, n) + + U256(base) + } + + self.Printf(" = %v", base) + stack.Push(base) + case MOD: + x, y := stack.Pop(), stack.Pop() + + self.Printf(" %v %% %v", x, y) + + if y.Cmp(ethutil.Big0) == 0 { + base.Set(ethutil.Big0) + } else { + base.Mod(x, y) + } + + U256(base) + + self.Printf(" = %v", base) + stack.Push(base) + case SMOD: + x, y := S256(stack.Pop()), S256(stack.Pop()) + + self.Printf(" %v %% %v", x, y) + + if y.Cmp(ethutil.Big0) == 0 { + base.Set(ethutil.Big0) + } else { + n := new(big.Int) + if x.Cmp(ethutil.Big0) < 0 { + n.SetInt64(-1) + } else { + n.SetInt64(1) + } + + base.Mod(x.Abs(x), y.Abs(y)).Mul(base, n) + + U256(base) + } + + self.Printf(" = %v", base) + stack.Push(base) + + case EXP: + x, y := stack.Popn() + + self.Printf(" %v ** %v", y, x) + + base.Exp(y, x, Pow256) + + U256(base) + + self.Printf(" = %v", base) + + stack.Push(base) + case SIGNEXTEND: + back := stack.Pop().Uint64() + if back < 31 { + bit := uint(back*8 + 7) + num := stack.Pop() + mask := new(big.Int).Lsh(ethutil.Big1, bit) + mask.Sub(mask, ethutil.Big1) + if ethutil.BitTest(num, int(bit)) { + num.Or(num, mask.Not(mask)) + } else { + num.And(num, mask) + } + + num = U256(num) + + self.Printf(" = %v", num) + + stack.Push(num) + } + case NOT: + base.Sub(Pow256, stack.Pop()).Sub(base, ethutil.Big1) + + // Not needed + //base = U256(base) + + stack.Push(base) + case LT: + x, y := stack.Popn() + self.Printf(" %v < %v", y, x) + // x < y + if y.Cmp(x) < 0 { + stack.Push(ethutil.BigTrue) + } else { + stack.Push(ethutil.BigFalse) + } + case GT: + x, y := stack.Popn() + self.Printf(" %v > %v", y, x) + + // x > y + if y.Cmp(x) > 0 { + stack.Push(ethutil.BigTrue) + } else { + stack.Push(ethutil.BigFalse) + } + + case SLT: + y, x := S256(stack.Pop()), S256(stack.Pop()) + self.Printf(" %v < %v", y, x) + // x < y + if y.Cmp(S256(x)) < 0 { + stack.Push(ethutil.BigTrue) + } else { + stack.Push(ethutil.BigFalse) + } + case SGT: + y, x := S256(stack.Pop()), S256(stack.Pop()) + self.Printf(" %v > %v", y, x) + + // x > y + if y.Cmp(x) > 0 { + stack.Push(ethutil.BigTrue) + } else { + stack.Push(ethutil.BigFalse) + } + + case EQ: + x, y := stack.Popn() + self.Printf(" %v == %v", y, x) + + // x == y + if x.Cmp(y) == 0 { + stack.Push(ethutil.BigTrue) + } else { + stack.Push(ethutil.BigFalse) + } + case ISZERO: + x := stack.Pop() + if x.Cmp(ethutil.BigFalse) > 0 { + stack.Push(ethutil.BigFalse) + } else { + stack.Push(ethutil.BigTrue) + } + + // 0x10 range + case AND: + x, y := stack.Popn() + self.Printf(" %v & %v", y, x) + + stack.Push(base.And(y, x)) + case OR: + x, y := stack.Popn() + self.Printf(" %v | %v", y, x) + + stack.Push(base.Or(y, x)) + case XOR: + x, y := stack.Popn() + self.Printf(" %v ^ %v", y, x) + + stack.Push(base.Xor(y, x)) + case BYTE: + val, th := stack.Popn() + + if th.Cmp(big.NewInt(32)) < 0 { + byt := big.NewInt(int64(ethutil.LeftPadBytes(val.Bytes(), 32)[th.Int64()])) + + base.Set(byt) + } else { + base.Set(ethutil.BigFalse) + } + + self.Printf(" => 0x%x", base.Bytes()) + + stack.Push(base) + case ADDMOD: + + x := stack.Pop() + y := stack.Pop() + z := stack.Pop() + + add := new(big.Int).Add(x, y) + if len(z.Bytes()) > 0 { // NOT 0x0 + base.Mod(add, z) + + U256(base) + } + + self.Printf(" %v + %v %% %v = %v", x, y, z, base) + + stack.Push(base) + case MULMOD: + + x := stack.Pop() + y := stack.Pop() + z := stack.Pop() + + mul := new(big.Int).Mul(x, y) + if len(z.Bytes()) > 0 { // NOT 0x0 + base.Mod(mul, z) + + U256(base) + } + + self.Printf(" %v + %v %% %v = %v", x, y, z, base) + + stack.Push(base) + + // 0x20 range + case SHA3: + size, offset := stack.Popn() + data := crypto.Sha3(mem.Get(offset.Int64(), size.Int64())) + + stack.Push(ethutil.BigD(data)) + + self.Printf(" => %x", data) + // 0x30 range + case ADDRESS: + stack.Push(ethutil.BigD(context.Address())) + + self.Printf(" => %x", context.Address()) + case BALANCE: + + addr := stack.Pop().Bytes() + balance := statedb.GetBalance(addr) + + stack.Push(balance) + + self.Printf(" => %v (%x)", balance, addr) + case ORIGIN: + origin := self.env.Origin() + + stack.Push(ethutil.BigD(origin)) + + self.Printf(" => %x", origin) + case CALLER: + caller := context.caller.Address() + stack.Push(ethutil.BigD(caller)) + + self.Printf(" => %x", caller) + case CALLVALUE: + stack.Push(value) + + self.Printf(" => %v", value) + case CALLDATALOAD: + var ( + offset = stack.Pop() + data = make([]byte, 32) + lenData = big.NewInt(int64(len(callData))) + ) + + if lenData.Cmp(offset) >= 0 { + length := new(big.Int).Add(offset, ethutil.Big32) + length = ethutil.BigMin(length, lenData) + + copy(data, callData[offset.Int64():length.Int64()]) + } + + self.Printf(" => 0x%x", data) + + stack.Push(ethutil.BigD(data)) + case CALLDATASIZE: + l := int64(len(callData)) + 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() + ) + + if cOff > size { + cOff = 0 + l = 0 + } else if cOff+l > size { + l = 0 + } + + code := callData[cOff : cOff+l] + + mem.Set(mOff, l, code) + + self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, callData[cOff:cOff+l]) + case CODESIZE, EXTCODESIZE: + var code []byte + if op == EXTCODESIZE { + addr := stack.Pop().Bytes() + + code = statedb.GetCode(addr) + } else { + code = context.Code + } + + l := big.NewInt(int64(len(code))) + stack.Push(l) + + self.Printf(" => %d", l) + case CODECOPY, EXTCODECOPY: + var code []byte + if op == EXTCODECOPY { + 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() + ) + codeCopy := context.GetCode(cOff, l) + + mem.Set(mOff, l, codeCopy) + + self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy) + case GASPRICE: + stack.Push(context.Price) + + self.Printf(" => %v", context.Price) + + // 0x40 range + case BLOCKHASH: + num := stack.Pop() + + n := U256(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()))) + } else { + stack.Push(ethutil.Big0) + } + + self.Printf(" => 0x%x", stack.Peek().Bytes()) + case COINBASE: + coinbase := self.env.Coinbase() + + stack.Push(ethutil.BigD(coinbase)) + + self.Printf(" => 0x%x", coinbase) + case TIMESTAMP: + time := self.env.Time() + + stack.Push(big.NewInt(time)) + + self.Printf(" => 0x%x", time) + case NUMBER: + number := self.env.BlockNumber() + + stack.Push(number) + + self.Printf(" => 0x%x", number.Bytes()) + case DIFFICULTY: + difficulty := self.env.Difficulty() + + stack.Push(difficulty) + + self.Printf(" => 0x%x", difficulty.Bytes()) + case GASLIMIT: + self.Printf(" => %v", 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)) + pc += a + + step += int(op) - int(PUSH1) + 1 + + self.Printf(" => 0x%x", byts) + case 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) + + 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) + + self.Printf(" => [%d] %x [0] %x", n, x.Bytes(), y.Bytes()) + case LOG0, LOG1, LOG2, LOG3, LOG4: + n := int(op - LOG0) + topics := make([][]byte, n) + mSize, mStart := stack.Popn() + for i := 0; i < n; i++ { + topics[i] = ethutil.LeftPadBytes(stack.Pop().Bytes(), 32) + } + + data := mem.Get(mStart.Int64(), mSize.Int64()) + log := &Log{context.Address(), topics, data} + self.env.AddLog(log) + + self.Printf(" => %v", log) + case MLOAD: + offset := stack.Pop() + val := ethutil.BigD(mem.Get(offset.Int64(), 32)) + 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() + mem.Set(mStart.Uint64(), 32, ethutil.BigToBytes(val, 256)) + + self.Printf(" => 0x%x", val) + case MSTORE8: + off := stack.Pop() + val := stack.Pop() + + mem.store[off.Int64()] = byte(val.Int64() & 0xff) + + self.Printf(" => [%v] 0x%x", off, val) + case SLOAD: + loc := stack.Pop() + val := ethutil.BigD(statedb.GetState(context.Address(), loc.Bytes())) + stack.Push(val) + + self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes()) + case SSTORE: + val, loc := stack.Popn() + statedb.SetState(context.Address(), loc.Bytes(), val) + + msg.AddStorageChange(loc.Bytes()) + + self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes()) + case JUMP: + jump(pc, stack.Pop()) + + continue + case JUMPI: + cond, pos := stack.Popn() + + if cond.Cmp(ethutil.BigTrue) >= 0 { + jump(pc, pos) + + continue + } + + case JUMPDEST: + case PC: + stack.Push(big.NewInt(int64(pc))) + case MSIZE: + stack.Push(big.NewInt(int64(mem.Len()))) + case GAS: + stack.Push(context.Gas) + // 0x60 range + case CREATE: + + var ( + value = stack.Pop() + size, offset = stack.Popn() + input = mem.Get(offset.Int64(), size.Int64()) + gas = new(big.Int).Set(context.Gas) + addr []byte + ) + + context.UseGas(context.Gas) + ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value) + if suberr != nil { + stack.Push(ethutil.BigFalse) + + self.Printf(" (*) 0x0 %v", suberr) + } else { + + // gas < len(ret) * CreateDataGas == NO_CODE + dataGas := big.NewInt(int64(len(ret))) + dataGas.Mul(dataGas, GasCreateByte) + if context.UseGas(dataGas) { + ref.SetCode(ret) + msg.Output = ret + } + addr = ref.Address() + + stack.Push(ethutil.BigD(addr)) + + self.Printf(" (*) %x", addr) + } + + // Debug hook + if self.Dbg != nil { + self.Dbg.SetCode(context.Code) + } + case CALL, CALLCODE: + self.Endl() + + gas := stack.Pop() + // Pop gas and value of the stack. + value, addr := stack.Popn() + // Pop input size and offset + inSize, inOffset := stack.Popn() + // Pop return size and offset + retSize, retOffset := stack.Popn() + + // Get the arguments from the memory + args := mem.Get(inOffset.Int64(), inSize.Int64()) + + var ( + ret []byte + err error + ) + if op == CALLCODE { + ret, err = self.env.CallCode(context, addr.Bytes(), args, gas, price, value) + } else { + ret, err = self.env.Call(context, addr.Bytes(), args, gas, price, value) + } + + if err != nil { + stack.Push(ethutil.BigFalse) + + vmlogger.Debugln(err) + } else { + stack.Push(ethutil.BigTrue) + msg.Output = ret + + 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() + 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()) + balance := statedb.GetBalance(context.Address()) + + self.Printf(" => (%x) %v", receiver.Address()[:4], balance) + + receiver.AddAmount(balance) + statedb.Delete(context.Address()) + + fallthrough + case STOP: // Stop the context + self.Endl() + + return context.Return(nil), nil + default: + vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op) + + panic(fmt.Errorf("Invalid opcode %x", op)) + } + + 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 + } + } + } + } + + } } -func New(env Environment, typ Type) VirtualMachine { - switch typ { - case DebugVmTy: - return NewDebugVm(env) - case JitVmTy: - return NewJitVm(env) - default: - return &Vm{env: env} +func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *Stack) (*big.Int, *big.Int) { + gas := new(big.Int) + addStepGasUsage := func(amount *big.Int) { + if amount.Cmp(ethutil.Big0) >= 0 { + gas.Add(gas, amount) + } + } + + addStepGasUsage(GasStep) + + var newMemSize *big.Int = ethutil.Big0 + var additionalGas *big.Int = new(big.Int) + // Stack Check, memory resize & gas phase + switch op { + // Stack checks only + case ISZERO, CALLDATALOAD, POP, JUMP, NOT: // 1 + stack.require(1) + case JUMPI, ADD, SUB, DIV, SDIV, MOD, SMOD, LT, GT, SLT, SGT, EQ, AND, OR, XOR, BYTE, SIGNEXTEND: // 2 + stack.require(2) + case ADDMOD, MULMOD: // 3 + stack.require(3) + case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16: + n := int(op - SWAP1 + 2) + stack.require(n) + case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16: + n := int(op - DUP1 + 1) + stack.require(n) + case LOG0, LOG1, LOG2, LOG3, LOG4: + n := int(op - LOG0) + stack.require(n + 2) + + gas.Set(GasLog) + addStepGasUsage(new(big.Int).Mul(big.NewInt(int64(n)), GasLog)) + + mSize, mStart := stack.Peekn() + addStepGasUsage(mSize) + + newMemSize = calcMemSize(mStart, mSize) + case EXP: + stack.require(2) + + gas.Set(big.NewInt(int64(len(stack.data[stack.Len()-2].Bytes()) + 1))) + // Gas only + case STOP: + gas.Set(ethutil.Big0) + case SUICIDE: + stack.require(1) + + gas.Set(ethutil.Big0) + case SLOAD: + stack.require(1) + + gas.Set(GasSLoad) + // Memory resize & Gas + case SSTORE: + stack.require(2) + + var mult *big.Int + y, x := stack.Peekn() + val := statedb.GetState(context.Address(), x.Bytes()) + if len(val) == 0 && len(y.Bytes()) > 0 { + // 0 => non 0 + mult = ethutil.Big3 + } else if len(val) > 0 && len(y.Bytes()) == 0 { + statedb.Refund(caller.Address(), GasSStoreRefund) + + mult = ethutil.Big0 + } else { + // non 0 => non 0 (or 0 => 0) + mult = ethutil.Big1 + } + gas.Set(new(big.Int).Mul(mult, GasSStore)) + case BALANCE: + stack.require(1) + gas.Set(GasBalance) + case MSTORE: + stack.require(2) + newMemSize = calcMemSize(stack.Peek(), u256(32)) + case MLOAD: + stack.require(1) + + newMemSize = calcMemSize(stack.Peek(), u256(32)) + case MSTORE8: + stack.require(2) + newMemSize = calcMemSize(stack.Peek(), u256(1)) + case RETURN: + stack.require(2) + + newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2]) + case SHA3: + stack.require(2) + gas.Set(GasSha) + newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2]) + additionalGas.Set(stack.data[stack.Len()-2]) + case CALLDATACOPY: + stack.require(2) + + newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3]) + additionalGas.Set(stack.data[stack.Len()-3]) + case CODECOPY: + stack.require(3) + + newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3]) + additionalGas.Set(stack.data[stack.Len()-3]) + case EXTCODECOPY: + stack.require(4) + + newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4]) + additionalGas.Set(stack.data[stack.Len()-4]) + case CALL, CALLCODE: + stack.require(7) + gas.Set(GasCall) + addStepGasUsage(stack.data[stack.Len()-1]) + + 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) + case CREATE: + stack.require(3) + gas.Set(GasCreate) + + newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-3]) + } + + switch op { + case CALLDATACOPY, CODECOPY, EXTCODECOPY: + additionalGas.Add(additionalGas, u256(31)) + additionalGas.Div(additionalGas, u256(32)) + addStepGasUsage(additionalGas) + case SHA3: + additionalGas.Add(additionalGas, u256(31)) + additionalGas.Div(additionalGas, u256(32)) + additionalGas.Mul(additionalGas, GasSha3Byte) + addStepGasUsage(additionalGas) + } + + if newMemSize.Cmp(ethutil.Big0) > 0 { + newMemSize.Add(newMemSize, u256(31)) + newMemSize.Div(newMemSize, u256(32)) + newMemSize.Mul(newMemSize, u256(32)) + + if newMemSize.Cmp(u256(int64(mem.Len()))) > 0 { + memGasUsage := new(big.Int).Sub(newMemSize, u256(int64(mem.Len()))) + memGasUsage.Mul(GasMemory, memGasUsage) + memGasUsage.Div(memGasUsage, u256(32)) + + addStepGasUsage(memGasUsage) + } + } + + return newMemSize, gas } -func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, data []byte) (ret []byte, err error) { - panic("not implemented") +func (self *Vm) RunPrecompiled(p *PrecompiledAccount, callData []byte, context *Context) (ret []byte, err error) { + gas := p.Gas(len(callData)) + if context.UseGas(gas) { + ret = p.Call(callData) + self.Printf("NATIVE_FUNC => %x", ret) + self.Endl() + + return context.Return(ret), nil + } else { + self.Printf("NATIVE_FUNC => failed").Endl() + + tmp := new(big.Int).Set(context.Gas) + + panic(OOG(gas, tmp).Error()) + } } -func (self *Vm) Env() Environment { - return self.env +func (self *Vm) Printf(format string, v ...interface{}) VirtualMachine { + if self.logTy == LogTyPretty { + self.logStr += fmt.Sprintf(format, v...) + } + + return self } -func (self *Vm) Depth() int { - return self.depth +func (self *Vm) Endl() VirtualMachine { + if self.logTy == LogTyPretty { + vmlogger.Debugln(self.logStr) + self.logStr = "" + } + + return self } -func (self *Vm) Printf(format string, v ...interface{}) VirtualMachine { return self } -func (self *Vm) Endl() VirtualMachine { return self } +func (self *Vm) Env() Environment { + return self.env +} diff --git a/vm/vm_debug.go b/vm/vm_debug.go deleted file mode 100644 index 44137568e..000000000 --- a/vm/vm_debug.go +++ /dev/null @@ -1,961 +0,0 @@ -package vm - -import ( - "fmt" - "math/big" - - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/state" -) - -type DebugVm struct { - env Environment - - logTy byte - logStr string - - err error - - // Debugging - Dbg Debugger - - BreakPoints []int64 - Stepping bool - Fn string - - Recoverable bool -} - -func NewDebugVm(env Environment) *DebugVm { - lt := LogTyPretty - if ethutil.Config.Diff { - lt = LogTyDiff - } - - return &DebugVm{env: env, logTy: lt, Recoverable: true} -} - -func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { - self.env.SetDepth(self.env.Depth() + 1) - - msg := self.env.State().Manifest().AddMessage(&state.Message{ - To: me.Address(), From: caller.Address(), - Input: callData, - Origin: self.env.Origin(), - Timestamp: self.env.Time(), Coinbase: self.env.Coinbase(), Number: self.env.BlockNumber(), - Value: value, - }) - context := NewContext(caller, me, code, gas, price) - - vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData) - - if self.Recoverable { - // Recover from any require exception - defer func() { - if r := recover(); r != nil { - self.Printf(" %v", r).Endl() - - context.UseGas(context.Gas) - - ret = context.Return(nil) - - err = fmt.Errorf("%v", r) - - } - }() - } - - if p := Precompiled[string(me.Address())]; p != nil { - return self.RunPrecompiled(p, callData, context) - } - - var ( - op OpCode - - destinations = analyseJumpDests(context.Code) - mem = NewMemory() - stack = NewStack() - pc uint64 = 0 - step = 0 - prevStep = 0 - statedb = self.env.State() - - jump = func(from uint64, to *big.Int) { - p := to.Uint64() - - nop := context.GetOp(p) - if !destinations.Has(p) { - panic(fmt.Sprintf("invalid jump destination (%v) %v", nop, p)) - } - - self.Printf(" ~> %v", to) - pc = to.Uint64() - - self.Endl() - } - ) - - // Don't bother with the execution if there's no code. - if len(code) == 0 { - return context.Return(nil), nil - } - - for { - prevStep = step - // The base for all big integer arithmetic - base := new(big.Int) - - step++ - // 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()) - - newMemSize, gas := self.calculateGasAndSize(context, caller, op, statedb, mem, stack) - - self.Printf("(g) %-3v (%v)", gas, context.Gas) - - if !context.UseGas(gas) { - self.Endl() - - tmp := new(big.Int).Set(context.Gas) - - context.UseGas(context.Gas) - - return context.Return(nil), OOG(gas, tmp) - } - - mem.Resize(newMemSize.Uint64()) - - switch op { - // 0x20 range - case ADD: - x, y := stack.Popn() - self.Printf(" %v + %v", y, x) - - base.Add(y, x) - - U256(base) - - self.Printf(" = %v", base) - // Pop result back on the stack - stack.Push(base) - case SUB: - x, y := stack.Popn() - self.Printf(" %v - %v", y, x) - - base.Sub(y, x) - - U256(base) - - self.Printf(" = %v", base) - // Pop result back on the stack - stack.Push(base) - case MUL: - x, y := stack.Popn() - self.Printf(" %v * %v", y, x) - - base.Mul(y, x) - - U256(base) - - self.Printf(" = %v", base) - // Pop result back on the stack - stack.Push(base) - case DIV: - x, y := stack.Pop(), stack.Pop() - self.Printf(" %v / %v", x, y) - - if y.Cmp(ethutil.Big0) != 0 { - base.Div(x, y) - } - - U256(base) - - self.Printf(" = %v", base) - // Pop result back on the stack - stack.Push(base) - case SDIV: - x, y := S256(stack.Pop()), S256(stack.Pop()) - - self.Printf(" %v / %v", x, y) - - if y.Cmp(ethutil.Big0) == 0 { - base.Set(ethutil.Big0) - } else { - n := new(big.Int) - if new(big.Int).Mul(x, y).Cmp(ethutil.Big0) < 0 { - n.SetInt64(-1) - } else { - n.SetInt64(1) - } - - base.Div(x.Abs(x), y.Abs(y)).Mul(base, n) - - U256(base) - } - - self.Printf(" = %v", base) - stack.Push(base) - case MOD: - x, y := stack.Pop(), stack.Pop() - - self.Printf(" %v %% %v", x, y) - - if y.Cmp(ethutil.Big0) == 0 { - base.Set(ethutil.Big0) - } else { - base.Mod(x, y) - } - - U256(base) - - self.Printf(" = %v", base) - stack.Push(base) - case SMOD: - x, y := S256(stack.Pop()), S256(stack.Pop()) - - self.Printf(" %v %% %v", x, y) - - if y.Cmp(ethutil.Big0) == 0 { - base.Set(ethutil.Big0) - } else { - n := new(big.Int) - if x.Cmp(ethutil.Big0) < 0 { - n.SetInt64(-1) - } else { - n.SetInt64(1) - } - - base.Mod(x.Abs(x), y.Abs(y)).Mul(base, n) - - U256(base) - } - - self.Printf(" = %v", base) - stack.Push(base) - - case EXP: - x, y := stack.Popn() - - self.Printf(" %v ** %v", y, x) - - base.Exp(y, x, Pow256) - - U256(base) - - self.Printf(" = %v", base) - - stack.Push(base) - case SIGNEXTEND: - back := stack.Pop().Uint64() - if back < 31 { - bit := uint(back*8 + 7) - num := stack.Pop() - mask := new(big.Int).Lsh(ethutil.Big1, bit) - mask.Sub(mask, ethutil.Big1) - if ethutil.BitTest(num, int(bit)) { - num.Or(num, mask.Not(mask)) - } else { - num.And(num, mask) - } - - num = U256(num) - - self.Printf(" = %v", num) - - stack.Push(num) - } - case NOT: - base.Sub(Pow256, stack.Pop()).Sub(base, ethutil.Big1) - - // Not needed - //base = U256(base) - - stack.Push(base) - case LT: - x, y := stack.Popn() - self.Printf(" %v < %v", y, x) - // x < y - if y.Cmp(x) < 0 { - stack.Push(ethutil.BigTrue) - } else { - stack.Push(ethutil.BigFalse) - } - case GT: - x, y := stack.Popn() - self.Printf(" %v > %v", y, x) - - // x > y - if y.Cmp(x) > 0 { - stack.Push(ethutil.BigTrue) - } else { - stack.Push(ethutil.BigFalse) - } - - case SLT: - y, x := S256(stack.Pop()), S256(stack.Pop()) - self.Printf(" %v < %v", y, x) - // x < y - if y.Cmp(S256(x)) < 0 { - stack.Push(ethutil.BigTrue) - } else { - stack.Push(ethutil.BigFalse) - } - case SGT: - y, x := S256(stack.Pop()), S256(stack.Pop()) - self.Printf(" %v > %v", y, x) - - // x > y - if y.Cmp(x) > 0 { - stack.Push(ethutil.BigTrue) - } else { - stack.Push(ethutil.BigFalse) - } - - case EQ: - x, y := stack.Popn() - self.Printf(" %v == %v", y, x) - - // x == y - if x.Cmp(y) == 0 { - stack.Push(ethutil.BigTrue) - } else { - stack.Push(ethutil.BigFalse) - } - case ISZERO: - x := stack.Pop() - if x.Cmp(ethutil.BigFalse) > 0 { - stack.Push(ethutil.BigFalse) - } else { - stack.Push(ethutil.BigTrue) - } - - // 0x10 range - case AND: - x, y := stack.Popn() - self.Printf(" %v & %v", y, x) - - stack.Push(base.And(y, x)) - case OR: - x, y := stack.Popn() - self.Printf(" %v | %v", y, x) - - stack.Push(base.Or(y, x)) - case XOR: - x, y := stack.Popn() - self.Printf(" %v ^ %v", y, x) - - stack.Push(base.Xor(y, x)) - case BYTE: - val, th := stack.Popn() - - if th.Cmp(big.NewInt(32)) < 0 { - byt := big.NewInt(int64(ethutil.LeftPadBytes(val.Bytes(), 32)[th.Int64()])) - - base.Set(byt) - } else { - base.Set(ethutil.BigFalse) - } - - self.Printf(" => 0x%x", base.Bytes()) - - stack.Push(base) - case ADDMOD: - - x := stack.Pop() - y := stack.Pop() - z := stack.Pop() - - add := new(big.Int).Add(x, y) - if len(z.Bytes()) > 0 { // NOT 0x0 - base.Mod(add, z) - - U256(base) - } - - self.Printf(" %v + %v %% %v = %v", x, y, z, base) - - stack.Push(base) - case MULMOD: - - x := stack.Pop() - y := stack.Pop() - z := stack.Pop() - - mul := new(big.Int).Mul(x, y) - if len(z.Bytes()) > 0 { // NOT 0x0 - base.Mod(mul, z) - - U256(base) - } - - self.Printf(" %v + %v %% %v = %v", x, y, z, base) - - stack.Push(base) - - // 0x20 range - case SHA3: - size, offset := stack.Popn() - data := crypto.Sha3(mem.Get(offset.Int64(), size.Int64())) - - stack.Push(ethutil.BigD(data)) - - self.Printf(" => %x", data) - // 0x30 range - case ADDRESS: - stack.Push(ethutil.BigD(context.Address())) - - self.Printf(" => %x", context.Address()) - case BALANCE: - - addr := stack.Pop().Bytes() - balance := statedb.GetBalance(addr) - - stack.Push(balance) - - self.Printf(" => %v (%x)", balance, addr) - case ORIGIN: - origin := self.env.Origin() - - stack.Push(ethutil.BigD(origin)) - - self.Printf(" => %x", origin) - case CALLER: - caller := context.caller.Address() - stack.Push(ethutil.BigD(caller)) - - self.Printf(" => %x", caller) - case CALLVALUE: - stack.Push(value) - - self.Printf(" => %v", value) - case CALLDATALOAD: - var ( - offset = stack.Pop() - data = make([]byte, 32) - lenData = big.NewInt(int64(len(callData))) - ) - - if lenData.Cmp(offset) >= 0 { - length := new(big.Int).Add(offset, ethutil.Big32) - length = ethutil.BigMin(length, lenData) - - copy(data, callData[offset.Int64():length.Int64()]) - } - - self.Printf(" => 0x%x", data) - - stack.Push(ethutil.BigD(data)) - case CALLDATASIZE: - l := int64(len(callData)) - 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() - ) - - if cOff > size { - cOff = 0 - l = 0 - } else if cOff+l > size { - l = 0 - } - - code := callData[cOff : cOff+l] - - mem.Set(mOff, l, code) - - self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, callData[cOff:cOff+l]) - case CODESIZE, EXTCODESIZE: - var code []byte - if op == EXTCODESIZE { - addr := stack.Pop().Bytes() - - code = statedb.GetCode(addr) - } else { - code = context.Code - } - - l := big.NewInt(int64(len(code))) - stack.Push(l) - - self.Printf(" => %d", l) - case CODECOPY, EXTCODECOPY: - var code []byte - if op == EXTCODECOPY { - 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() - ) - codeCopy := context.GetCode(cOff, l) - - mem.Set(mOff, l, codeCopy) - - self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy) - case GASPRICE: - stack.Push(context.Price) - - self.Printf(" => %v", context.Price) - - // 0x40 range - case BLOCKHASH: - num := stack.Pop() - - n := U256(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()))) - } else { - stack.Push(ethutil.Big0) - } - - self.Printf(" => 0x%x", stack.Peek().Bytes()) - case COINBASE: - coinbase := self.env.Coinbase() - - stack.Push(ethutil.BigD(coinbase)) - - self.Printf(" => 0x%x", coinbase) - case TIMESTAMP: - time := self.env.Time() - - stack.Push(big.NewInt(time)) - - self.Printf(" => 0x%x", time) - case NUMBER: - number := self.env.BlockNumber() - - stack.Push(number) - - self.Printf(" => 0x%x", number.Bytes()) - case DIFFICULTY: - difficulty := self.env.Difficulty() - - stack.Push(difficulty) - - self.Printf(" => 0x%x", difficulty.Bytes()) - case GASLIMIT: - self.Printf(" => %v", 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)) - pc += a - - step += int(op) - int(PUSH1) + 1 - - self.Printf(" => 0x%x", byts) - case 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) - - 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) - - self.Printf(" => [%d] %x [0] %x", n, x.Bytes(), y.Bytes()) - case LOG0, LOG1, LOG2, LOG3, LOG4: - n := int(op - LOG0) - topics := make([][]byte, n) - mSize, mStart := stack.Popn() - for i := 0; i < n; i++ { - topics[i] = ethutil.LeftPadBytes(stack.Pop().Bytes(), 32) - } - - data := mem.Get(mStart.Int64(), mSize.Int64()) - log := &Log{context.Address(), topics, data} - self.env.AddLog(log) - - self.Printf(" => %v", log) - case MLOAD: - offset := stack.Pop() - val := ethutil.BigD(mem.Get(offset.Int64(), 32)) - 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() - mem.Set(mStart.Uint64(), 32, ethutil.BigToBytes(val, 256)) - - self.Printf(" => 0x%x", val) - case MSTORE8: - off := stack.Pop() - val := stack.Pop() - - mem.store[off.Int64()] = byte(val.Int64() & 0xff) - - self.Printf(" => [%v] 0x%x", off, val) - case SLOAD: - loc := stack.Pop() - val := ethutil.BigD(statedb.GetState(context.Address(), loc.Bytes())) - stack.Push(val) - - self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes()) - case SSTORE: - val, loc := stack.Popn() - statedb.SetState(context.Address(), loc.Bytes(), val) - - msg.AddStorageChange(loc.Bytes()) - - self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes()) - case JUMP: - jump(pc, stack.Pop()) - - continue - case JUMPI: - cond, pos := stack.Popn() - - if cond.Cmp(ethutil.BigTrue) >= 0 { - jump(pc, pos) - - continue - } - - case JUMPDEST: - case PC: - stack.Push(big.NewInt(int64(pc))) - case MSIZE: - stack.Push(big.NewInt(int64(mem.Len()))) - case GAS: - stack.Push(context.Gas) - // 0x60 range - case CREATE: - - var ( - value = stack.Pop() - size, offset = stack.Popn() - input = mem.Get(offset.Int64(), size.Int64()) - gas = new(big.Int).Set(context.Gas) - addr []byte - ) - - context.UseGas(context.Gas) - ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value) - if suberr != nil { - stack.Push(ethutil.BigFalse) - - self.Printf(" (*) 0x0 %v", suberr) - } else { - - // gas < len(ret) * CreateDataGas == NO_CODE - dataGas := big.NewInt(int64(len(ret))) - dataGas.Mul(dataGas, GasCreateByte) - if context.UseGas(dataGas) { - ref.SetCode(ret) - msg.Output = ret - } - addr = ref.Address() - - stack.Push(ethutil.BigD(addr)) - - self.Printf(" (*) %x", addr) - } - - // Debug hook - if self.Dbg != nil { - self.Dbg.SetCode(context.Code) - } - case CALL, CALLCODE: - self.Endl() - - gas := stack.Pop() - // Pop gas and value of the stack. - value, addr := stack.Popn() - // Pop input size and offset - inSize, inOffset := stack.Popn() - // Pop return size and offset - retSize, retOffset := stack.Popn() - - // Get the arguments from the memory - args := mem.Get(inOffset.Int64(), inSize.Int64()) - - var ( - ret []byte - err error - ) - if op == CALLCODE { - ret, err = self.env.CallCode(context, addr.Bytes(), args, gas, price, value) - } else { - ret, err = self.env.Call(context, addr.Bytes(), args, gas, price, value) - } - - if err != nil { - stack.Push(ethutil.BigFalse) - - vmlogger.Debugln(err) - } else { - stack.Push(ethutil.BigTrue) - msg.Output = ret - - 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() - 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()) - balance := statedb.GetBalance(context.Address()) - - self.Printf(" => (%x) %v", receiver.Address()[:4], balance) - - receiver.AddAmount(balance) - statedb.Delete(context.Address()) - - fallthrough - case STOP: // Stop the context - self.Endl() - - return context.Return(nil), nil - default: - vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op) - - panic(fmt.Errorf("Invalid opcode %x", op)) - } - - 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 - } - } - } - } - - } -} - -func (self *DebugVm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *Stack) (*big.Int, *big.Int) { - gas := new(big.Int) - addStepGasUsage := func(amount *big.Int) { - if amount.Cmp(ethutil.Big0) >= 0 { - gas.Add(gas, amount) - } - } - - addStepGasUsage(GasStep) - - var newMemSize *big.Int = ethutil.Big0 - var additionalGas *big.Int = new(big.Int) - // Stack Check, memory resize & gas phase - switch op { - // Stack checks only - case ISZERO, CALLDATALOAD, POP, JUMP, NOT: // 1 - stack.require(1) - case JUMPI, ADD, SUB, DIV, SDIV, MOD, SMOD, LT, GT, SLT, SGT, EQ, AND, OR, XOR, BYTE, SIGNEXTEND: // 2 - stack.require(2) - case ADDMOD, MULMOD: // 3 - stack.require(3) - case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16: - n := int(op - SWAP1 + 2) - stack.require(n) - case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16: - n := int(op - DUP1 + 1) - stack.require(n) - case LOG0, LOG1, LOG2, LOG3, LOG4: - n := int(op - LOG0) - stack.require(n + 2) - - gas.Set(GasLog) - addStepGasUsage(new(big.Int).Mul(big.NewInt(int64(n)), GasLog)) - - mSize, mStart := stack.Peekn() - addStepGasUsage(mSize) - - newMemSize = calcMemSize(mStart, mSize) - case EXP: - stack.require(2) - - gas.Set(big.NewInt(int64(len(stack.data[stack.Len()-2].Bytes()) + 1))) - // Gas only - case STOP: - gas.Set(ethutil.Big0) - case SUICIDE: - stack.require(1) - - gas.Set(ethutil.Big0) - case SLOAD: - stack.require(1) - - gas.Set(GasSLoad) - // Memory resize & Gas - case SSTORE: - stack.require(2) - - var mult *big.Int - y, x := stack.Peekn() - val := statedb.GetState(context.Address(), x.Bytes()) - if len(val) == 0 && len(y.Bytes()) > 0 { - // 0 => non 0 - mult = ethutil.Big3 - } else if len(val) > 0 && len(y.Bytes()) == 0 { - statedb.Refund(caller.Address(), GasSStoreRefund) - - mult = ethutil.Big0 - } else { - // non 0 => non 0 (or 0 => 0) - mult = ethutil.Big1 - } - gas.Set(new(big.Int).Mul(mult, GasSStore)) - case BALANCE: - stack.require(1) - gas.Set(GasBalance) - case MSTORE: - stack.require(2) - newMemSize = calcMemSize(stack.Peek(), u256(32)) - case MLOAD: - stack.require(1) - - newMemSize = calcMemSize(stack.Peek(), u256(32)) - case MSTORE8: - stack.require(2) - newMemSize = calcMemSize(stack.Peek(), u256(1)) - case RETURN: - stack.require(2) - - newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2]) - case SHA3: - stack.require(2) - gas.Set(GasSha) - newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2]) - additionalGas.Set(stack.data[stack.Len()-2]) - case CALLDATACOPY: - stack.require(2) - - newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3]) - additionalGas.Set(stack.data[stack.Len()-3]) - case CODECOPY: - stack.require(3) - - newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3]) - additionalGas.Set(stack.data[stack.Len()-3]) - case EXTCODECOPY: - stack.require(4) - - newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4]) - additionalGas.Set(stack.data[stack.Len()-4]) - case CALL, CALLCODE: - stack.require(7) - gas.Set(GasCall) - addStepGasUsage(stack.data[stack.Len()-1]) - - 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) - case CREATE: - stack.require(3) - gas.Set(GasCreate) - - newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-3]) - } - - switch op { - case CALLDATACOPY, CODECOPY, EXTCODECOPY: - additionalGas.Add(additionalGas, u256(31)) - additionalGas.Div(additionalGas, u256(32)) - addStepGasUsage(additionalGas) - case SHA3: - additionalGas.Add(additionalGas, u256(31)) - additionalGas.Div(additionalGas, u256(32)) - additionalGas.Mul(additionalGas, GasSha3Byte) - addStepGasUsage(additionalGas) - } - - if newMemSize.Cmp(ethutil.Big0) > 0 { - newMemSize.Add(newMemSize, u256(31)) - newMemSize.Div(newMemSize, u256(32)) - newMemSize.Mul(newMemSize, u256(32)) - - if newMemSize.Cmp(u256(int64(mem.Len()))) > 0 { - memGasUsage := new(big.Int).Sub(newMemSize, u256(int64(mem.Len()))) - memGasUsage.Mul(GasMemory, memGasUsage) - memGasUsage.Div(memGasUsage, u256(32)) - - addStepGasUsage(memGasUsage) - } - - } - - return newMemSize, gas -} - -func (self *DebugVm) RunPrecompiled(p *PrecompiledAccount, callData []byte, context *Context) (ret []byte, err error) { - gas := p.Gas(len(callData)) - if context.UseGas(gas) { - ret = p.Call(callData) - self.Printf("NATIVE_FUNC => %x", ret) - self.Endl() - - return context.Return(ret), nil - } else { - self.Printf("NATIVE_FUNC => failed").Endl() - - tmp := new(big.Int).Set(context.Gas) - - panic(OOG(gas, tmp).Error()) - } -} - -func (self *DebugVm) Printf(format string, v ...interface{}) VirtualMachine { - if self.logTy == LogTyPretty { - self.logStr += fmt.Sprintf(format, v...) - } - - return self -} - -func (self *DebugVm) Endl() VirtualMachine { - if self.logTy == LogTyPretty { - vmlogger.Debugln(self.logStr) - self.logStr = "" - } - - return self -} - -func (self *DebugVm) Env() Environment { - return self.env -} diff --git a/vm/vm_jit.go b/vm/vm_jit.go index c715abab0..1cb9652af 100644 --- a/vm/vm_jit.go +++ b/vm/vm_jit.go @@ -3,12 +3,12 @@ package vm import "math/big" type JitVm struct { - env Environment - backup *DebugVm + env Environment + backup *Vm } func NewJitVm(env Environment) *JitVm { - backupVm := NewDebugVm(env) + backupVm := NewVm(env) return &JitVm{env: env, backup: backupVm} } @@ -28,4 +28,4 @@ func (self *JitVm) Env() Environment { return self.env } -//go is nice \ No newline at end of file +//go is nice -- cgit v1.2.3 From 9845029a7535672746139084138f3e894e604e44 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 20 Jan 2015 15:49:12 +0100 Subject: StdVm by default --- vm/vm.go | 6 ++++-- vm/vm_jit.go | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) (limited to 'vm') diff --git a/vm/vm.go b/vm/vm.go index 6aa39797e..37e4249f5 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -17,7 +17,6 @@ type Vm struct { err error - // Debugging Dbg Debugger BreakPoints []int64 @@ -27,7 +26,7 @@ type Vm struct { Recoverable bool } -func NewVm(env Environment) *Vm { +func New(env Environment) *Vm { lt := LogTyPretty if ethutil.Config.Diff { lt = LogTyDiff @@ -111,6 +110,9 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I 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) + } newMemSize, gas := self.calculateGasAndSize(context, caller, op, statedb, mem, stack) diff --git a/vm/vm_jit.go b/vm/vm_jit.go index 1cb9652af..0882bcf0c 100644 --- a/vm/vm_jit.go +++ b/vm/vm_jit.go @@ -8,7 +8,7 @@ type JitVm struct { } func NewJitVm(env Environment) *JitVm { - backupVm := NewVm(env) + backupVm := New(env) return &JitVm{env: env, backup: backupVm} } -- cgit v1.2.3 From d5f38f5690caeb30794e62d4a1b2683a6107cfbc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Bylica?= Date: Thu, 22 Jan 2015 18:00:15 +0100 Subject: JitVM: the EVM JIT bridge --- vm/vm_jit.go | 363 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- vm/vm_jit_fake.go | 10 ++ 2 files changed, 364 insertions(+), 9 deletions(-) create mode 100644 vm/vm_jit_fake.go (limited to 'vm') diff --git a/vm/vm_jit.go b/vm/vm_jit.go index 0882bcf0c..eaebc0749 100644 --- a/vm/vm_jit.go +++ b/vm/vm_jit.go @@ -1,31 +1,376 @@ +// +build evmjit + package vm -import "math/big" +/* +#include +#include + +struct evmjit_result +{ + int32_t returnCode; + uint64_t returnDataSize; + void* returnData; +}; + +struct evmjit_result evmjit_run(void* _data, void* _env); + +#cgo LDFLAGS: -levmjit +*/ +import "C" + +import ( + "bytes" + "errors" + "fmt" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/state" + "math/big" + "unsafe" +) type JitVm struct { - env Environment - backup *Vm + env Environment + me ContextRef + callerAddr []byte + price *big.Int + data RuntimeData +} + +type i256 [32]byte + +const ( + Gas = iota + address + Caller + Origin + CallValue + CallDataSize + GasPrice + CoinBase + TimeStamp + Number + Difficulty + GasLimit + CodeSize + + _size + + ReturnDataOffset = CallValue // Reuse 2 fields for return data reference + ReturnDataSize = CallDataSize + SuicideDestAddress = address ///< Suicide balance destination address +) + +type RuntimeData struct { + elems [_size]i256 + callData *byte + code *byte +} + +func hash2llvm(h []byte) i256 { + var m i256 + copy(m[len(m)-len(h):], h) // right aligned copy + return m +} + +func llvm2hash(m *i256) []byte { + if len(m) != 32 { + panic("I don't know Go!") + } + return C.GoBytes(unsafe.Pointer(m), 32) +} + +func address2llvm(addr []byte) i256 { + n := hash2llvm(addr) + bswap(&n) + return n +} + +func bswap(m *i256) *i256 { + for i, l := 0, len(m); i < l/2; i++ { + m[i], m[l-i-1] = m[l-i-1], m[i] + } + return m +} + +func trim(m []byte) []byte { + skip := 0 + for i := 0; i < len(m); i++ { + if m[i] == 0 { + skip++ + } else { + break + } + } + return m[skip:] +} + +func getDataPtr(m []byte) *byte { + var p *byte + if len(m) > 0 { + p = &m[0] + } + return p +} + +func big2llvm(n *big.Int) i256 { + m := hash2llvm(n.Bytes()) + bswap(&m) + return m +} + +func llvm2big(m *i256) *big.Int { + n := big.NewInt(0) + for i := 0; i < len(m); i++ { + b := big.NewInt(int64(m[i])) + b.Lsh(b, uint(i)*8) + n.Add(n, b) + } + return n +} + +func llvm2bytes(data *byte, length uint64) []byte { + if length == 0 { + return nil + } + if data == nil { + panic("llvm2bytes: nil pointer to data") + } + return (*[1 << 30]byte)(unsafe.Pointer(data))[:length:length] +} + +func untested(condition bool, message string) { + if condition { + panic("Condition `" + message + "` tested. Remove assert.") + } +} + +func assert(condition bool, message string) { + if !condition { + panic("Assert `" + message + "` failed!") + } } func NewJitVm(env Environment) *JitVm { - backupVm := New(env) - return &JitVm{env: env, backup: backupVm} + return &JitVm{env: env} } func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { - return self.backup.Run(me, caller, code, value, gas, price, callData) + self.env.SetDepth(self.env.Depth() + 1) + + if Precompiled[string(me.Address())] != nil { + // if it's address of precopiled contract + // fallback to standard VM + stdVm := New(self.env) + return stdVm.Run(me, caller, code, value, gas, price, callData) + } + + self.me = me // FIXME: Make sure Run() is not used more than once + self.callerAddr = caller.Address() + self.price = price + + self.data.elems[Gas] = big2llvm(gas) + self.data.elems[address] = address2llvm(self.me.Address()) + self.data.elems[Caller] = address2llvm(caller.Address()) + self.data.elems[Origin] = address2llvm(self.env.Origin()) + self.data.elems[CallValue] = big2llvm(value) + self.data.elems[CallDataSize] = big2llvm(big.NewInt(int64(len(callData)))) // TODO: Keep call data size as i64 + self.data.elems[GasPrice] = big2llvm(price) + self.data.elems[CoinBase] = address2llvm(self.env.Coinbase()) + self.data.elems[TimeStamp] = big2llvm(big.NewInt(self.env.Time())) // TODO: Keep timestamp as i64 + self.data.elems[Number] = big2llvm(self.env.BlockNumber()) + self.data.elems[Difficulty] = big2llvm(self.env.Difficulty()) + self.data.elems[GasLimit] = big2llvm(self.env.GasLimit()) + self.data.elems[CodeSize] = big2llvm(big.NewInt(int64(len(code)))) // TODO: Keep code size as i64 + self.data.callData = getDataPtr(callData) + self.data.code = getDataPtr(code) + + result := C.evmjit_run(unsafe.Pointer(&self.data), unsafe.Pointer(self)) + //fmt.Printf("JIT result: %d\n", r) + + if result.returnCode >= 100 { + err = errors.New("OOG from JIT") + gas.SetInt64(0) // Set gas to 0, JIT does not bother + } else { + gasLeft := llvm2big(&self.data.elems[Gas]) // TODO: Set value directly to gas instance + gas.Set(gasLeft) + if result.returnCode == 1 { // RETURN + ret = C.GoBytes(result.returnData, C.int(result.returnDataSize)) + C.free(result.returnData) + } else if result.returnCode == 2 { // SUICIDE + state := self.Env().State() + receiverAddr := llvm2hash(bswap(&self.data.elems[address])) + receiverAddr = trim(receiverAddr) // TODO: trim all zeros or subslice 160bits? + receiver := state.GetOrNewStateObject(receiverAddr) + balance := state.GetBalance(me.Address()) + receiver.AddAmount(balance) + state.Delete(me.Address()) + } + } + + return } func (self *JitVm) Printf(format string, v ...interface{}) VirtualMachine { - return self.backup.Printf(format, v) + return self } func (self *JitVm) Endl() VirtualMachine { - return self.backup.Endl() + return self } func (self *JitVm) Env() Environment { return self.env } -//go is nice +//export env_sha3 +func env_sha3(dataPtr unsafe.Pointer, length uint64, resultPtr unsafe.Pointer) { + data := C.GoBytes(dataPtr, C.int(length)) + hash := crypto.Sha3(data) + result := (*i256)(resultPtr) + *result = hash2llvm(hash) +} + +//export env_sstore +func env_sstore(vmPtr unsafe.Pointer, indexPtr unsafe.Pointer, valuePtr unsafe.Pointer) { + vm := (*JitVm)(vmPtr) + index := llvm2hash(bswap((*i256)(indexPtr))) + value := llvm2hash(bswap((*i256)(valuePtr))) + value = trim(value) + if len(value) == 0 { + prevValue := vm.env.State().GetState(vm.me.Address(), index) + if len(prevValue) != 0 { + vm.Env().State().Refund(vm.callerAddr, GasSStoreRefund) + } + } + + vm.env.State().SetState(vm.me.Address(), index, value) +} + +//export env_sload +func env_sload(vmPtr unsafe.Pointer, indexPtr unsafe.Pointer, resultPtr unsafe.Pointer) { + vm := (*JitVm)(vmPtr) + index := llvm2hash(bswap((*i256)(indexPtr))) + value := vm.env.State().GetState(vm.me.Address(), index) + result := (*i256)(resultPtr) + *result = hash2llvm(value) + bswap(result) +} + +//export env_balance +func env_balance(_vm unsafe.Pointer, _addr unsafe.Pointer, _result unsafe.Pointer) { + vm := (*JitVm)(_vm) + addr := llvm2hash((*i256)(_addr)) + balance := vm.Env().State().GetBalance(addr) + result := (*i256)(_result) + *result = big2llvm(balance) +} + +//export env_blockhash +func env_blockhash(_vm unsafe.Pointer, _number unsafe.Pointer, _result unsafe.Pointer) { + vm := (*JitVm)(_vm) + number := llvm2big((*i256)(_number)) + result := (*i256)(_result) + + currNumber := vm.Env().BlockNumber() + limit := big.NewInt(0).Sub(currNumber, big.NewInt(256)) + if number.Cmp(limit) >= 0 && number.Cmp(currNumber) < 0 { + hash := vm.Env().GetHash(uint64(number.Int64())) + *result = hash2llvm(hash) + } else { + *result = i256{} + } +} + +//export env_call +func env_call(_vm unsafe.Pointer, _gas unsafe.Pointer, _receiveAddr unsafe.Pointer, _value unsafe.Pointer, inDataPtr unsafe.Pointer, inDataLen uint64, outDataPtr *byte, outDataLen uint64, _codeAddr unsafe.Pointer) bool { + vm := (*JitVm)(_vm) + + //fmt.Printf("env_call (depth %d)\n", vm.Env().Depth()) + + defer func() { + if r := recover(); r != nil { + fmt.Printf("Recovered in env_call (depth %d, out %p %d): %s\n", vm.Env().Depth(), outDataPtr, outDataLen, r) + } + }() + + balance := vm.Env().State().GetBalance(vm.me.Address()) + value := llvm2big((*i256)(_value)) + + if balance.Cmp(value) >= 0 { + receiveAddr := llvm2hash((*i256)(_receiveAddr)) + inData := C.GoBytes(inDataPtr, C.int(inDataLen)) + outData := llvm2bytes(outDataPtr, outDataLen) + codeAddr := llvm2hash((*i256)(_codeAddr)) + llvmGas := (*i256)(_gas) + gas := llvm2big(llvmGas) + var out []byte + var err error + if bytes.Equal(codeAddr, receiveAddr) { + out, err = vm.env.Call(vm.me, codeAddr, inData, gas, vm.price, value) + } else { + out, err = vm.env.CallCode(vm.me, codeAddr, inData, gas, vm.price, value) + } + *llvmGas = big2llvm(gas) + if err == nil { + copy(outData, out) + return true + } + } + + return false +} + +//export env_create +func env_create(_vm unsafe.Pointer, _gas unsafe.Pointer, _value unsafe.Pointer, initDataPtr unsafe.Pointer, initDataLen uint64, _result unsafe.Pointer) { + vm := (*JitVm)(_vm) + + value := llvm2big((*i256)(_value)) + initData := C.GoBytes(initDataPtr, C.int(initDataLen)) // TODO: Unnecessary if low balance + result := (*i256)(_result) + *result = i256{} + + llvmGas := (*i256)(_gas) + gas := llvm2big(llvmGas) + + ret, suberr, ref := vm.env.Create(vm.me, nil, initData, gas, vm.price, value) + if suberr == nil { + dataGas := big.NewInt(int64(len(ret))) // TODO: Nto the best design. env.Create can do it, it has the reference to gas counter + dataGas.Mul(dataGas, GasCreateByte) + gas.Sub(gas, dataGas) + *result = hash2llvm(ref.Address()) + } + *llvmGas = big2llvm(gas) +} + +//export env_log +func env_log(_vm unsafe.Pointer, dataPtr unsafe.Pointer, dataLen uint64, _topic1 unsafe.Pointer, _topic2 unsafe.Pointer, _topic3 unsafe.Pointer, _topic4 unsafe.Pointer) { + vm := (*JitVm)(_vm) + + data := C.GoBytes(dataPtr, C.int(dataLen)) + + topics := make([][]byte, 0, 4) + if _topic1 != nil { + topics = append(topics, llvm2hash((*i256)(_topic1))) + } + if _topic2 != nil { + topics = append(topics, llvm2hash((*i256)(_topic2))) + } + if _topic3 != nil { + topics = append(topics, llvm2hash((*i256)(_topic3))) + } + if _topic4 != nil { + topics = append(topics, llvm2hash((*i256)(_topic4))) + } + + vm.Env().AddLog(state.NewLog(vm.me.Address(), topics, data)) +} + +//export env_extcode +func env_extcode(_vm unsafe.Pointer, _addr unsafe.Pointer, o_size *uint64) *byte { + vm := (*JitVm)(_vm) + addr := llvm2hash((*i256)(_addr)) + code := vm.Env().State().GetCode(addr) + *o_size = uint64(len(code)) + return getDataPtr(code) +} diff --git a/vm/vm_jit_fake.go b/vm/vm_jit_fake.go new file mode 100644 index 000000000..d6b5be45b --- /dev/null +++ b/vm/vm_jit_fake.go @@ -0,0 +1,10 @@ +// +build !evmjit + +package vm + +import "fmt" + +func NewJitVm(env Environment) VirtualMachine { + fmt.Printf("Warning! EVM JIT not enabled.\n") + return New(env) +} -- cgit v1.2.3 From 94106cc41ff3795b9b13044f5625c2e1089795f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Bylica?= Date: Fri, 23 Jan 2015 16:45:22 +0100 Subject: JitVm code cleanups & refactoring. Some memory copies eliminated (i.e. in SHA3 calculation) --- vm/vm_jit.go | 38 +++++++++++++++++++++++++------------- 1 file changed, 25 insertions(+), 13 deletions(-) (limited to 'vm') diff --git a/vm/vm_jit.go b/vm/vm_jit.go index eaebc0749..0150a4eef 100644 --- a/vm/vm_jit.go +++ b/vm/vm_jit.go @@ -15,6 +15,8 @@ struct evmjit_result struct evmjit_result evmjit_run(void* _data, void* _env); +// Shared library evmjit (e.g. libevmjit.so) is expected to be installed in /usr/local/lib +// More: https://github.com/ethereum/evmjit #cgo LDFLAGS: -levmjit */ import "C" @@ -74,10 +76,11 @@ func hash2llvm(h []byte) i256 { } func llvm2hash(m *i256) []byte { - if len(m) != 32 { - panic("I don't know Go!") - } - return C.GoBytes(unsafe.Pointer(m), 32) + return C.GoBytes(unsafe.Pointer(m), C.int(len(m))) +} + +func llvm2hashRef(m *i256) []byte { + return (*[1 << 30]byte)(unsafe.Pointer(m))[:len(m):len(m)] } func address2llvm(addr []byte) i256 { @@ -86,6 +89,8 @@ func address2llvm(addr []byte) i256 { return n } +// bswap swap bytes of the 256-bit integer on LLVM side +// TODO: Do not change memory on LLVM side, that can conflict with memory access optimizations func bswap(m *i256) *i256 { for i, l := 0, len(m); i < l/2; i++ { m[i], m[l-i-1] = m[l-i-1], m[i] @@ -129,12 +134,14 @@ func llvm2big(m *i256) *big.Int { return n } -func llvm2bytes(data *byte, length uint64) []byte { +// llvm2bytesRef creates a []byte slice that references byte buffer on LLVM side (as of that not controller by GC) +// User must asure that referenced memory is available to Go until the data is copied or not needed any more +func llvm2bytesRef(data *byte, length uint64) []byte { if length == 0 { return nil } if data == nil { - panic("llvm2bytes: nil pointer to data") + panic("Unexpected nil data pointer") } return (*[1 << 30]byte)(unsafe.Pointer(data))[:length:length] } @@ -156,8 +163,10 @@ func NewJitVm(env Environment) *JitVm { } func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { + // TODO: depth is increased but never checked by VM. VM should not know about it at all. self.env.SetDepth(self.env.Depth() + 1) + // TODO: Move it to Env.Call() or sth if Precompiled[string(me.Address())] != nil { // if it's address of precopiled contract // fallback to standard VM @@ -165,7 +174,11 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi return stdVm.Run(me, caller, code, value, gas, price, callData) } - self.me = me // FIXME: Make sure Run() is not used more than once + if self.me != nil { + panic("JitVm.Run() can be called only once per JitVm instance") + } + + self.me = me self.callerAddr = caller.Address() self.price = price @@ -186,7 +199,6 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi self.data.code = getDataPtr(code) result := C.evmjit_run(unsafe.Pointer(&self.data), unsafe.Pointer(self)) - //fmt.Printf("JIT result: %d\n", r) if result.returnCode >= 100 { err = errors.New("OOG from JIT") @@ -198,9 +210,9 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi ret = C.GoBytes(result.returnData, C.int(result.returnDataSize)) C.free(result.returnData) } else if result.returnCode == 2 { // SUICIDE + // TODO: Suicide support logic should be moved to Env to be shared by VM implementations state := self.Env().State() - receiverAddr := llvm2hash(bswap(&self.data.elems[address])) - receiverAddr = trim(receiverAddr) // TODO: trim all zeros or subslice 160bits? + receiverAddr := llvm2hashRef(bswap(&self.data.elems[address])) receiver := state.GetOrNewStateObject(receiverAddr) balance := state.GetBalance(me.Address()) receiver.AddAmount(balance) @@ -224,8 +236,8 @@ func (self *JitVm) Env() Environment { } //export env_sha3 -func env_sha3(dataPtr unsafe.Pointer, length uint64, resultPtr unsafe.Pointer) { - data := C.GoBytes(dataPtr, C.int(length)) +func env_sha3(dataPtr *byte, length uint64, resultPtr unsafe.Pointer) { + data := llvm2bytesRef(dataPtr, length) hash := crypto.Sha3(data) result := (*i256)(resultPtr) *result = hash2llvm(hash) @@ -300,7 +312,7 @@ func env_call(_vm unsafe.Pointer, _gas unsafe.Pointer, _receiveAddr unsafe.Point if balance.Cmp(value) >= 0 { receiveAddr := llvm2hash((*i256)(_receiveAddr)) inData := C.GoBytes(inDataPtr, C.int(inDataLen)) - outData := llvm2bytes(outDataPtr, outDataLen) + outData := llvm2bytesRef(outDataPtr, outDataLen) codeAddr := llvm2hash((*i256)(_codeAddr)) llvmGas := (*i256)(_gas) gas := llvm2big(llvmGas) -- cgit v1.2.3 From c71aff99dbb45d5998049604109457aa34ecf573 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Bylica?= Date: Mon, 26 Jan 2015 16:13:55 +0100 Subject: Update EVM JIT runtime data layout --- vm/vm_jit.go | 71 +++++++++++++++++++++++++----------------------------------- 1 file changed, 30 insertions(+), 41 deletions(-) (limited to 'vm') diff --git a/vm/vm_jit.go b/vm/vm_jit.go index 0150a4eef..4c0988df9 100644 --- a/vm/vm_jit.go +++ b/vm/vm_jit.go @@ -41,32 +41,22 @@ type JitVm struct { type i256 [32]byte -const ( - Gas = iota - address - Caller - Origin - CallValue - CallDataSize - GasPrice - CoinBase - TimeStamp - Number - Difficulty - GasLimit - CodeSize - - _size - - ReturnDataOffset = CallValue // Reuse 2 fields for return data reference - ReturnDataSize = CallDataSize - SuicideDestAddress = address ///< Suicide balance destination address -) - type RuntimeData struct { - elems [_size]i256 - callData *byte - code *byte + gas int64 + gasPrice int64 + callData *byte + callDataSize uint64 + address i256 + caller i256 + origin i256 + callValue i256 + coinBase i256 + difficulty i256 + gasLimit i256 + number uint64 + timestamp int64 + code *byte + codeSize uint64 } func hash2llvm(h []byte) i256 { @@ -182,21 +172,21 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi self.callerAddr = caller.Address() self.price = price - self.data.elems[Gas] = big2llvm(gas) - self.data.elems[address] = address2llvm(self.me.Address()) - self.data.elems[Caller] = address2llvm(caller.Address()) - self.data.elems[Origin] = address2llvm(self.env.Origin()) - self.data.elems[CallValue] = big2llvm(value) - self.data.elems[CallDataSize] = big2llvm(big.NewInt(int64(len(callData)))) // TODO: Keep call data size as i64 - self.data.elems[GasPrice] = big2llvm(price) - self.data.elems[CoinBase] = address2llvm(self.env.Coinbase()) - self.data.elems[TimeStamp] = big2llvm(big.NewInt(self.env.Time())) // TODO: Keep timestamp as i64 - self.data.elems[Number] = big2llvm(self.env.BlockNumber()) - self.data.elems[Difficulty] = big2llvm(self.env.Difficulty()) - self.data.elems[GasLimit] = big2llvm(self.env.GasLimit()) - self.data.elems[CodeSize] = big2llvm(big.NewInt(int64(len(code)))) // TODO: Keep code size as i64 + self.data.gas = gas.Int64() + self.data.gasPrice = price.Int64() self.data.callData = getDataPtr(callData) + self.data.callDataSize = uint64(len(callData)) + self.data.address = address2llvm(self.me.Address()) + self.data.caller = address2llvm(caller.Address()) + self.data.origin = address2llvm(self.env.Origin()) + self.data.callValue = big2llvm(value) + self.data.coinBase = address2llvm(self.env.Coinbase()) + self.data.difficulty = big2llvm(self.env.Difficulty()) + self.data.gasLimit = big2llvm(self.env.GasLimit()) + self.data.number = self.env.BlockNumber().Uint64() + self.data.timestamp = self.env.Time() self.data.code = getDataPtr(code) + self.data.codeSize = uint64(len(code)) result := C.evmjit_run(unsafe.Pointer(&self.data), unsafe.Pointer(self)) @@ -204,15 +194,14 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi err = errors.New("OOG from JIT") gas.SetInt64(0) // Set gas to 0, JIT does not bother } else { - gasLeft := llvm2big(&self.data.elems[Gas]) // TODO: Set value directly to gas instance - gas.Set(gasLeft) + gas.SetInt64(self.data.gas) if result.returnCode == 1 { // RETURN ret = C.GoBytes(result.returnData, C.int(result.returnDataSize)) C.free(result.returnData) } else if result.returnCode == 2 { // SUICIDE // TODO: Suicide support logic should be moved to Env to be shared by VM implementations state := self.Env().State() - receiverAddr := llvm2hashRef(bswap(&self.data.elems[address])) + receiverAddr := llvm2hashRef(bswap(&self.data.address)) receiver := state.GetOrNewStateObject(receiverAddr) balance := state.GetBalance(me.Address()) receiver.AddAmount(balance) -- cgit v1.2.3 From 079c59b929d5e09eebad6169c22f146bd2f060af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Bylica?= Date: Mon, 26 Jan 2015 18:02:09 +0100 Subject: Update JitVm to new EVM JIT ABI (C interface) --- vm/vm_jit.go | 28 +++++++++++----------------- 1 file changed, 11 insertions(+), 17 deletions(-) (limited to 'vm') diff --git a/vm/vm_jit.go b/vm/vm_jit.go index 4c0988df9..38cab57da 100644 --- a/vm/vm_jit.go +++ b/vm/vm_jit.go @@ -3,17 +3,10 @@ package vm /* -#include -#include -struct evmjit_result -{ - int32_t returnCode; - uint64_t returnDataSize; - void* returnData; -}; - -struct evmjit_result evmjit_run(void* _data, void* _env); +void* evmjit_create(); +int evmjit_run(void* _jit, void* _data, void* _env); +void evmjit_destroy(void* _jit); // Shared library evmjit (e.g. libevmjit.so) is expected to be installed in /usr/local/lib // More: https://github.com/ethereum/evmjit @@ -188,17 +181,17 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi self.data.code = getDataPtr(code) self.data.codeSize = uint64(len(code)) - result := C.evmjit_run(unsafe.Pointer(&self.data), unsafe.Pointer(self)) + jit := C.evmjit_create() + retCode := C.evmjit_run(jit, unsafe.Pointer(&self.data), unsafe.Pointer(self)) - if result.returnCode >= 100 { + if retCode < 0 { err = errors.New("OOG from JIT") gas.SetInt64(0) // Set gas to 0, JIT does not bother } else { gas.SetInt64(self.data.gas) - if result.returnCode == 1 { // RETURN - ret = C.GoBytes(result.returnData, C.int(result.returnDataSize)) - C.free(result.returnData) - } else if result.returnCode == 2 { // SUICIDE + if retCode == 1 { // RETURN + ret = C.GoBytes(unsafe.Pointer(self.data.callData), C.int(self.data.callDataSize)) + } else if retCode == 2 { // SUICIDE // TODO: Suicide support logic should be moved to Env to be shared by VM implementations state := self.Env().State() receiverAddr := llvm2hashRef(bswap(&self.data.address)) @@ -208,7 +201,8 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi state.Delete(me.Address()) } } - + + C.evmjit_destroy(jit); return } -- cgit v1.2.3 From 84adf77bf3492351de82f0ec820a1d280e85a5cd Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 29 Jan 2015 13:10:34 +0100 Subject: Added RPC "Call" for JS calls to contracts --- vm/vm.go | 2 ++ 1 file changed, 2 insertions(+) (limited to 'vm') diff --git a/vm/vm.go b/vm/vm.go index 37e4249f5..4364b1cb9 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -634,6 +634,8 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I continue } + self.Printf(" ~> false") + case JUMPDEST: case PC: stack.Push(big.NewInt(int64(pc))) -- cgit v1.2.3 From d52878c744fd7acce727feb41c2d4296e56826d3 Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 1 Feb 2015 15:29:57 +0100 Subject: Removed some VMEnv & Added VmType() to vm.Environment --- vm/environment.go | 2 ++ 1 file changed, 2 insertions(+) (limited to 'vm') diff --git a/vm/environment.go b/vm/environment.go index 8ec13ee41..8507e248f 100644 --- a/vm/environment.go +++ b/vm/environment.go @@ -22,6 +22,8 @@ type Environment interface { Transfer(from, to Account, amount *big.Int) error AddLog(state.Log) + VmType() Type + Depth() int SetDepth(i int) -- cgit v1.2.3 From 8ccde784f9035c0a7a8f234994538c817c5b9de7 Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 1 Feb 2015 15:30:29 +0100 Subject: Added (disabled) Jit validation --- vm/common.go | 12 ++++++++++++ 1 file changed, 12 insertions(+) (limited to 'vm') diff --git a/vm/common.go b/vm/common.go index ff187001f..45a7187a9 100644 --- a/vm/common.go +++ b/vm/common.go @@ -18,6 +18,18 @@ const ( MaxVmTy ) +func NewVm(env Environment) VirtualMachine { + switch env.VmType() { + case JitVmTy: + return NewJitVm(env) + default: + vmlogger.Infoln("unsupported vm type %d", env.VmType()) + fallthrough + case StdVmTy: + return New(env) + } +} + var ( GasStep = big.NewInt(1) GasSha = big.NewInt(10) -- cgit v1.2.3 From faa54e59c1c276d153299c73afdea246941ec952 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 2 Feb 2015 20:01:10 -0800 Subject: Make sure that CALL addr is always 20 bytes --- vm/vm.go | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) (limited to 'vm') diff --git a/vm/vm.go b/vm/vm.go index 4364b1cb9..69e061e54 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -516,7 +516,7 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I case BLOCKHASH: num := stack.Pop() - n := U256(new(big.Int).Sub(self.env.BlockNumber(), ethutil.Big257)) + 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()))) } else { @@ -681,8 +681,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I self.Dbg.SetCode(context.Code) } case CALL, CALLCODE: - self.Endl() - gas := stack.Pop() // Pop gas and value of the stack. value, addr := stack.Popn() @@ -691,6 +689,9 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I // Pop return size and offset retSize, retOffset := stack.Popn() + address := ethutil.Address(addr.Bytes()) + self.Printf(" => %x", address).Endl() + // Get the arguments from the memory args := mem.Get(inOffset.Int64(), inSize.Int64()) @@ -699,9 +700,9 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I err error ) if op == CALLCODE { - ret, err = self.env.CallCode(context, addr.Bytes(), args, gas, price, value) + ret, err = self.env.CallCode(context, address, args, gas, price, value) } else { - ret, err = self.env.Call(context, addr.Bytes(), args, gas, price, value) + ret, err = self.env.Call(context, address, args, gas, price, value) } if err != nil { -- cgit v1.2.3 From 3f03197daebace568a61bf69c06c97e30080a749 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 4 Feb 2015 07:39:02 -0800 Subject: Updated tests --- vm/vm.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'vm') diff --git a/vm/vm.go b/vm/vm.go index 69e061e54..2b8c90428 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -510,7 +510,7 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I case GASPRICE: stack.Push(context.Price) - self.Printf(" => %v", context.Price) + self.Printf(" => %x", context.Price) // 0x40 range case BLOCKHASH: @@ -643,6 +643,8 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I stack.Push(big.NewInt(int64(mem.Len()))) case GAS: stack.Push(context.Gas) + + self.Printf(" => %x", context.Gas) // 0x60 range case CREATE: @@ -653,6 +655,7 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I gas = new(big.Int).Set(context.Gas) addr []byte ) + self.Endl() context.UseGas(context.Gas) ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value) @@ -673,7 +676,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I stack.Push(ethutil.BigD(addr)) - self.Printf(" (*) %x", addr) } // Debug hook -- cgit v1.2.3 From 3f6baa45a7fb1ae5fd7966d2763a2a776a65eb96 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 11 Feb 2015 23:46:45 +0100 Subject: Documented methods & removed old manifest --- vm/vm.go | 11 ----------- 1 file changed, 11 deletions(-) (limited to 'vm') diff --git a/vm/vm.go b/vm/vm.go index 2b8c90428..29e1ade54 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -38,13 +38,6 @@ func New(env Environment) *Vm { func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { self.env.SetDepth(self.env.Depth() + 1) - msg := self.env.State().Manifest().AddMessage(&state.Message{ - To: me.Address(), From: caller.Address(), - Input: callData, - Origin: self.env.Origin(), - Timestamp: self.env.Time(), Coinbase: self.env.Coinbase(), Number: self.env.BlockNumber(), - Value: value, - }) context := NewContext(caller, me, code, gas, price) vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData) @@ -618,8 +611,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I val, loc := stack.Popn() statedb.SetState(context.Address(), loc.Bytes(), val) - msg.AddStorageChange(loc.Bytes()) - self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes()) case JUMP: jump(pc, stack.Pop()) @@ -670,7 +661,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I dataGas.Mul(dataGas, GasCreateByte) if context.UseGas(dataGas) { ref.SetCode(ret) - msg.Output = ret } addr = ref.Address() @@ -713,7 +703,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I vmlogger.Debugln(err) } else { stack.Push(ethutil.BigTrue) - msg.Output = ret mem.Set(retOffset.Uint64(), retSize.Uint64(), ret) } -- cgit v1.2.3