From 3d9a4e7084c33cb28a2265c0dd232a0ea3871c92 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 3 Dec 2014 12:21:12 +0100 Subject: [PATCH] Fixed mem error in vm. Fixed logs tests --- chain/bloom9.go | 4 ++-- cmd/ethereum/main.go | 2 +- cmd/mist/main.go | 2 +- tests/helper/vm.go | 17 +++++++++++------ tests/vm/gh_test.go | 40 ++++++++++++++++++++++++++++++++-------- vm/stack.go | 3 +-- vm/types.go | 5 +++++ vm/vm_debug.go | 10 ++++++---- 8 files changed, 59 insertions(+), 24 deletions(-) diff --git a/chain/bloom9.go b/chain/bloom9.go index c610bd101..9b2e379c8 100644 --- a/chain/bloom9.go +++ b/chain/bloom9.go @@ -11,13 +11,13 @@ import ( func CreateBloom(receipts Receipts) []byte { bin := new(big.Int) for _, receipt := range receipts { - bin.Or(bin, logsBloom(receipt.logs)) + bin.Or(bin, LogsBloom(receipt.logs)) } return ethutil.LeftPadBytes(bin.Bytes(), 64) } -func logsBloom(logs state.Logs) *big.Int { +func LogsBloom(logs state.Logs) *big.Int { bin := new(big.Int) for _, log := range logs { data := [][]byte{log.Address} diff --git a/cmd/ethereum/main.go b/cmd/ethereum/main.go index 1493de384..60052314c 100644 --- a/cmd/ethereum/main.go +++ b/cmd/ethereum/main.go @@ -30,7 +30,7 @@ import ( const ( ClientIdentifier = "Ethereum(G)" - Version = "0.7.6" + Version = "0.7.7" ) var clilogger = logger.NewLogger("CLI") diff --git a/cmd/mist/main.go b/cmd/mist/main.go index 39beeafdb..8c46de6d9 100644 --- a/cmd/mist/main.go +++ b/cmd/mist/main.go @@ -31,7 +31,7 @@ import ( const ( ClientIdentifier = "Mist" - Version = "0.7.6" + Version = "0.7.7" ) var ethereum *eth.Ethereum diff --git a/tests/helper/vm.go b/tests/helper/vm.go index b4ad93193..8e6645fc3 100644 --- a/tests/helper/vm.go +++ b/tests/helper/vm.go @@ -20,6 +20,8 @@ type Env struct { time int64 difficulty *big.Int gasLimit *big.Int + + logs state.Logs } func NewEnv(state *state.State) *Env { @@ -51,24 +53,27 @@ func (self *Env) Difficulty() *big.Int { return self.difficulty } func (self *Env) BlockHash() []byte { return nil } func (self *Env) State() *state.State { return self.state } func (self *Env) GasLimit() *big.Int { return self.gasLimit } -func (self *Env) AddLog(*state.Log) {} +func (self *Env) AddLog(log *state.Log) { + self.logs = append(self.logs, log) +} func (self *Env) Transfer(from, to vm.Account, amount *big.Int) error { return vm.Transfer(from, to, amount) } -func RunVm(state *state.State, env, exec map[string]string) ([]byte, *big.Int, error) { +func RunVm(state *state.State, env, exec map[string]string) ([]byte, state.Logs, *big.Int, error) { address := FromHex(exec["address"]) caller := state.GetOrNewStateObject(FromHex(exec["caller"])) - evm := vm.New(NewEnvFromMap(state, env, exec), vm.DebugVmTy) + vmenv := NewEnvFromMap(state, env, exec) + evm := vm.New(vmenv, vm.DebugVmTy) execution := vm.NewExecution(evm, address, FromHex(exec["data"]), ethutil.Big(exec["gas"]), ethutil.Big(exec["gasPrice"]), ethutil.Big(exec["value"])) execution.SkipTransfer = true ret, err := execution.Exec(address, caller) - return ret, execution.Gas, err + return ret, vmenv.logs, execution.Gas, err } -func RunState(state *state.State, env, tx map[string]string) ([]byte, *big.Int, error) { +func RunState(state *state.State, env, tx map[string]string) ([]byte, state.Logs, *big.Int, error) { address := FromHex(tx["to"]) keyPair, _ := crypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(tx["secretKey"]))) caller := state.GetOrNewStateObject(keyPair.Address()) @@ -79,5 +84,5 @@ func RunState(state *state.State, env, tx map[string]string) ([]byte, *big.Int, execution := vm.NewExecution(evm, address, FromHex(tx["data"]), ethutil.Big(tx["gasLimit"]), ethutil.Big(tx["gasPrice"]), ethutil.Big(tx["value"])) ret, err := execution.Exec(address, caller) - return ret, execution.Gas, err + return ret, vmenv.logs, execution.Gas, err } diff --git a/tests/vm/gh_test.go b/tests/vm/gh_test.go index 5391e0500..523ff46ac 100644 --- a/tests/vm/gh_test.go +++ b/tests/vm/gh_test.go @@ -6,6 +6,7 @@ import ( "strconv" "testing" + "github.com/ethereum/go-ethereum/chain" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/tests/helper" @@ -18,6 +19,12 @@ type Account struct { Storage map[string]string } +type Log struct { + Address string + Data string + Topics []string +} + func StateObjectFromAccount(addr string, account Account) *state.StateObject { obj := state.NewStateObject(ethutil.Hex2Bytes(addr)) obj.SetBalance(ethutil.Big(account.Balance)) @@ -46,6 +53,7 @@ type VmTest struct { Env Env Exec map[string]string Transaction map[string]string + Logs map[string]Log Gas string Out string Post map[string]Account @@ -57,10 +65,10 @@ func RunVmTest(p string, t *testing.T) { helper.CreateFileTests(t, p, &tests) for name, test := range tests { - state := state.New(helper.NewTrie()) + statedb := state.New(helper.NewTrie()) for addr, account := range test.Pre { obj := StateObjectFromAccount(addr, account) - state.SetStateObject(obj) + statedb.SetStateObject(obj) } // XXX Yeah, yeah... @@ -77,15 +85,16 @@ func RunVmTest(p string, t *testing.T) { } var ( - ret []byte - gas *big.Int - err error + ret []byte + gas *big.Int + err error + logs state.Logs ) if len(test.Exec) > 0 { - ret, gas, err = helper.RunVm(state, env, test.Exec) + ret, logs, gas, err = helper.RunVm(statedb, env, test.Exec) } else { - ret, gas, err = helper.RunState(state, env, test.Transaction) + ret, logs, gas, err = helper.RunState(statedb, env, test.Transaction) } // When an error is returned it doesn't always mean the tests fails. @@ -107,7 +116,7 @@ func RunVmTest(p string, t *testing.T) { } for addr, account := range test.Post { - obj := state.GetStateObject(helper.FromHex(addr)) + obj := statedb.GetStateObject(helper.FromHex(addr)) for addr, value := range account.Storage { v := obj.GetState(helper.FromHex(addr)).Bytes() vexp := helper.FromHex(value) @@ -117,6 +126,16 @@ func RunVmTest(p string, t *testing.T) { } } } + + if len(test.Logs) > 0 { + genBloom := ethutil.LeftPadBytes(chain.LogsBloom(logs).Bytes(), 64) + // Logs within the test itself aren't correct, missing empty fields (32 0s) + for bloom /*logs*/, _ := range test.Logs { + if !bytes.Equal(genBloom, ethutil.Hex2Bytes(bloom)) { + t.Errorf("bloom mismatch") + } + } + } } } @@ -161,6 +180,11 @@ func TestVm(t *testing.T) { RunVmTest(fn, t) } +func TestVmLog(t *testing.T) { + const fn = "../files/vmtests/vmLogTest.json" + RunVmTest(fn, t) +} + func TestStateSystemOperations(t *testing.T) { const fn = "../files/StateTests/stSystemOperationsTest.json" RunVmTest(fn, t) diff --git a/vm/stack.go b/vm/stack.go index 2eca60ad1..98795cc03 100644 --- a/vm/stack.go +++ b/vm/stack.go @@ -147,9 +147,8 @@ func (m *Memory) Get(offset, size int64) []byte { func (self *Memory) Geti(offset, size int64) (cpy []byte) { if len(self.store) > int(offset) { - s := int64(math.Min(float64(len(self.store)), float64(offset+size))) cpy = make([]byte, size) - copy(cpy, self.store[offset:offset+s]) + copy(cpy, self.store[offset:offset+size]) return } diff --git a/vm/types.go b/vm/types.go index 530dbf400..ec9c7e74e 100644 --- a/vm/types.go +++ b/vm/types.go @@ -308,6 +308,11 @@ var opCodeToString = map[OpCode]string{ SWAP14: "SWAP14", SWAP15: "SWAP15", SWAP16: "SWAP16", + LOG0: "LOG0", + LOG1: "LOG1", + LOG2: "LOG2", + LOG3: "LOG3", + LOG4: "LOG4", // 0xf0 range CREATE: "CREATE", diff --git a/vm/vm_debug.go b/vm/vm_debug.go index dbab8fbcb..91d3c55c1 100644 --- a/vm/vm_debug.go +++ b/vm/vm_debug.go @@ -35,7 +35,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) RunClosure(closure *Closure) (ret []byte, err error) { @@ -168,8 +168,10 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) { gas.Set(GasLog) addStepGasUsage(new(big.Int).Mul(big.NewInt(int64(n)), GasLog)) - mSize, _ := stack.Peekn() + mSize, mStart := stack.Peekn() addStepGasUsage(mSize) + + newMemSize = calcMemSize(mStart, mSize) case EXP: require(2) @@ -755,10 +757,10 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) { case LOG0, LOG1, LOG2, LOG3, LOG4: n := int(op - LOG0) topics := make([][]byte, n) - mStart, mSize := stack.Pop().Int64(), stack.Pop().Int64() + mSize, mStart := stack.Pop().Int64(), stack.Pop().Int64() data := mem.Geti(mStart, mSize) for i := 0; i < n; i++ { - topics[i] = stack.Pop().Bytes() + topics[i] = ethutil.LeftPadBytes(stack.Pop().Bytes(), 32) } log := &state.Log{closure.Address(), topics, data}