mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-07-26 14:46:42 +00:00
f770d3643b
This changes the internals of the EVM-JIT by dropping support for blocks (and therefor also transactions) that can exceed a 64^2-1 gas-limit. This means that the EVM-JIT can drop support for abritrary precision (*big.Int) and move to 64bit based gas calculations. For obvious reasons integer overflows have added to make sure that gas calculations such as gas for memory doesn't overflow 64bit. If the overflow check fails it throws an out-of-gas error and will halt the execution of the code.
308 lines
8.6 KiB
Go
308 lines
8.6 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of go-ethereum.
|
|
//
|
|
// go-ethereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// go-ethereum is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// evm executes EVM code snippets.
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"math/big"
|
|
"os"
|
|
"runtime"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/cmd/utils"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core"
|
|
"github.com/ethereum/go-ethereum/core/state"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
"github.com/ethereum/go-ethereum/logger/glog"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
"gopkg.in/urfave/cli.v1"
|
|
)
|
|
|
|
var gitCommit = "" // Git SHA1 commit hash of the release (set via linker flags)
|
|
|
|
var (
|
|
app = utils.NewApp(gitCommit, "the evm command line interface")
|
|
|
|
DebugFlag = cli.BoolFlag{
|
|
Name: "debug",
|
|
Usage: "output full trace logs",
|
|
}
|
|
ForceJitFlag = cli.BoolFlag{
|
|
Name: "forcejit",
|
|
Usage: "forces jit compilation",
|
|
}
|
|
DisableJitFlag = cli.BoolFlag{
|
|
Name: "nojit",
|
|
Usage: "disabled jit compilation",
|
|
}
|
|
CodeFlag = cli.StringFlag{
|
|
Name: "code",
|
|
Usage: "EVM code",
|
|
}
|
|
CodeFileFlag = cli.StringFlag{
|
|
Name: "codefile",
|
|
Usage: "file containing EVM code",
|
|
}
|
|
GasFlag = cli.StringFlag{
|
|
Name: "gas",
|
|
Usage: "gas limit for the evm",
|
|
Value: "10000000000",
|
|
}
|
|
PriceFlag = cli.StringFlag{
|
|
Name: "price",
|
|
Usage: "price set for the evm",
|
|
Value: "0",
|
|
}
|
|
ValueFlag = cli.StringFlag{
|
|
Name: "value",
|
|
Usage: "value set for the evm",
|
|
Value: "0",
|
|
}
|
|
DumpFlag = cli.BoolFlag{
|
|
Name: "dump",
|
|
Usage: "dumps the state after the run",
|
|
}
|
|
InputFlag = cli.StringFlag{
|
|
Name: "input",
|
|
Usage: "input for the EVM",
|
|
}
|
|
SysStatFlag = cli.BoolFlag{
|
|
Name: "sysstat",
|
|
Usage: "display system stats",
|
|
}
|
|
VerbosityFlag = cli.IntFlag{
|
|
Name: "verbosity",
|
|
Usage: "sets the verbosity level",
|
|
}
|
|
CreateFlag = cli.BoolFlag{
|
|
Name: "create",
|
|
Usage: "indicates the action should be create rather than call",
|
|
}
|
|
)
|
|
|
|
func init() {
|
|
app.Flags = []cli.Flag{
|
|
CreateFlag,
|
|
DebugFlag,
|
|
VerbosityFlag,
|
|
ForceJitFlag,
|
|
DisableJitFlag,
|
|
SysStatFlag,
|
|
CodeFlag,
|
|
CodeFileFlag,
|
|
GasFlag,
|
|
PriceFlag,
|
|
ValueFlag,
|
|
DumpFlag,
|
|
InputFlag,
|
|
}
|
|
app.Action = run
|
|
}
|
|
|
|
func run(ctx *cli.Context) error {
|
|
glog.SetToStderr(true)
|
|
glog.SetV(ctx.GlobalInt(VerbosityFlag.Name))
|
|
|
|
db, _ := ethdb.NewMemDatabase()
|
|
statedb, _ := state.New(common.Hash{}, db)
|
|
sender := statedb.CreateAccount(common.StringToAddress("sender"))
|
|
|
|
logger := vm.NewStructLogger(nil)
|
|
vmenv := NewEnv(statedb, common.StringToAddress("evmuser"), common.Big(ctx.GlobalString(ValueFlag.Name)), common.Big(ctx.GlobalString(PriceFlag.Name)), vm.Config{
|
|
Debug: ctx.GlobalBool(DebugFlag.Name),
|
|
ForceJit: ctx.GlobalBool(ForceJitFlag.Name),
|
|
EnableJit: !ctx.GlobalBool(DisableJitFlag.Name),
|
|
Tracer: logger,
|
|
})
|
|
|
|
tstart := time.Now()
|
|
|
|
var (
|
|
code []byte
|
|
ret []byte
|
|
err error
|
|
)
|
|
|
|
if ctx.GlobalString(CodeFlag.Name) != "" {
|
|
code = common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name))
|
|
} else {
|
|
var hexcode []byte
|
|
if ctx.GlobalString(CodeFileFlag.Name) != "" {
|
|
var err error
|
|
hexcode, err = ioutil.ReadFile(ctx.GlobalString(CodeFileFlag.Name))
|
|
if err != nil {
|
|
fmt.Printf("Could not load code from file: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
} else {
|
|
var err error
|
|
hexcode, err = ioutil.ReadAll(os.Stdin)
|
|
if err != nil {
|
|
fmt.Printf("Could not load code from stdin: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
code = common.Hex2Bytes(string(hexcode[:]))
|
|
}
|
|
|
|
if ctx.GlobalBool(CreateFlag.Name) {
|
|
input := append(code, common.Hex2Bytes(ctx.GlobalString(InputFlag.Name))...)
|
|
ret, _, err = vmenv.Create(
|
|
sender,
|
|
input,
|
|
common.Big(ctx.GlobalString(GasFlag.Name)),
|
|
common.Big(ctx.GlobalString(ValueFlag.Name)),
|
|
)
|
|
} else {
|
|
receiver := statedb.CreateAccount(common.StringToAddress("receiver"))
|
|
|
|
receiver.SetCode(crypto.Keccak256Hash(code), code)
|
|
ret, err = vmenv.Call(
|
|
sender,
|
|
receiver.Address(),
|
|
common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)),
|
|
common.Big(ctx.GlobalString(GasFlag.Name)),
|
|
common.Big(ctx.GlobalString(ValueFlag.Name)),
|
|
)
|
|
}
|
|
vmdone := time.Since(tstart)
|
|
|
|
if ctx.GlobalBool(DumpFlag.Name) {
|
|
statedb.Commit(true)
|
|
fmt.Println(string(statedb.Dump()))
|
|
}
|
|
vm.StdErrFormat(logger.StructLogs())
|
|
|
|
if ctx.GlobalBool(SysStatFlag.Name) {
|
|
var mem runtime.MemStats
|
|
runtime.ReadMemStats(&mem)
|
|
fmt.Printf("vm took %v\n", vmdone)
|
|
fmt.Printf(`alloc: %d
|
|
tot alloc: %d
|
|
no. malloc: %d
|
|
heap alloc: %d
|
|
heap objs: %d
|
|
num gc: %d
|
|
`, mem.Alloc, mem.TotalAlloc, mem.Mallocs, mem.HeapAlloc, mem.HeapObjects, mem.NumGC)
|
|
}
|
|
|
|
fmt.Printf("OUT: 0x%x", ret)
|
|
if err != nil {
|
|
fmt.Printf(" error: %v", err)
|
|
}
|
|
fmt.Println()
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
if err := app.Run(os.Args); err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
type VMEnv struct {
|
|
state *state.StateDB
|
|
block *types.Block
|
|
|
|
transactor *common.Address
|
|
value *big.Int
|
|
|
|
depth int
|
|
Gas, price *big.Int
|
|
time *big.Int
|
|
logs []vm.StructLog
|
|
|
|
evm *vm.EVM
|
|
}
|
|
|
|
func NewEnv(state *state.StateDB, transactor common.Address, value, price *big.Int, cfg vm.Config) *VMEnv {
|
|
env := &VMEnv{
|
|
state: state,
|
|
transactor: &transactor,
|
|
value: value,
|
|
price: price,
|
|
time: big.NewInt(time.Now().Unix()),
|
|
}
|
|
|
|
env.evm = vm.New(env, cfg)
|
|
return env
|
|
}
|
|
|
|
// ruleSet implements vm.ChainConfig and will always default to the homestead rule set.
|
|
type ruleSet struct{}
|
|
|
|
func (ruleSet) IsHomestead(*big.Int) bool { return true }
|
|
func (ruleSet) GasTable(*big.Int) params.GasTable {
|
|
return params.GasTableHomesteadGasRepriceFork
|
|
}
|
|
|
|
func (self *VMEnv) ChainConfig() *params.ChainConfig { return params.TestChainConfig }
|
|
func (self *VMEnv) Vm() vm.Vm { return self.evm }
|
|
func (self *VMEnv) Db() vm.Database { return self.state }
|
|
func (self *VMEnv) SnapshotDatabase() int { return self.state.Snapshot() }
|
|
func (self *VMEnv) RevertToSnapshot(snap int) { self.state.RevertToSnapshot(snap) }
|
|
func (self *VMEnv) Origin() common.Address { return *self.transactor }
|
|
func (self *VMEnv) BlockNumber() *big.Int { return common.Big0 }
|
|
func (self *VMEnv) Coinbase() common.Address { return *self.transactor }
|
|
func (self *VMEnv) Time() *big.Int { return self.time }
|
|
func (self *VMEnv) Difficulty() *big.Int { return common.Big1 }
|
|
func (self *VMEnv) BlockHash() []byte { return make([]byte, 32) }
|
|
func (self *VMEnv) Value() *big.Int { return self.value }
|
|
func (self *VMEnv) GasLimit() *big.Int { return big.NewInt(1000000000) }
|
|
func (self *VMEnv) GasPrice() *big.Int { return big.NewInt(1000000000) }
|
|
func (self *VMEnv) VmType() vm.Type { return vm.StdVmTy }
|
|
func (self *VMEnv) Depth() int { return 0 }
|
|
func (self *VMEnv) SetDepth(i int) { self.depth = i }
|
|
func (self *VMEnv) GetHash(n uint64) common.Hash {
|
|
if self.block.Number().Cmp(big.NewInt(int64(n))) == 0 {
|
|
return self.block.Hash()
|
|
}
|
|
return common.Hash{}
|
|
}
|
|
func (self *VMEnv) AddLog(log *vm.Log) {
|
|
self.state.AddLog(log)
|
|
}
|
|
func (self *VMEnv) CanTransfer(from common.Address, balance *big.Int) bool {
|
|
return self.state.GetBalance(from).Cmp(balance) >= 0
|
|
}
|
|
func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) {
|
|
core.Transfer(from, to, amount)
|
|
}
|
|
|
|
func (self *VMEnv) Call(caller vm.ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error) {
|
|
self.Gas = gas
|
|
return core.Call(self, caller, addr, data, gas, value)
|
|
}
|
|
|
|
func (self *VMEnv) CallCode(caller vm.ContractRef, addr common.Address, data []byte, gas, value *big.Int) ([]byte, error) {
|
|
return core.CallCode(self, caller, addr, data, gas, value)
|
|
}
|
|
|
|
func (self *VMEnv) DelegateCall(caller vm.ContractRef, addr common.Address, data []byte, gas *big.Int) ([]byte, error) {
|
|
return core.DelegateCall(self, caller, addr, data, gas)
|
|
}
|
|
|
|
func (self *VMEnv) Create(caller vm.ContractRef, data []byte, gas, value *big.Int) ([]byte, common.Address, error) {
|
|
return core.Create(self, caller, data, gas, value)
|
|
}
|