protocol/vm/vm.go

   1 package vm
   2
   3 import (
   4         "encoding/hex"
   5         "fmt"
   6         "io"
   7         "strings"
   8
   9         "github.com/holiman/uint256"
  10
  11         "github.com/bytom/bytom/errors"
  12 )
  13
  14 type virtualMachine struct {
  15         context *Context
  16
  17         program      []byte // the program currently executing
  18         pc, nextPC   uint32
  19         runLimit     int64
  20         deferredCost int64
  21
  22         expansionReserved bool
  23
  24         // Stores the data parsed out of an opcode. Used as input to
  25         // data-pushing opcodes.
  26         data []byte
  27
  28         // CHECKPREDICATE spawns a child vm with depth+1
  29         depth int
  30
  31         // In each of these stacks, stack[len(stack)-1] is the top element.
  32         dataStack [][]byte
  33         altStack  [][]byte
  34 }
  35
  36 // TraceOut - if non-nil - will receive trace output during
  37 // execution.
  38 var TraceOut io.Writer
  39
  40 // Verify program by running VM
  41 func Verify(context *Context, gasLimit int64) (gasLeft int64, err error) {
  42         defer func() {
  43                 if r := recover(); r != nil {
  44                         if rErr, ok := r.(error); ok {
  45                                 err = errors.Sub(ErrUnexpected, rErr)
  46                         } else {
  47                                 err = errors.Wrap(ErrUnexpected, r)
  48                         }
  49                 }
  50         }()
  51
  52         if context.VMVersion != 1 {
  53                 return gasLimit, ErrUnsupportedVM
  54         }
  55
  56         vm := &virtualMachine{
  57                 expansionReserved: context.TxVersion != nil && *context.TxVersion == 1,
  58                 program:           context.Code,
  59                 runLimit:          gasLimit,
  60                 context:           context,
  61         }
  62
  63         for i, state := range context.StateData {
  64                 if err = vm.pushAlt(state, false); err != nil {
  65                         return vm.runLimit, errors.Wrapf(err, "pushing initial statedata %d", i)
  66                 }
  67         }
  68
  69         for i, arg := range context.Arguments {
  70                 if err = vm.push(arg, false); err != nil {
  71                         return vm.runLimit, errors.Wrapf(err, "pushing initial argument %d", i)
  72                 }
  73         }
  74
  75         err = vm.run()
  76         if err == nil && vm.falseResult() {
  77                 err = ErrFalseVMResult
  78         }
  79
  80         return vm.runLimit, wrapErr(err, vm, context.Arguments)
  81 }
  82
  83 // falseResult returns true iff the stack is empty or the top
  84 // item is false
  85 func (vm *virtualMachine) falseResult() bool {
  86         return len(vm.dataStack) == 0 || !AsBool(vm.dataStack[len(vm.dataStack)-1])
  87 }
  88
  89 func (vm *virtualMachine) run() error {
  90         for vm.pc = 0; vm.pc < uint32(len(vm.program)); { // handle vm.pc updates in step
  91                 if err := vm.step(); err != nil {
  92                         return err
  93                 }
  94         }
  95         return nil
  96 }
  97
  98 func (vm *virtualMachine) step() error {
  99         inst, err := ParseOp(vm.program, vm.pc)
 100         if err != nil {
 101                 return err
 102         }
 103
 104         vm.nextPC = vm.pc + inst.Len
 105
 106         if TraceOut != nil {
 107                 opname := inst.Op.String()
 108                 fmt.Fprintf(TraceOut, "vm %d pc %d limit %d %s", vm.depth, vm.pc, vm.runLimit, opname)
 109                 if len(inst.Data) > 0 {
 110                         fmt.Fprintf(TraceOut, " %x", inst.Data)
 111                 }
 112                 fmt.Fprint(TraceOut, "\n")
 113         }
 114
 115         if isExpansion[inst.Op] {
 116                 if vm.expansionReserved {
 117                         return ErrDisallowedOpcode
 118                 }
 119                 vm.pc = vm.nextPC
 120                 return vm.applyCost(1)
 121         }
 122
 123         vm.deferredCost = 0
 124         vm.data = inst.Data
 125         if err = ops[inst.Op].fn(vm); err != nil {
 126                 return err
 127         }
 128
 129         if err = vm.applyCost(vm.deferredCost); err != nil {
 130                 return err
 131         }
 132
 133         vm.pc = vm.nextPC
 134         if TraceOut != nil {
 135                 for i := len(vm.dataStack) - 1; i >= 0; i-- {
 136                         fmt.Fprintf(TraceOut, "  stack %d: %x\n", len(vm.dataStack)-1-i, vm.dataStack[i])
 137                 }
 138         }
 139
 140         return nil
 141 }
 142
 143 func (vm *virtualMachine) push(data []byte, deferred bool) error {
 144         cost := 8 + int64(len(data))
 145         if deferred {
 146                 vm.deferCost(cost)
 147         } else if err := vm.applyCost(cost); err != nil {
 148                 return err
 149         }
 150
 151         vm.dataStack = append(vm.dataStack, data)
 152         return nil
 153 }
 154
 155 func (vm *virtualMachine) pushAlt(data []byte, deferred bool) error {
 156         cost := 8 + int64(len(data))
 157         if deferred {
 158                 vm.deferCost(cost)
 159         } else if err := vm.applyCost(cost); err != nil {
 160                 return err
 161         }
 162
 163         vm.altStack = append(vm.altStack, data)
 164         return nil
 165 }
 166
 167 func (vm *virtualMachine) pushBool(b bool, deferred bool) error {
 168         return vm.push(BoolBytes(b), deferred)
 169 }
 170
 171 func (vm *virtualMachine) pushInt64(n int64, deferred bool) error {
 172         return vm.push(Int64Bytes(n), deferred)
 173 }
 174
 175 func (vm *virtualMachine) pushBigInt(n *uint256.Int, deferred bool) error {
 176         return vm.push(BigIntBytes(n), deferred)
 177 }
 178
 179 func (vm *virtualMachine) pop(deferred bool) ([]byte, error) {
 180         if len(vm.dataStack) == 0 {
 181                 return nil, ErrDataStackUnderflow
 182         }
 183         res := vm.dataStack[len(vm.dataStack)-1]
 184         vm.dataStack = vm.dataStack[:len(vm.dataStack)-1]
 185
 186         cost := 8 + int64(len(res))
 187         if deferred {
 188                 vm.deferCost(-cost)
 189         } else {
 190                 vm.runLimit += cost
 191         }
 192
 193         return res, nil
 194 }
 195
 196 func (vm *virtualMachine) popInt64(deferred bool) (int64, error) {
 197         bytes, err := vm.pop(deferred)
 198         if err != nil {
 199                 return 0, err
 200         }
 201
 202         return AsInt64(bytes)
 203 }
 204
 205 func (vm *virtualMachine) popBigInt(deferred bool) (*uint256.Int, error) {
 206         bytes, err := vm.pop(deferred)
 207         if err != nil {
 208                 return nil, err
 209         }
 210
 211         return AsBigInt(bytes)
 212 }
 213
 214 func (vm *virtualMachine) top() ([]byte, error) {
 215         if len(vm.dataStack) == 0 {
 216                 return nil, ErrDataStackUnderflow
 217         }
 218
 219         return vm.dataStack[len(vm.dataStack)-1], nil
 220 }
 221
 222 // positive cost decreases runlimit, negative cost increases it
 223 func (vm *virtualMachine) applyCost(n int64) error {
 224         if n > vm.runLimit {
 225                 vm.runLimit = 0
 226                 return ErrRunLimitExceeded
 227         }
 228
 229         vm.runLimit -= n
 230         return nil
 231 }
 232
 233 func (vm *virtualMachine) deferCost(n int64) {
 234         vm.deferredCost += n
 235 }
 236
 237 func stackCost(stack [][]byte) int64 {
 238         result := int64(8 * len(stack))
 239         for _, item := range stack {
 240                 result += int64(len(item))
 241         }
 242         return result
 243 }
 244
 245 func wrapErr(err error, vm *virtualMachine, args [][]byte) error {
 246         if err == nil {
 247                 return nil
 248         }
 249
 250         dis, errDis := Disassemble(vm.program)
 251         if errDis != nil {
 252                 dis = "???"
 253         }
 254
 255         dataArgs := make([]string, 0, len(args))
 256         for _, a := range args {
 257                 dataArgs = append(dataArgs, hex.EncodeToString(a))
 258         }
 259
 260         return errors.Wrap(err, fmt.Sprintf("%s [prog %x = %s; args %s]", err.Error(), vm.program, dis, strings.Join(dataArgs, " ")))
 261 }