aboutsummaryrefslogtreecommitdiffstats
path: root/core/vm/vm.go
diff options
context:
space:
mode:
Diffstat (limited to 'core/vm/vm.go')
-rw-r--r--core/vm/vm.go200
1 files changed, 60 insertions, 140 deletions
diff --git a/core/vm/vm.go b/core/vm/vm.go
index 2bd950385..4c0ab0f47 100644
--- a/core/vm/vm.go
+++ b/core/vm/vm.go
@@ -7,16 +7,13 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/params"
)
+// Vm implements VirtualMachine
type Vm struct {
env Environment
- logTy byte
- logStr string
-
err error
// For logging
debug bool
@@ -31,13 +28,13 @@ type Vm struct {
After func(*Context, error)
}
+// New returns a new Virtual Machine
func New(env Environment) *Vm {
- lt := LogTyPretty
-
- return &Vm{debug: Debug, env: env, logTy: lt, Recoverable: true}
+ return &Vm{env: env, debug: Debug, Recoverable: true}
}
-func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
+// Run loops and evaluates the contract's code with the given input data
+func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
self.env.SetDepth(self.env.Depth() + 1)
defer self.env.SetDepth(self.env.Depth() - 1)
@@ -48,8 +45,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
price = context.Price
)
- self.Printf("(%d) (%x) %x (code=%d) gas: %v (d) %x", self.env.Depth(), caller.Address().Bytes()[:4], context.Address(), len(code), context.Gas, callData).Endl()
-
// User defer pattern to check for an error and, based on the error being nil or not, use all gas and return.
defer func() {
if self.After != nil {
@@ -57,7 +52,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
}
if err != nil {
- self.Printf(" %v", err).Endl()
+
// In case of a VM exception (known exceptions) all gas consumed (panics NOT included).
context.UseGas(context.Gas)
@@ -67,7 +62,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
if context.CodeAddr != nil {
if p := Precompiled[context.CodeAddr.Str()]; p != nil {
- return self.RunPrecompiled(p, callData, context)
+ return self.RunPrecompiled(p, input, context)
}
}
@@ -77,23 +72,24 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
}
var (
- op OpCode
- codehash = crypto.Sha3Hash(code)
- mem = NewMemory()
- stack = newStack()
- pc = new(big.Int)
- statedb = self.env.State()
-
- jump = func(from *big.Int, to *big.Int) error {
+ op OpCode // current opcode
+ codehash = crypto.Sha3Hash(code) // codehash is used when doing jump dest caching
+ mem = NewMemory() // bound memory
+ stack = newstack() // local stack
+ statedb = self.env.State() // current state
+ // For optimisation reason we're using uint64 as the program counter.
+ // It's theoretically possible to go above 2^64. The YP defines the PC to be uint256. Pratically much less so feasible.
+ pc = uint64(0) // program counter
+
+ // jump evaluates and checks whether the given jump destination is a valid one
+ // if valid move the `pc` otherwise return an error.
+ jump = func(from uint64, to *big.Int) error {
if !context.jumpdests.has(codehash, code, to) {
- nop := context.GetOp(to)
+ nop := context.GetOp(to.Uint64())
return fmt.Errorf("invalid jump destination (%v) %v", nop, to)
}
- self.Printf(" ~> %v", to)
- pc = to
-
- self.Endl()
+ pc = to.Uint64()
return nil
}
@@ -106,63 +102,56 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
// 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())
+ // calculate the new memory size and gas price for the current executing opcode
newMemSize, gas, err := self.calculateGasAndSize(context, caller, op, statedb, mem, stack)
if err != nil {
return nil, err
}
- self.Printf("(g) %-3v (%v)", gas, context.Gas)
+ self.log(pc, op, context.Gas, gas, mem, stack, context)
+ // Use the calculated gas. When insufficient gas is present, use all gas and return an
+ // Out Of Gas error
if !context.UseGas(gas) {
- self.Endl()
-
tmp := new(big.Int).Set(context.Gas)
context.UseGas(context.Gas)
return context.Return(nil), OOG(gas, tmp)
}
-
+ // Resize the memory calculated previously
mem.Resize(newMemSize.Uint64())
switch op {
case ADD:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v + %v", y, x)
base.Add(x, y)
U256(base)
- self.Printf(" = %v", base)
// pop result back on the stack
stack.push(base)
case SUB:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v - %v", x, y)
base.Sub(x, y)
U256(base)
- self.Printf(" = %v", base)
// pop result back on the stack
stack.push(base)
case MUL:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v * %v", y, x)
base.Mul(x, y)
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(common.Big0) != 0 {
base.Div(x, y)
@@ -170,14 +159,11 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
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(common.Big0) == 0 {
base.Set(common.Big0)
} else {
@@ -193,13 +179,10 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
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(common.Big0) == 0 {
base.Set(common.Big0)
} else {
@@ -208,13 +191,10 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
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(common.Big0) == 0 {
base.Set(common.Big0)
} else {
@@ -230,20 +210,15 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
U256(base)
}
- self.Printf(" = %v", base)
stack.push(base)
case EXP:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v ** %v", x, y)
-
base.Exp(x, y, Pow256)
U256(base)
- self.Printf(" = %v", base)
-
stack.push(base)
case SIGNEXTEND:
back := stack.pop()
@@ -260,15 +235,13 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
num = U256(num)
- self.Printf(" = %v", num)
-
stack.push(num)
}
case NOT:
stack.push(U256(new(big.Int).Not(stack.pop())))
case LT:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v < %v", x, y)
+
// x < y
if x.Cmp(y) < 0 {
stack.push(common.BigTrue)
@@ -277,7 +250,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
}
case GT:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v > %v", x, y)
// x > y
if x.Cmp(y) > 0 {
@@ -288,7 +260,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
case SLT:
x, y := S256(stack.pop()), S256(stack.pop())
- self.Printf(" %v < %v", x, y)
+
// x < y
if x.Cmp(S256(y)) < 0 {
stack.push(common.BigTrue)
@@ -297,7 +269,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
}
case SGT:
x, y := S256(stack.pop()), S256(stack.pop())
- self.Printf(" %v > %v", x, y)
// x > y
if x.Cmp(y) > 0 {
@@ -308,7 +279,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
case EQ:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v == %v", y, x)
// x == y
if x.Cmp(y) == 0 {
@@ -326,17 +296,14 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
case AND:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v & %v", y, x)
stack.push(base.And(x, y))
case OR:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v | %v", x, y)
stack.push(base.Or(x, y))
case XOR:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v ^ %v", x, y)
stack.push(base.Xor(x, y))
case BYTE:
@@ -350,8 +317,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
base.Set(common.BigFalse)
}
- self.Printf(" => 0x%x", base.Bytes())
-
stack.push(base)
case ADDMOD:
x := stack.pop()
@@ -365,8 +330,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
base = U256(base)
}
- self.Printf(" %v + %v %% %v = %v", x, y, z, base)
-
stack.push(base)
case MULMOD:
x := stack.pop()
@@ -380,8 +343,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
U256(base)
}
- self.Printf(" %v + %v %% %v = %v", x, y, z, base)
-
stack.push(base)
case SHA3:
@@ -390,55 +351,45 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
stack.push(common.BigD(data))
- self.Printf(" => (%v) %x", size, data)
case ADDRESS:
stack.push(common.Bytes2Big(context.Address().Bytes()))
- self.Printf(" => %x", context.Address())
case BALANCE:
addr := common.BigToAddress(stack.pop())
balance := statedb.GetBalance(addr)
stack.push(balance)
- self.Printf(" => %v (%x)", balance, addr)
case ORIGIN:
origin := self.env.Origin()
stack.push(origin.Big())
- self.Printf(" => %x", origin)
case CALLER:
caller := context.caller.Address()
stack.push(common.Bytes2Big(caller.Bytes()))
- self.Printf(" => %x", caller)
case CALLVALUE:
stack.push(value)
- self.Printf(" => %v", value)
case CALLDATALOAD:
- data := getData(callData, stack.pop(), common.Big32)
-
- self.Printf(" => 0x%x", data)
+ data := getData(input, stack.pop(), common.Big32)
stack.push(common.Bytes2Big(data))
case CALLDATASIZE:
- l := int64(len(callData))
+ l := int64(len(input))
stack.push(big.NewInt(l))
- self.Printf(" => %d", l)
case CALLDATACOPY:
var (
mOff = stack.pop()
cOff = stack.pop()
l = stack.pop()
)
- data := getData(callData, cOff, l)
+ data := getData(input, cOff, l)
mem.Set(mOff.Uint64(), l.Uint64(), data)
- self.Printf(" => [%v, %v, %v]", mOff, cOff, l)
case CODESIZE, EXTCODESIZE:
var code []byte
if op == EXTCODESIZE {
@@ -452,7 +403,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
l := big.NewInt(int64(len(code)))
stack.push(l)
- self.Printf(" => %d", l)
case CODECOPY, EXTCODECOPY:
var code []byte
if op == EXTCODECOPY {
@@ -472,12 +422,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
mem.Set(mOff.Uint64(), l.Uint64(), codeCopy)
- self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy)
case GASPRICE:
stack.push(context.Price)
- self.Printf(" => %x", context.Price)
-
case BLOCKHASH:
num := stack.pop()
@@ -488,56 +435,47 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
stack.push(common.Big0)
}
- self.Printf(" => 0x%x", stack.peek().Bytes())
case COINBASE:
coinbase := self.env.Coinbase()
stack.push(coinbase.Big())
- 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(U256(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())
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 := big.NewInt(int64(op - PUSH1 + 1))
- byts := getData(code, new(big.Int).Add(pc, big.NewInt(1)), a)
+ size := uint64(op - PUSH1 + 1)
+ byts := getData(code, new(big.Int).SetUint64(pc+1), new(big.Int).SetUint64(size))
// push value to stack
stack.push(common.Bytes2Big(byts))
- pc.Add(pc, a)
+ pc += size
- 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.dup(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)
stack.swap(n)
- self.Printf(" => [%d]", n)
case LOG0, LOG1, LOG2, LOG3, LOG4:
n := int(op - LOG0)
topics := make([]common.Hash, n)
@@ -550,38 +488,32 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
log := state.NewLog(context.Address(), topics, data, self.env.BlockNumber().Uint64())
self.env.AddLog(log)
- self.Printf(" => %v", log)
case MLOAD:
offset := stack.pop()
val := common.BigD(mem.Get(offset.Int64(), 32))
stack.push(val)
- self.Printf(" => 0x%x", val.Bytes())
case MSTORE:
// pop value of the stack
mStart, val := stack.pop(), stack.pop()
mem.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256))
- self.Printf(" => 0x%x", val)
case MSTORE8:
off, val := stack.pop().Int64(), stack.pop().Int64()
mem.store[off] = byte(val & 0xff)
- self.Printf(" => [%v] 0x%x", off, mem.store[off])
case SLOAD:
loc := common.BigToHash(stack.pop())
val := common.Bytes2Big(statedb.GetState(context.Address(), loc))
stack.push(val)
- self.Printf(" {0x%x : 0x%x}", loc, val.Bytes())
case SSTORE:
loc := common.BigToHash(stack.pop())
val := stack.pop()
statedb.SetState(context.Address(), loc, val)
- self.Printf(" {0x%x : 0x%x}", loc, val.Bytes())
case JUMP:
if err := jump(pc, stack.pop()); err != nil {
return nil, err
@@ -599,17 +531,14 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
continue
}
- self.Printf(" ~> false")
-
case JUMPDEST:
case PC:
- stack.push(pc)
+ stack.push(new(big.Int).SetUint64(pc))
case MSIZE:
stack.push(big.NewInt(int64(mem.Len())))
case GAS:
stack.push(context.Gas)
- self.Printf(" => %x", context.Gas)
case CREATE:
var (
@@ -619,14 +548,12 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
gas = new(big.Int).Set(context.Gas)
addr common.Address
)
- self.Endl()
context.UseGas(context.Gas)
ret, suberr, ref := self.env.Create(context, input, gas, price, value)
if suberr != nil {
stack.push(common.BigFalse)
- self.Printf(" (*) 0x0 %v", suberr)
} else {
// gas < len(ret) * CreateDataGas == NO_CODE
dataGas := big.NewInt(int64(len(ret)))
@@ -651,7 +578,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
retOffset, retSize := stack.pop(), stack.pop()
address := common.BigToAddress(addr)
- self.Printf(" => %x", address).Endl()
// Get the arguments from the memory
args := mem.Get(inOffset.Int64(), inSize.Int64())
@@ -673,47 +599,41 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
if err != nil {
stack.push(common.BigFalse)
- self.Printf("%v").Endl()
} else {
stack.push(common.BigTrue)
mem.Set(retOffset.Uint64(), retSize.Uint64(), ret)
}
- self.Printf("resume %x (%v)", context.Address(), context.Gas)
+
case RETURN:
offset, size := stack.pop(), stack.pop()
ret := mem.GetPtr(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(common.BigToAddress(stack.pop()))
balance := statedb.GetBalance(context.Address())
- self.Printf(" => (%x) %v", receiver.Address().Bytes()[:4], balance)
-
receiver.AddBalance(balance)
statedb.Delete(context.Address())
fallthrough
case STOP: // Stop the context
- self.Endl()
return context.Return(nil), nil
default:
- self.Printf("(pc) %-3v Invalid opcode %x\n", pc, op).Endl()
return nil, fmt.Errorf("Invalid opcode %x", op)
}
- pc.Add(pc, One)
+ pc++
- self.Endl()
}
}
+// calculateGasAndSize calculates the required given the opcode and stack items calculates the new memorysize for
+// the operation. This does not reduce gas or resizes the memory.
func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int, error) {
var (
gas = new(big.Int)
@@ -855,40 +775,40 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo
return newMemSize, gas, nil
}
-func (self *Vm) RunPrecompiled(p *PrecompiledAccount, callData []byte, context *Context) (ret []byte, err error) {
- gas := p.Gas(len(callData))
+// RunPrecompile runs and evaluate the output of a precompiled contract defined in contracts.go
+func (self *Vm) RunPrecompiled(p *PrecompiledAccount, input []byte, context *Context) (ret []byte, err error) {
+ gas := p.Gas(len(input))
if context.UseGas(gas) {
- ret = p.Call(callData)
- self.Printf("NATIVE_FUNC => %x", ret)
- self.Endl()
+ ret = p.Call(input)
return context.Return(ret), nil
} else {
- self.Printf("NATIVE_FUNC => failed").Endl()
-
tmp := new(big.Int).Set(context.Gas)
return nil, OOG(gas, tmp)
}
}
-func (self *Vm) Printf(format string, v ...interface{}) VirtualMachine {
- if self.debug {
- self.logStr += fmt.Sprintf(format, v...)
+// log emits a log event to the environment for each opcode encountered. This is not to be confused with the
+// LOG* opcode.
+func (self *Vm) log(pc uint64, op OpCode, gas, cost *big.Int, memory *Memory, stack *stack, context *Context) {
+ if Debug {
+ mem := make([]byte, len(memory.Data()))
+ copy(mem, memory.Data())
+ stck := make([]*big.Int, len(stack.Data()))
+ copy(stck, stack.Data())
+
+ object := context.self.(*state.StateObject)
+ storage := make(map[common.Hash][]byte)
+ object.EachStorage(func(k, v []byte) {
+ storage[common.BytesToHash(k)] = v
+ })
+
+ self.env.AddStructLog(StructLog{pc, op, new(big.Int).Set(gas), cost, mem, stck, storage})
}
-
- return self
-}
-
-func (self *Vm) Endl() VirtualMachine {
- if self.debug {
- glog.V(0).Infoln(self.logStr)
- self.logStr = ""
- }
-
- return self
}
+// Environment returns the current workable state of the VM
func (self *Vm) Env() Environment {
return self.env
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-22 07:57:42 +0800