[R4R]Feature/backport geth native trace

cmd/evm/disasm.go

@@ -46,7 +46,7 @@ func disasmCmd(ctx *cli.Context) error {
  case ctx.GlobalIsSet(InputFlag.Name):
  in = ctx.GlobalString(InputFlag.Name)
  default:
- return errors.New("Missing filename or --input value")
+ return errors.New("missing filename or --input value")
  }
 
  code := strings.TrimSpace(in)

cmd/evm/internal/t8ntool/execution.go

@@ -82,7 +82,7 @@ type stEnvMarshaling struct {
 // Apply applies a set of transactions to a pre-state
 func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  txs types.Transactions, miningReward int64,
- getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.Tracer, err error)) (*state.StateDB, *ExecutionResult, error) {
+ getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error)) (*state.StateDB, *ExecutionResult, error) {
 
  // Capture errors for BLOCKHASH operation, if we haven't been supplied the
  // required blockhashes

cmd/evm/internal/t8ntool/flags.go

@@ -30,15 +30,15 @@ var (
  Name: "trace",
  Usage: "Output full trace logs to files <txhash>.jsonl",
  }
- TraceDisableMemoryFlag = cli.BoolFlag{
+ TraceDisableMemoryFlag = cli.BoolTFlag{
  Name: "trace.nomemory",
  Usage: "Disable full memory dump in traces",
  }
  TraceDisableStackFlag = cli.BoolFlag{
  Name: "trace.nostack",
  Usage: "Disable stack output in traces",
  }
- TraceDisableReturnDataFlag = cli.BoolFlag{
+ TraceDisableReturnDataFlag = cli.BoolTFlag{
  Name: "trace.noreturndata",
  Usage: "Disable return data output in traces",
  }

cmd/evm/internal/t8ntool/transition.go

@@ -81,10 +81,10 @@ func Main(ctx *cli.Context) error {
 
  var (
  err error
- tracer vm.Tracer
+ tracer vm.EVMLogger
  baseDir = ""
  )
- var getTracer func(txIndex int, txHash common.Hash) (vm.Tracer, error)
+ var getTracer func(txIndex int, txHash common.Hash) (vm.EVMLogger, error)
 
  // If user specified a basedir, make sure it exists
  if ctx.IsSet(OutputBasedir.Name) {
@@ -99,10 +99,10 @@ func Main(ctx *cli.Context) error {
  if ctx.Bool(TraceFlag.Name) {
  // Configure the EVM logger
  logConfig := &vm.LogConfig{
- DisableStack:  ctx.Bool(TraceDisableStackFlag.Name),
- DisableMemory: ctx.Bool(TraceDisableMemoryFlag.Name),
- DisableReturnData: ctx.Bool(TraceDisableReturnDataFlag.Name),
- Debug:  true,
+ DisableStack: ctx.Bool(TraceDisableStackFlag.Name),
+ EnableMemory: !ctx.Bool(TraceDisableMemoryFlag.Name),
+ EnableReturnData: !ctx.Bool(TraceDisableReturnDataFlag.Name),
+ Debug: true,
  }
  var prevFile *os.File
  // This one closes the last file
@@ -111,7 +111,7 @@ func Main(ctx *cli.Context) error {
  prevFile.Close()
  }
  }()
- getTracer = func(txIndex int, txHash common.Hash) (vm.Tracer, error) {
+ getTracer = func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) {
  if prevFile != nil {
  prevFile.Close()
  }
@@ -123,7 +123,7 @@ func Main(ctx *cli.Context) error {
  return vm.NewJSONLogger(logConfig, traceFile), nil
  }
  } else {
- getTracer = func(txIndex int, txHash common.Hash) (tracer vm.Tracer, err error) {
+ getTracer = func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error) {
  return nil, nil
  }
  }

cmd/evm/main.go

@@ -113,7 +113,7 @@ var (
  Name: "receiver",
  Usage: "The transaction receiver (execution context)",
  }
- DisableMemoryFlag = cli.BoolFlag{
+ DisableMemoryFlag = cli.BoolTFlag{
  Name: "nomemory",
  Usage: "disable memory output",
  }
@@ -125,9 +125,9 @@ var (
  Name: "nostorage",
  Usage: "disable storage output",
  }
- DisableReturnDataFlag = cli.BoolFlag{
+ DisableReturnDataFlag = cli.BoolTFlag{
  Name: "noreturndata",
- Usage: "disable return data output",
+ Usage: "enable return data output",
  }
  EVMInterpreterFlag = cli.StringFlag{
  Name: "vm.evm",

cmd/evm/runner.go

@@ -108,15 +108,15 @@ func runCmd(ctx *cli.Context) error {
  glogger.Verbosity(log.Lvl(ctx.GlobalInt(VerbosityFlag.Name)))
  log.Root().SetHandler(glogger)
  logconfig := &vm.LogConfig{
- DisableMemory: ctx.GlobalBool(DisableMemoryFlag.Name),
- DisableStack:  ctx.GlobalBool(DisableStackFlag.Name),
- DisableStorage:  ctx.GlobalBool(DisableStorageFlag.Name),
- DisableReturnData: ctx.GlobalBool(DisableReturnDataFlag.Name),
- Debug:  ctx.GlobalBool(DebugFlag.Name),
+ EnableMemory: !ctx.GlobalBool(DisableMemoryFlag.Name),
+ DisableStack: ctx.GlobalBool(DisableStackFlag.Name),
+ DisableStorage: ctx.GlobalBool(DisableStorageFlag.Name),
+ EnableReturnData: !ctx.GlobalBool(DisableReturnDataFlag.Name),
+ Debug: ctx.GlobalBool(DebugFlag.Name),
  }
 
  var (
- tracer vm.Tracer
+ tracer vm.EVMLogger
  debugLogger *vm.StructLogger
  statedb *state.StateDB
  chainConfig *params.ChainConfig

cmd/evm/staterunner.go

@@ -59,13 +59,13 @@ func stateTestCmd(ctx *cli.Context) error {
 
  // Configure the EVM logger
  config := &vm.LogConfig{
- DisableMemory: ctx.GlobalBool(DisableMemoryFlag.Name),
- DisableStack:  ctx.GlobalBool(DisableStackFlag.Name),
- DisableStorage:  ctx.GlobalBool(DisableStorageFlag.Name),
- DisableReturnData: ctx.GlobalBool(DisableReturnDataFlag.Name),
+ EnableMemory: !ctx.GlobalBool(DisableMemoryFlag.Name),
+ DisableStack: ctx.GlobalBool(DisableStackFlag.Name),
+ DisableStorage: ctx.GlobalBool(DisableStorageFlag.Name),
+ EnableReturnData: !ctx.GlobalBool(DisableReturnDataFlag.Name),
  }
  var (
- tracer vm.Tracer
+ tracer vm.EVMLogger
  debugger *vm.StructLogger
  )
  switch {

cmd/geth/main.go

@@ -39,6 +39,11 @@ import (
  "github.com/ethereum/go-ethereum/log"
  "github.com/ethereum/go-ethereum/metrics"
  "github.com/ethereum/go-ethereum/node"
+
+ // Force-load the tracer engines to trigger registration
+ _ "github.com/ethereum/go-ethereum/eth/tracers/js"
+ _ "github.com/ethereum/go-ethereum/eth/tracers/native"
+
  "gopkg.in/urfave/cli.v1"
 )
 

core/vm/access_list_tracer.go

@@ -141,7 +141,7 @@ func (a *AccessListTracer) CaptureStart(env *EVM, from common.Address, to common
 }
 
 // CaptureState captures all opcodes that touch storage or addresses and adds them to the accesslist.
-func (a *AccessListTracer) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, rData []byte, depth int, err error) {
+func (a *AccessListTracer) CaptureState(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, rData []byte, depth int, err error) {
  stack := scope.Stack
  if (op == SLOAD || op == SSTORE) && stack.len() >= 1 {
  slot := common.Hash(stack.data[stack.len()-1].Bytes32())
@@ -161,11 +161,16 @@ func (a *AccessListTracer) CaptureState(env *EVM, pc uint64, op OpCode, gas, cos
  }
 }
 
-func (*AccessListTracer) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, depth int, err error) {
+func (*AccessListTracer) CaptureFault(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, depth int, err error) {
 }
 
 func (*AccessListTracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) {}
 
+func (*AccessListTracer) CaptureEnter(typ OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+}
+
+func (*AccessListTracer) CaptureExit(output []byte, gasUsed uint64, err error) {}
+
 // AccessList returns the current accesslist maintained by the tracer.
 func (a *AccessListTracer) AccessList() types.AccessList {
  return a.list.accessList()

core/vm/evm.go

@@ -232,9 +232,14 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
  if !evm.StateDB.Exist(addr) {
  if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
  // Calling a non existing account, don't do anything, but ping the tracer
- if evm.vmConfig.Debug && evm.depth == 0 {
- evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
- evm.vmConfig.Tracer.CaptureEnd(ret, 0, 0, nil)
+ if evm.vmConfig.Debug {
+ if evm.depth == 0 {
+ evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
+ evm.vmConfig.Tracer.CaptureEnd(ret, 0, 0, nil)
+ } else {
+ evm.vmConfig.Tracer.CaptureEnter(CALL, caller.Address(), addr, input, gas, value)
+ evm.vmConfig.Tracer.CaptureExit(ret, 0, nil)
+ }
  }
  return nil, gas, nil
  }
@@ -243,11 +248,19 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
  evm.Context.Transfer(evm.StateDB, caller.Address(), addr, value)
 
  // Capture the tracer start/end events in debug mode
- if evm.vmConfig.Debug && evm.depth == 0 {
- evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
- defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters
- evm.vmConfig.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)
- }(gas, time.Now())
+ if evm.vmConfig.Debug {
+ if evm.depth == 0 {
+ evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
+ defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters
+ evm.vmConfig.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)
+ }(gas, time.Now())
+ } else {
+ // Handle tracer events for entering and exiting a call frame
+ evm.vmConfig.Tracer.CaptureEnter(CALL, caller.Address(), addr, input, gas, value)
+ defer func(startGas uint64) {
+ evm.vmConfig.Tracer.CaptureExit(ret, startGas-gas, err)
+ }(gas)
+ }
  }
 
  if isPrecompile {
@@ -307,6 +320,14 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
  }
  var snapshot = evm.StateDB.Snapshot()
 
+ // Invoke tracer hooks that signal entering/exiting a call frame
+ if evm.vmConfig.Debug {
+ evm.vmConfig.Tracer.CaptureEnter(CALLCODE, caller.Address(), addr, input, gas, value)
+ defer func(startGas uint64) {
+ evm.vmConfig.Tracer.CaptureExit(ret, startGas-gas, err)
+ }(gas)
+ }
+
  // It is allowed to call precompiles, even via delegatecall
  if p, isPrecompile := evm.precompile(addr); isPrecompile {
  ret, gas, err = RunPrecompiledContract(p, input, gas)
@@ -343,6 +364,14 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by
  }
  var snapshot = evm.StateDB.Snapshot()
 
+ // Invoke tracer hooks that signal entering/exiting a call frame
+ if evm.vmConfig.Debug {
+ evm.vmConfig.Tracer.CaptureEnter(DELEGATECALL, caller.Address(), addr, input, gas, nil)
+ defer func(startGas uint64) {
+ evm.vmConfig.Tracer.CaptureExit(ret, startGas-gas, err)
+ }(gas)
+ }
+
  // It is allowed to call precompiles, even via delegatecall
  if p, isPrecompile := evm.precompile(addr); isPrecompile {
  ret, gas, err = RunPrecompiledContract(p, input, gas)
@@ -388,6 +417,14 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte
  // future scenarios
  evm.StateDB.AddBalance(addr, big0)
 
+ // Invoke tracer hooks that signal entering/exiting a call frame
+ if evm.vmConfig.Debug {
+ evm.vmConfig.Tracer.CaptureEnter(STATICCALL, caller.Address(), addr, input, gas, nil)
+ defer func(startGas uint64) {
+ evm.vmConfig.Tracer.CaptureExit(ret, startGas-gas, err)
+ }(gas)
+ }
+
  if p, isPrecompile := evm.precompile(addr); isPrecompile {
  ret, gas, err = RunPrecompiledContract(p, input, gas)
  } else {
@@ -427,7 +464,7 @@ func (c *codeAndHash) Hash() common.Hash {
 }
 
 // create creates a new contract using code as deployment code.
-func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, value *big.Int, address common.Address) ([]byte, common.Address, uint64, error) {
+func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, value *big.Int, address common.Address, typ OpCode) ([]byte, common.Address, uint64, error) {
  // Depth check execution. Fail if we're trying to execute above the
  // limit.
  if evm.depth > int(params.CallCreateDepth) {
@@ -465,9 +502,14 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
  return nil, address, gas, nil
  }
 
- if evm.vmConfig.Debug && evm.depth == 0 {
- evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), address, true, codeAndHash.code, gas, value)
+ if evm.vmConfig.Debug {
+ if evm.depth == 0 {
+ evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), address, true, codeAndHash.code, gas, value)
+ } else {
+ evm.vmConfig.Tracer.CaptureEnter(typ, caller.Address(), address, codeAndHash.code, gas, value)
+ }
  }
+
  start := time.Now()
 
  ret, err := run(evm, contract, nil, false)
@@ -500,16 +542,20 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
  }
  }
 
- if evm.vmConfig.Debug && evm.depth == 0 {
- evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
+ if evm.vmConfig.Debug {
+ if evm.depth == 0 {
+ evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
+ } else {
+ evm.vmConfig.Tracer.CaptureExit(ret, gas-contract.Gas, err)
+ }
  }
  return ret, address, contract.Gas, err
 }
 
 // Create creates a new contract using code as deployment code.
 func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
  contractAddr = crypto.CreateAddress(caller.Address(), evm.StateDB.GetNonce(caller.Address()))
- return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr)
+ return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr, CREATE)
 }
 
 // Create2 creates a new contract using code as deployment code.
@@ -519,7 +565,7 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I
 func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
  codeAndHash := &codeAndHash{code: code}
  contractAddr = crypto.CreateAddress2(caller.Address(), salt.Bytes32(), codeAndHash.Hash().Bytes())
- return evm.create(caller, codeAndHash, gas, endowment, contractAddr)
+ return evm.create(caller, codeAndHash, gas, endowment, contractAddr, CREATE2)
 }
 
 // ChainConfig returns the environment's chain configuration

core/vm/instructions.go

@@ -791,6 +791,10 @@ func opSuicide(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]
  balance := interpreter.evm.StateDB.GetBalance(scope.Contract.Address())
  interpreter.evm.StateDB.AddBalance(beneficiary.Bytes20(), balance)
  interpreter.evm.StateDB.Suicide(scope.Contract.Address())
+ if interpreter.cfg.Debug {
+ interpreter.cfg.Tracer.CaptureEnter(SELFDESTRUCT, scope.Contract.Address(), beneficiary.Bytes20(), []byte{}, 0, balance)
+ interpreter.cfg.Tracer.CaptureExit([]byte{}, 0, nil)
+ }
  return nil, nil
 }
 

core/vm/interpreter.go

@@ -34,10 +34,10 @@ var EVMInterpreterPool = sync.Pool{
 
 // Config are the configuration options for the Interpreter
 type Config struct {
- Debug bool // Enables debugging
- Tracer Tracer // Opcode logger
- NoRecursion bool // Disables call, callcode, delegate call and create
- EnablePreimageRecording bool // Enables recording of SHA3/keccak preimages
+ Debug bool  // Enables debugging
+ Tracer EVMLogger // Opcode logger
+ NoRecursion bool  // Disables call, callcode, delegate call and create
+ EnablePreimageRecording bool  // Enables recording of SHA3/keccak preimages
 
  JumpTable [256]*operation // EVM instruction table, automatically populated if unset
 
@@ -183,9 +183,9 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
  pc = uint64(0) // program counter
  cost uint64
  // copies used by tracer
- pcCopy uint64 // needed for the deferred Tracer
- gasCopy uint64 // for Tracer to log gas remaining before execution
- logged bool // deferred Tracer should ignore already logged steps
+ pcCopy uint64 // needed for the deferred EVMLogger
+ gasCopy uint64 // for EVMLogger to log gas remaining before execution
+ logged bool // deferred EVMLogger should ignore already logged steps
  res []byte // result of the opcode execution function
  )
  // Don't move this deferrred function, it's placed before the capturestate-deferred method,
@@ -200,9 +200,9 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
  defer func() {
  if err != nil {
  if !logged {
- in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)
+ in.cfg.Tracer.CaptureState(pcCopy, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)
  } else {
- in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, callContext, in.evm.depth, err)
+ in.cfg.Tracer.CaptureFault(pcCopy, op, gasCopy, cost, callContext, in.evm.depth, err)
  }
  }
  }()
@@ -284,7 +284,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
  }
 
  if in.cfg.Debug {
- in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)
+ in.cfg.Tracer.CaptureState(pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)
  logged = true
  }