From b7006034b13ecff7195ea7fae600a8b2e220b6a7 Mon Sep 17 00:00:00 2001 From: Nikolay Volf Date: Tue, 1 Aug 2017 13:37:57 +0300 Subject: [PATCH] Decouple virtual machines (#6184) * work in progress for splitting vms * evm working * Evm -> Vm * wasm converted * ethcore working * test fixes --- Cargo.lock | 34 +++- ethcore/Cargo.toml | 2 + ethcore/evm/Cargo.toml | 1 + ethcore/evm/src/benches/mod.rs | 2 +- ethcore/evm/src/evm.rs | 147 +----------------- ethcore/evm/src/factory.rs | 6 +- ethcore/evm/src/interpreter/gasometer.rs | 22 +-- ethcore/evm/src/interpreter/memory.rs | 2 +- ethcore/evm/src/interpreter/mod.rs | 42 ++--- ethcore/evm/src/jit.rs | 7 +- ethcore/evm/src/lib.rs | 20 +-- ethcore/evm/src/tests.rs | 46 +++--- ethcore/light/Cargo.toml | 1 + ethcore/light/src/lib.rs | 1 + ethcore/light/src/on_demand/request.rs | 2 +- ethcore/src/block.rs | 4 +- ethcore/src/builtin.rs | 6 +- ethcore/src/client/client.rs | 3 +- ethcore/src/client/evm_test_client.rs | 4 +- ethcore/src/client/mod.rs | 2 +- ethcore/src/client/test_client.rs | 3 +- ethcore/src/client/traits.rs | 2 +- ethcore/src/engines/authority_round/mod.rs | 2 +- ethcore/src/engines/mod.rs | 8 +- .../engines/validator_set/safe_contract.rs | 2 +- ethcore/src/ethereum/ethash.rs | 4 +- ethcore/src/executed.rs | 4 +- ethcore/src/executive.rs | 65 ++++---- ethcore/src/externalities.rs | 43 +++-- ethcore/src/json_tests/executive.rs | 33 ++-- ethcore/src/json_tests/state.rs | 2 +- ethcore/src/lib.rs | 2 + ethcore/src/spec/spec.rs | 14 +- ethcore/src/state/mod.rs | 4 +- ethcore/src/tests/evm.rs | 4 +- ethcore/src/trace/executive_tracer.rs | 2 +- ethcore/src/trace/mod.rs | 2 +- ethcore/src/trace/noop_tracer.rs | 2 +- ethcore/src/trace/types/error.rs | 28 ++-- ethcore/src/trace/types/trace.rs | 2 +- ethcore/vm/Cargo.toml | 14 ++ ethcore/{evm => vm}/src/action_params.rs | 4 +- ethcore/{evm => vm}/src/call_type.rs | 0 ethcore/{evm => vm}/src/env_info.rs | 0 ethcore/vm/src/error.rs | 100 ++++++++++++ ethcore/{evm => vm}/src/ext.rs | 25 +-- ethcore/vm/src/lib.rs | 46 ++++++ ethcore/vm/src/return_data.rs | 68 ++++++++ ethcore/{evm => vm}/src/schedule.rs | 7 + ethcore/wasm/Cargo.toml | 12 ++ .../{evm/src/wasm => wasm/src}/call_args.rs | 0 ethcore/{evm/src/wasm => wasm/src}/env.rs | 0 .../{evm/src/wasm/mod.rs => wasm/src/lib.rs} | 31 ++-- ethcore/{evm/src/wasm => wasm/src}/ptr.rs | 0 ethcore/{evm/src/wasm => wasm/src}/result.rs | 0 ethcore/{evm/src/wasm => wasm/src}/runtime.rs | 13 +- ethcore/{evm/src/wasm => wasm/src}/tests.rs | 2 +- evmbin/benches/mod.rs | 2 +- evmbin/src/main.rs | 2 +- evmbin/src/vm.rs | 2 +- rpc/Cargo.toml | 2 +- rpc/src/lib.rs | 2 +- rpc/src/v1/helpers/light_fetch.rs | 2 +- rpc/src/v1/tests/mocked/traces.rs | 2 +- rpc/src/v1/types/trace.rs | 16 +- 65 files changed, 534 insertions(+), 400 deletions(-) create mode 100644 ethcore/vm/Cargo.toml rename ethcore/{evm => vm}/src/action_params.rs (98%) rename ethcore/{evm => vm}/src/call_type.rs (100%) rename ethcore/{evm => vm}/src/env_info.rs (100%) create mode 100644 ethcore/vm/src/error.rs rename ethcore/{evm => vm}/src/ext.rs (85%) create mode 100644 ethcore/vm/src/lib.rs create mode 100644 ethcore/vm/src/return_data.rs rename ethcore/{evm => vm}/src/schedule.rs (98%) create mode 100644 ethcore/wasm/Cargo.toml rename ethcore/{evm/src/wasm => wasm/src}/call_args.rs (100%) rename ethcore/{evm/src/wasm => wasm/src}/env.rs (100%) rename ethcore/{evm/src/wasm/mod.rs => wasm/src/lib.rs} (83%) rename ethcore/{evm/src/wasm => wasm/src}/ptr.rs (100%) rename ethcore/{evm/src/wasm => wasm/src}/result.rs (100%) rename ethcore/{evm/src/wasm => wasm/src}/runtime.rs (97%) rename ethcore/{evm/src/wasm => wasm/src}/tests.rs (99%) diff --git a/Cargo.lock b/Cargo.lock index b8e163639..49a657806 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,6 +1,14 @@ [root] -name = "using_queue" +name = "wasm" version = "0.1.0" +dependencies = [ + "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "ethcore-util 1.8.0", + "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", + "parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)", + "vm 0.1.0", + "wasm-utils 0.1.0 (git+https://github.com/paritytech/wasm-utils)", +] [[package]] name = "advapi32-sys" @@ -504,6 +512,8 @@ dependencies = [ "stats 0.1.0", "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)", "transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", + "vm 0.1.0", + "wasm 0.1.0", ] [[package]] @@ -625,6 +635,7 @@ dependencies = [ "smallvec 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "stats 0.1.0", "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)", + "vm 0.1.0", ] [[package]] @@ -888,6 +899,7 @@ dependencies = [ "parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)", "rlp 0.2.0", "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "vm 0.1.0", "wasm-utils 0.1.0 (git+https://github.com/paritytech/wasm-utils)", ] @@ -1933,7 +1945,6 @@ dependencies = [ "ethkey 0.2.0", "ethstore 0.1.0", "ethsync 1.8.0", - "evm 0.1.0", "fetch 0.1.0", "futures 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)", "futures-cpupool 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1962,6 +1973,7 @@ dependencies = [ "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)", "tokio-timer 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", + "vm 0.1.0", ] [[package]] @@ -3044,6 +3056,10 @@ dependencies = [ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "using_queue" +version = "0.1.0" + [[package]] name = "utf8-ranges" version = "1.0.0" @@ -3072,6 +3088,20 @@ dependencies = [ "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "vm" +version = "0.1.0" +dependencies = [ + "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "common-types 0.1.0", + "ethcore-util 1.8.0", + "ethjson 0.1.0", + "evmjit 1.8.0", + "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", + "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", + "rlp 0.2.0", +] + [[package]] name = "void" version = "1.0.2" diff --git a/ethcore/Cargo.toml b/ethcore/Cargo.toml index 71e329201..60f145902 100644 --- a/ethcore/Cargo.toml +++ b/ethcore/Cargo.toml @@ -53,6 +53,8 @@ semver = "0.6" stats = { path = "../util/stats" } time = "0.1" transient-hashmap = "0.4" +vm = { path = "vm" } +wasm = { path = "wasm" } [dev-dependencies] native-contracts = { path = "native_contracts", features = ["test_contracts"] } diff --git a/ethcore/evm/Cargo.toml b/ethcore/evm/Cargo.toml index b48dd2346..f3bd208ec 100644 --- a/ethcore/evm/Cargo.toml +++ b/ethcore/evm/Cargo.toml @@ -13,6 +13,7 @@ ethjson = { path = "../../json" } lazy_static = "0.2" log = "0.3" rlp = { path = "../../util/rlp" } +vm = { path = "../vm" } parity-wasm = "0.12" wasm-utils = { git = "https://github.com/paritytech/wasm-utils" } diff --git a/ethcore/evm/src/benches/mod.rs b/ethcore/evm/src/benches/mod.rs index 4463696d6..ecb7d379a 100644 --- a/ethcore/evm/src/benches/mod.rs +++ b/ethcore/evm/src/benches/mod.rs @@ -25,7 +25,7 @@ extern crate test; use self::test::{Bencher, black_box}; use util::*; -use evm::action_params::ActionParams; +use vm::ActionParams; use evm::{self, Factory, VMType}; use evm::tests::FakeExt; diff --git a/ethcore/evm/src/evm.rs b/ethcore/evm/src/evm.rs index c27caf8b3..d593143a6 100644 --- a/ethcore/evm/src/evm.rs +++ b/ethcore/evm/src/evm.rs @@ -17,142 +17,8 @@ //! Evm interface. use std::{ops, cmp, fmt}; -use util::{U128, U256, U512, trie}; -use action_params::ActionParams; -use {Ext}; - -use super::wasm; - -/// Evm errors. -#[derive(Debug, Clone, PartialEq)] -pub enum Error { - /// `OutOfGas` is returned when transaction execution runs out of gas. - /// The state should be reverted to the state from before the - /// transaction execution. But it does not mean that transaction - /// was invalid. Balance still should be transfered and nonce - /// should be increased. - OutOfGas, - /// `BadJumpDestination` is returned when execution tried to move - /// to position that wasn't marked with JUMPDEST instruction - BadJumpDestination { - /// Position the code tried to jump to. - destination: usize - }, - /// `BadInstructions` is returned when given instruction is not supported - BadInstruction { - /// Unrecognized opcode - instruction: u8, - }, - /// `StackUnderflow` when there is not enough stack elements to execute instruction - StackUnderflow { - /// Invoked instruction - instruction: &'static str, - /// How many stack elements was requested by instruction - wanted: usize, - /// How many elements were on stack - on_stack: usize - }, - /// When execution would exceed defined Stack Limit - OutOfStack { - /// Invoked instruction - instruction: &'static str, - /// How many stack elements instruction wanted to push - wanted: usize, - /// What was the stack limit - limit: usize - }, - /// Built-in contract failed on given input - BuiltIn(&'static str), - /// When execution tries to modify the state in static context - MutableCallInStaticContext, - /// Likely to cause consensus issues. - Internal(String), - /// Wasm runtime error - Wasm(String), -} - -impl From> for Error { - fn from(err: Box) -> Self { - Error::Internal(format!("Internal error: {}", err)) - } -} - -impl From for Error { - fn from(err: wasm::RuntimeError) -> Self { - Error::Wasm(format!("Runtime error: {:?}", err)) - } -} - -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - use self::Error::*; - match *self { - OutOfGas => write!(f, "Out of gas"), - BadJumpDestination { destination } => write!(f, "Bad jump destination {:x}", destination), - BadInstruction { instruction } => write!(f, "Bad instruction {:x}", instruction), - StackUnderflow { instruction, wanted, on_stack } => write!(f, "Stack underflow {} {}/{}", instruction, wanted, on_stack), - OutOfStack { instruction, wanted, limit } => write!(f, "Out of stack {} {}/{}", instruction, wanted, limit), - BuiltIn(name) => write!(f, "Built-in failed: {}", name), - Internal(ref msg) => write!(f, "Internal error: {}", msg), - MutableCallInStaticContext => write!(f, "Mutable call in static context"), - Wasm(ref msg) => write!(f, "Internal error: {}", msg), - } - } -} - -/// A specialized version of Result over EVM errors. -pub type Result = ::std::result::Result; - -/// Return data buffer. Holds memory from a previous call and a slice into that memory. -#[derive(Debug)] -pub struct ReturnData { - mem: Vec, - offset: usize, - size: usize, -} - -impl ::std::ops::Deref for ReturnData { - type Target = [u8]; - fn deref(&self) -> &[u8] { - &self.mem[self.offset..self.offset + self.size] - } -} - -impl ReturnData { - /// Create empty `ReturnData`. - pub fn empty() -> Self { - ReturnData { - mem: Vec::new(), - offset: 0, - size: 0, - } - } - /// Create `ReturnData` from give buffer and slice. - pub fn new(mem: Vec, offset: usize, size: usize) -> Self { - ReturnData { - mem: mem, - offset: offset, - size: size, - } - } -} - -/// Gas Left: either it is a known value, or it needs to be computed by processing -/// a return instruction. -#[derive(Debug)] -pub enum GasLeft { - /// Known gas left - Known(U256), - /// Return or Revert instruction must be processed. - NeedsReturn { - /// Amount of gas left. - gas_left: U256, - /// Return data buffer. - data: ReturnData, - /// Apply or revert state changes on revert. - apply_state: bool - }, -} +use util::{U128, U256, U512}; +use vm::{Ext, Result, ReturnData, GasLeft, Error}; /// Finalization result. Gas Left: either it is a known value, or it needs to be computed by processing /// a return instruction. @@ -281,15 +147,6 @@ impl CostType for usize { } } -/// Evm interface -pub trait Evm { - /// This function should be used to execute transaction. - /// - /// It returns either an error, a known amount of gas left, or parameters to be used - /// to compute the final gas left. - fn exec(&mut self, params: ActionParams, ext: &mut Ext) -> Result; -} - #[cfg(test)] mod tests { use util::U256; diff --git a/ethcore/evm/src/factory.rs b/ethcore/evm/src/factory.rs index 2d8934ca1..20275dbff 100644 --- a/ethcore/evm/src/factory.rs +++ b/ethcore/evm/src/factory.rs @@ -17,7 +17,7 @@ //! Evm factory. //! use std::sync::Arc; -use evm::Evm; +use vm::Vm; use util::U256; use super::interpreter::SharedCache; use super::vmtype::VMType; @@ -33,7 +33,7 @@ impl Factory { /// Create fresh instance of VM /// Might choose implementation depending on supplied gas. #[cfg(feature = "jit")] - pub fn create(&self, gas: U256) -> Box { + pub fn create(&self, gas: U256) -> Box { match self.evm { VMType::Jit => { Box::new(super::jit::JitEvm::default()) @@ -49,7 +49,7 @@ impl Factory { /// Create fresh instance of VM /// Might choose implementation depending on supplied gas. #[cfg(not(feature = "jit"))] - pub fn create(&self, gas: U256) -> Box { + pub fn create(&self, gas: U256) -> Box { match self.evm { VMType::Interpreter => if Self::can_fit_in_usize(gas) { Box::new(super::interpreter::Interpreter::::new(self.evm_cache.clone())) diff --git a/ethcore/evm/src/interpreter/gasometer.rs b/ethcore/evm/src/interpreter/gasometer.rs index c2dcf5412..1533de837 100644 --- a/ethcore/evm/src/interpreter/gasometer.rs +++ b/ethcore/evm/src/interpreter/gasometer.rs @@ -17,15 +17,15 @@ use util::*; use super::u256_to_address; -use {evm, ext}; +use {evm, vm}; use instructions::{self, Instruction, InstructionInfo}; use interpreter::stack::Stack; -use schedule::Schedule; +use vm::Schedule; macro_rules! overflowing { ($x: expr) => {{ let (v, overflow) = $x; - if overflow { return Err(evm::Error::OutOfGas); } + if overflow { return Err(vm::Error::OutOfGas); } v }} } @@ -59,16 +59,16 @@ impl Gasometer { } } - pub fn verify_gas(&self, gas_cost: &Gas) -> evm::Result<()> { + pub fn verify_gas(&self, gas_cost: &Gas) -> vm::Result<()> { match &self.current_gas < gas_cost { - true => Err(evm::Error::OutOfGas), + true => Err(vm::Error::OutOfGas), false => Ok(()) } } /// How much gas is provided to a CALL/CREATE, given that we need to deduct `needed` for this operation /// and that we `requested` some. - pub fn gas_provided(&self, schedule: &Schedule, needed: Gas, requested: Option) -> evm::Result { + pub fn gas_provided(&self, schedule: &Schedule, needed: Gas, requested: Option) -> vm::Result { // Try converting requested gas to `Gas` (`U256/u64`) // but in EIP150 even if we request more we should never fail from OOG let requested = requested.map(Gas::from_u256); @@ -107,12 +107,12 @@ impl Gasometer { /// it will be the amount of gas that the current context provides to the child context. pub fn requirements( &mut self, - ext: &ext::Ext, + ext: &vm::Ext, instruction: Instruction, info: &InstructionInfo, stack: &Stack, current_mem_size: usize, - ) -> evm::Result> { + ) -> vm::Result> { let schedule = ext.schedule(); let tier = instructions::get_tier_idx(info.tier); let default_gas = Gas::from(schedule.tier_step_gas[tier]); @@ -291,7 +291,7 @@ impl Gasometer { }) } - fn mem_gas_cost(&self, schedule: &Schedule, current_mem_size: usize, mem_size: &Gas) -> evm::Result<(Gas, Gas, usize)> { + fn mem_gas_cost(&self, schedule: &Schedule, current_mem_size: usize, mem_size: &Gas) -> vm::Result<(Gas, Gas, usize)> { let gas_for_mem = |mem_size: Gas| { let s = mem_size >> 5; // s * memory_gas + s * s / quad_coeff_div @@ -319,12 +319,12 @@ impl Gasometer { #[inline] -fn mem_needed_const(mem: &U256, add: usize) -> evm::Result { +fn mem_needed_const(mem: &U256, add: usize) -> vm::Result { Gas::from_u256(overflowing!(mem.overflowing_add(U256::from(add)))) } #[inline] -fn mem_needed(offset: &U256, size: &U256) -> evm::Result { +fn mem_needed(offset: &U256, size: &U256) -> vm::Result { if size.is_zero() { return Ok(Gas::from(0)); } diff --git a/ethcore/evm/src/interpreter/memory.rs b/ethcore/evm/src/interpreter/memory.rs index 017b5777d..a13c99a82 100644 --- a/ethcore/evm/src/interpreter/memory.rs +++ b/ethcore/evm/src/interpreter/memory.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use util::U256; -use {ReturnData}; +use vm::ReturnData; const MAX_RETURN_WASTE_BYTES: usize = 16384; diff --git a/ethcore/evm/src/interpreter/mod.rs b/ethcore/evm/src/interpreter/mod.rs index 30b431912..3c39a89c1 100644 --- a/ethcore/evm/src/interpreter/mod.rs +++ b/ethcore/evm/src/interpreter/mod.rs @@ -23,17 +23,21 @@ mod stack; mod memory; mod shared_cache; +use std::marker::PhantomData; + +use vm::{ + self, ActionParams, ActionValue, CallType, MessageCallResult, + ContractCreateResult, CreateContractAddress, ReturnData, GasLeft +}; + +use evm::CostType; +use instructions::{self, Instruction, InstructionInfo}; + use self::gasometer::Gasometer; use self::stack::{Stack, VecStack}; use self::memory::Memory; pub use self::shared_cache::SharedCache; -use std::marker::PhantomData; -use action_params::{ActionParams, ActionValue}; -use call_type::CallType; -use instructions::{self, Instruction, InstructionInfo}; -use evm::{self, GasLeft, CostType, ReturnData}; -use ext::{self, MessageCallResult, ContractCreateResult, CreateContractAddress}; use bit_set::BitSet; use util::*; @@ -107,8 +111,8 @@ pub struct Interpreter { _type: PhantomData, } -impl evm::Evm for Interpreter { - fn exec(&mut self, params: ActionParams, ext: &mut ext::Ext) -> evm::Result { +impl vm::Vm for Interpreter { + fn exec(&mut self, params: ActionParams, ext: &mut vm::Ext) -> vm::Result { self.mem.clear(); let mut informant = informant::EvmInformant::new(ext.depth()); @@ -205,7 +209,7 @@ impl Interpreter { } } - fn verify_instruction(&self, ext: &ext::Ext, instruction: Instruction, info: &InstructionInfo, stack: &Stack) -> evm::Result<()> { + fn verify_instruction(&self, ext: &vm::Ext, instruction: Instruction, info: &InstructionInfo, stack: &Stack) -> vm::Result<()> { let schedule = ext.schedule(); if (instruction == instructions::DELEGATECALL && !schedule.have_delegate_call) || @@ -214,25 +218,25 @@ impl Interpreter { ((instruction == instructions::RETURNDATACOPY || instruction == instructions::RETURNDATASIZE) && !schedule.have_return_data) || (instruction == instructions::REVERT && !schedule.have_revert) { - return Err(evm::Error::BadInstruction { + return Err(vm::Error::BadInstruction { instruction: instruction }); } if info.tier == instructions::GasPriceTier::Invalid { - return Err(evm::Error::BadInstruction { + return Err(vm::Error::BadInstruction { instruction: instruction }); } if !stack.has(info.args) { - Err(evm::Error::StackUnderflow { + Err(vm::Error::StackUnderflow { instruction: info.name, wanted: info.args, on_stack: stack.size() }) } else if stack.size() - info.args + info.ret > schedule.stack_limit { - Err(evm::Error::OutOfStack { + Err(vm::Error::OutOfStack { instruction: info.name, wanted: info.ret - info.args, limit: schedule.stack_limit @@ -272,12 +276,12 @@ impl Interpreter { &mut self, gas: Cost, params: &ActionParams, - ext: &mut ext::Ext, + ext: &mut vm::Ext, instruction: Instruction, code: &mut CodeReader, stack: &mut Stack, provided: Option - ) -> evm::Result> { + ) -> vm::Result> { match instruction { instructions::JUMP => { let jump = stack.pop_back(); @@ -593,13 +597,13 @@ impl Interpreter { } } - fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &BitSet) -> evm::Result { + fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &BitSet) -> vm::Result { let jump = jump_u.low_u64() as usize; if valid_jump_destinations.contains(jump) && U256::from(jump) == jump_u { Ok(jump) } else { - Err(evm::Error::BadJumpDestination { + Err(vm::Error::BadJumpDestination { destination: jump }) } @@ -617,7 +621,7 @@ impl Interpreter { } } - fn exec_stack_instruction(&self, instruction: Instruction, stack: &mut Stack) -> evm::Result<()> { + fn exec_stack_instruction(&self, instruction: Instruction, stack: &mut Stack) -> vm::Result<()> { match instruction { instructions::DUP1...instructions::DUP16 => { let position = instructions::get_dup_position(instruction); @@ -822,7 +826,7 @@ impl Interpreter { } }, _ => { - return Err(evm::Error::BadInstruction { + return Err(vm::Error::BadInstruction { instruction: instruction }); } diff --git a/ethcore/evm/src/jit.rs b/ethcore/evm/src/jit.rs index f27e9b5d3..22262cbb6 100644 --- a/ethcore/evm/src/jit.rs +++ b/ethcore/evm/src/jit.rs @@ -19,6 +19,7 @@ use util::*; use evmjit; use evm::{self, GasLeft}; use evm::CallType; +use vm::{self, Vm}; /// Should be used to convert jit types to ethcore trait FromJit: Sized { @@ -318,7 +319,7 @@ pub struct JitEvm { context: Option, } -impl evm::Evm for JitEvm { +impl vm::Vm for JitEvm { fn exec(&mut self, params: ActionParams, ext: &mut evm::Ext) -> evm::Result { // Dirty hack. This is unsafe, but we interact with ffi, so it's justified. let ext_adapter: ExtAdapter<'static> = unsafe { ::std::mem::transmute(ExtAdapter::new(ext, params.address.clone())) }; @@ -370,8 +371,8 @@ impl evm::Evm for JitEvm { ext.suicide(&Address::from_jit(&context.suicide_refund_address())); Ok(GasLeft::Known(U256::from(context.gas_left()))) }, - evmjit::ReturnCode::OutOfGas => Err(evm::Error::OutOfGas), - _err => Err(evm::Error::Internal) + evmjit::ReturnCode::OutOfGas => Err(vm::Error::OutOfGas), + _err => Err(vm::Error::Internal) } } } diff --git a/ethcore/evm/src/lib.rs b/ethcore/evm/src/lib.rs index fa4d12315..aa4d87697 100644 --- a/ethcore/evm/src/lib.rs +++ b/ethcore/evm/src/lib.rs @@ -24,11 +24,11 @@ extern crate ethjson; extern crate rlp; extern crate parity_wasm; extern crate wasm_utils; +extern crate vm; #[macro_use] extern crate lazy_static; -#[macro_use] extern crate log; #[cfg(feature = "jit")] @@ -37,14 +37,8 @@ extern crate evmjit; #[cfg(test)] extern crate rustc_hex; -pub mod action_params; -pub mod call_type; -pub mod env_info; -pub mod ext; pub mod evm; pub mod interpreter; -pub mod schedule; -pub mod wasm; #[macro_use] pub mod factory; @@ -59,12 +53,12 @@ mod tests; #[cfg(all(feature="benches", test))] mod benches; -pub use self::action_params::ActionParams; -pub use self::call_type::CallType; -pub use self::env_info::EnvInfo; -pub use self::evm::{Evm, Error, Finalize, FinalizationResult, GasLeft, Result, CostType, ReturnData}; -pub use self::ext::{Ext, ContractCreateResult, MessageCallResult, CreateContractAddress}; +pub use vm::{ + Schedule, CleanDustMode, EnvInfo, CallType, ActionParams, Ext, + ContractCreateResult, MessageCallResult, CreateContractAddress, + GasLeft, ReturnData +}; +pub use self::evm::{Finalize, FinalizationResult, CostType}; pub use self::instructions::{InstructionInfo, INSTRUCTIONS, push_bytes}; pub use self::vmtype::VMType; pub use self::factory::Factory; -pub use self::schedule::{Schedule, CleanDustMode}; diff --git a/ethcore/evm/src/tests.rs b/ethcore/evm/src/tests.rs index d0502f79a..a80893ac3 100644 --- a/ethcore/evm/src/tests.rs +++ b/ethcore/evm/src/tests.rs @@ -17,12 +17,12 @@ use std::fmt::Debug; use rustc_hex::FromHex; use util::*; -use action_params::{ActionParams, ActionValue}; -use env_info::EnvInfo; -use call_type::CallType; -use schedule::Schedule; -use evm::{self, GasLeft, ReturnData}; -use ext::{Ext, ContractCreateResult, MessageCallResult, CreateContractAddress}; +use evm::{self, GasLeft}; +use vm::{ + self, CallType, Schedule, EnvInfo, ActionParams, ActionValue, + ReturnData, Ext, ContractCreateResult, MessageCallResult, + CreateContractAddress, +}; use factory::Factory; use vmtype::VMType; @@ -66,7 +66,7 @@ pub struct FakeExt { } // similar to the normal `finalize` function, but ignoring NeedsReturn. -fn test_finalize(res: Result) -> Result { +fn test_finalize(res: Result) -> Result { match res { Ok(GasLeft::Known(gas)) => Ok(gas), Ok(GasLeft::NeedsReturn{..}) => unimplemented!(), // since ret is unimplemented. @@ -80,35 +80,29 @@ impl FakeExt { } } -impl Default for Schedule { - fn default() -> Self { - Schedule::new_frontier() - } -} - impl Ext for FakeExt { - fn storage_at(&self, key: &H256) -> evm::Result { + fn storage_at(&self, key: &H256) -> vm::Result { Ok(self.store.get(key).unwrap_or(&H256::new()).clone()) } - fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()> { + fn set_storage(&mut self, key: H256, value: H256) -> vm::Result<()> { self.store.insert(key, value); Ok(()) } - fn exists(&self, address: &Address) -> evm::Result { + fn exists(&self, address: &Address) -> vm::Result { Ok(self.balances.contains_key(address)) } - fn exists_and_not_null(&self, address: &Address) -> evm::Result { + fn exists_and_not_null(&self, address: &Address) -> vm::Result { Ok(self.balances.get(address).map_or(false, |b| !b.is_zero())) } - fn origin_balance(&self) -> evm::Result { + fn origin_balance(&self) -> vm::Result { unimplemented!() } - fn balance(&self, address: &Address) -> evm::Result { + fn balance(&self, address: &Address) -> vm::Result { Ok(self.balances[address]) } @@ -152,15 +146,15 @@ impl Ext for FakeExt { MessageCallResult::Success(*gas, ReturnData::empty()) } - fn extcode(&self, address: &Address) -> evm::Result> { + fn extcode(&self, address: &Address) -> vm::Result> { Ok(self.codes.get(address).unwrap_or(&Arc::new(Bytes::new())).clone()) } - fn extcodesize(&self, address: &Address) -> evm::Result { + fn extcodesize(&self, address: &Address) -> vm::Result { Ok(self.codes.get(address).map_or(0, |c| c.len())) } - fn log(&mut self, topics: Vec, data: &[u8]) -> evm::Result<()> { + fn log(&mut self, topics: Vec, data: &[u8]) -> vm::Result<()> { self.logs.push(FakeLogEntry { topics: topics, data: data.to_vec() @@ -168,11 +162,11 @@ impl Ext for FakeExt { Ok(()) } - fn ret(self, _gas: &U256, _data: &ReturnData) -> evm::Result { + fn ret(self, _gas: &U256, _data: &ReturnData) -> vm::Result { unimplemented!(); } - fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> { + fn suicide(&mut self, refund_address: &Address) -> vm::Result<()> { self.suicides.insert(refund_address.clone()); Ok(()) } @@ -211,7 +205,7 @@ fn test_stack_underflow() { }; match err { - evm::Error::StackUnderflow {wanted, on_stack, ..} => { + vm::Error::StackUnderflow {wanted, on_stack, ..} => { assert_eq!(wanted, 2); assert_eq!(on_stack, 0); } @@ -849,7 +843,7 @@ fn test_badinstruction_int() { }; match err { - evm::Error::BadInstruction { instruction: 0xaf } => (), + vm::Error::BadInstruction { instruction: 0xaf } => (), _ => assert!(false, "Expected bad instruction") } } diff --git a/ethcore/light/Cargo.toml b/ethcore/light/Cargo.toml index 09f2e0e1a..b652050d2 100644 --- a/ethcore/light/Cargo.toml +++ b/ethcore/light/Cargo.toml @@ -19,6 +19,7 @@ ethcore-io = { path = "../../util/io" } ethcore-ipc = { path = "../../ipc/rpc", optional = true } ethcore-devtools = { path = "../../devtools" } evm = { path = "../evm" } +vm = { path = "../vm" } rlp = { path = "../../util/rlp" } time = "0.1" smallvec = "0.4" diff --git a/ethcore/light/src/lib.rs b/ethcore/light/src/lib.rs index 49928bd98..b172134cf 100644 --- a/ethcore/light/src/lib.rs +++ b/ethcore/light/src/lib.rs @@ -80,6 +80,7 @@ extern crate serde; extern crate smallvec; extern crate stats; extern crate time; +extern crate vm; #[cfg(feature = "ipc")] extern crate ethcore_ipc as ipc; diff --git a/ethcore/light/src/on_demand/request.rs b/ethcore/light/src/on_demand/request.rs index 9587dd8ed..6a2201349 100644 --- a/ethcore/light/src/on_demand/request.rs +++ b/ethcore/light/src/on_demand/request.rs @@ -24,7 +24,7 @@ use ethcore::engines::Engine; use ethcore::receipt::Receipt; use ethcore::state::{self, ProvedExecution}; use ethcore::transaction::SignedTransaction; -use evm::env_info::EnvInfo; +use vm::EnvInfo; use request::{self as net_request, IncompleteRequest, CompleteRequest, Output, OutputKind, Field}; diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs index 8cd1e22b6..64958700e 100644 --- a/ethcore/src/block.rs +++ b/ethcore/src/block.rs @@ -25,7 +25,7 @@ use util::{Bytes, Address, Hashable, U256, H256, ordered_trie_root, SHA3_NULL_RL use util::error::{Mismatch, OutOfBounds}; use basic_types::{LogBloom, Seal}; -use evm::env_info::{EnvInfo, LastHashes}; +use vm::{EnvInfo, LastHashes}; use engines::Engine; use error::{Error, BlockError, TransactionError}; use factory::Factories; @@ -667,7 +667,7 @@ mod tests { use tests::helpers::*; use super::*; use engines::Engine; - use evm::env_info::LastHashes; + use vm::LastHashes; use error::Error; use header::Header; use factory::Factories; diff --git a/ethcore/src/builtin.rs b/ethcore/src/builtin.rs index 7f71802b3..9e49e610c 100644 --- a/ethcore/src/builtin.rs +++ b/ethcore/src/builtin.rs @@ -36,9 +36,9 @@ impl From<&'static str> for Error { } } -impl Into<::evm::Error> for Error { - fn into(self) -> ::evm::Error { - ::evm::Error::BuiltIn(self.0) +impl Into<::vm::Error> for Error { + fn into(self) -> ::vm::Error { + ::vm::Error::BuiltIn(self.0) } } diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index 48cf481f1..94a5e09f3 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -42,9 +42,8 @@ use client::{ }; use encoded; use engines::{Engine, EpochTransition}; -use evm::env_info::EnvInfo; -use evm::env_info::LastHashes; use error::{ImportError, ExecutionError, CallError, BlockError, ImportResult, Error as EthcoreError}; +use vm::{EnvInfo, LastHashes}; use evm::{Factory as EvmFactory, Schedule}; use executive::{Executive, Executed, TransactOptions, contract_address}; use factory::Factories; diff --git a/ethcore/src/client/evm_test_client.rs b/ethcore/src/client/evm_test_client.rs index 5f23f449d..cd8501c31 100644 --- a/ethcore/src/client/evm_test_client.rs +++ b/ethcore/src/client/evm_test_client.rs @@ -23,7 +23,7 @@ use util::kvdb::{self, KeyValueDB}; use {state, state_db, client, executive, trace, db, spec}; use factory::Factories; use evm::{self, VMType}; -use evm::action_params::ActionParams; +use vm::{self, ActionParams}; /// EVM test Error. #[derive(Debug)] @@ -31,7 +31,7 @@ pub enum EvmTestError { /// Trie integrity error. Trie(util::TrieError), /// EVM error. - Evm(evm::Error), + Evm(vm::Error), /// Initialization error. Initialization(::error::Error), /// Low-level database error. diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs index b2d1ce991..f7c7417ad 100644 --- a/ethcore/src/client/mod.rs +++ b/ethcore/src/client/mod.rs @@ -40,7 +40,7 @@ pub use types::pruning_info::PruningInfo; pub use types::call_analytics::CallAnalytics; pub use executive::{Executed, Executive, TransactOptions}; -pub use evm::env_info::{LastHashes, EnvInfo}; +pub use vm::{LastHashes, EnvInfo}; pub use error::{BlockImportError, TransactionImportError, TransactionImportResult}; pub use verification::VerifierType; diff --git a/ethcore/src/client/test_client.rs b/ethcore/src/client/test_client.rs index 5dfdf5c25..a8c99efe2 100644 --- a/ethcore/src/client/test_client.rs +++ b/ethcore/src/client/test_client.rs @@ -36,7 +36,8 @@ use log_entry::LocalizedLogEntry; use receipt::{Receipt, LocalizedReceipt}; use blockchain::extras::BlockReceipts; use error::{ImportResult, Error as EthcoreError}; -use evm::{Factory as EvmFactory, VMType, Schedule}; +use evm::{Factory as EvmFactory, VMType}; +use vm::Schedule; use miner::{Miner, MinerService, TransactionImportResult}; use spec::Spec; use types::basic_account::BasicAccount; diff --git a/ethcore/src/client/traits.rs b/ethcore/src/client/traits.rs index aca369b21..e76da60bd 100644 --- a/ethcore/src/client/traits.rs +++ b/ethcore/src/client/traits.rs @@ -19,7 +19,7 @@ use std::collections::BTreeMap; use block::{OpenBlock, SealedBlock, ClosedBlock}; use blockchain::TreeRoute; use encoded; -use evm::env_info::LastHashes; +use vm::LastHashes; use error::{ImportResult, CallError, Error as EthcoreError}; use error::{TransactionImportResult, BlockImportError}; use evm::{Factory as EvmFactory, Schedule}; diff --git a/ethcore/src/engines/authority_round/mod.rs b/ethcore/src/engines/authority_round/mod.rs index ebe7cacea..97bbbcd26 100644 --- a/ethcore/src/engines/authority_round/mod.rs +++ b/ethcore/src/engines/authority_round/mod.rs @@ -514,7 +514,7 @@ impl Engine for AuthorityRound { fn on_new_block( &self, block: &mut ExecutedBlock, - last_hashes: Arc<::evm::env_info::LastHashes>, + last_hashes: Arc<::vm::LastHashes>, epoch_begin: bool, ) -> Result<(), Error> { let parent_hash = block.fields().header.parent_hash().clone(); diff --git a/ethcore/src/engines/mod.rs b/ethcore/src/engines/mod.rs index c5fa4818e..5e415cb7a 100644 --- a/ethcore/src/engines/mod.rs +++ b/ethcore/src/engines/mod.rs @@ -43,15 +43,13 @@ use account_provider::AccountProvider; use block::ExecutedBlock; use builtin::Builtin; use client::Client; -use evm::env_info::{EnvInfo, LastHashes}; +use vm::{EnvInfo, LastHashes, Schedule, CreateContractAddress}; use error::Error; -use evm::Schedule; use header::{Header, BlockNumber}; use receipt::Receipt; use snapshot::SnapshotComponents; use spec::CommonParams; use transaction::{UnverifiedTransaction, SignedTransaction}; -use evm::CreateContractAddress; use ethkey::Signature; use util::*; @@ -394,12 +392,10 @@ pub trait Engine : Sync + Send { /// Common engine utilities pub mod common { use block::ExecutedBlock; - use evm::env_info::{EnvInfo, LastHashes}; use error::Error; use transaction::SYSTEM_ADDRESS; use executive::Executive; - use evm::CallType; - use evm::action_params::{ActionParams, ActionValue}; + use vm::{CallType, ActionParams, ActionValue, EnvInfo, LastHashes}; use trace::{NoopTracer, NoopVMTracer}; use state::Substate; diff --git a/ethcore/src/engines/validator_set/safe_contract.rs b/ethcore/src/engines/validator_set/safe_contract.rs index 2c42323be..f90a3cf0c 100644 --- a/ethcore/src/engines/validator_set/safe_contract.rs +++ b/ethcore/src/engines/validator_set/safe_contract.rs @@ -299,7 +299,7 @@ impl ValidatorSet for ValidatorSafeContract { let (old_header, state_items) = decode_first_proof(&rlp)?; let old_hash = old_header.hash(); - let env_info = ::evm::env_info::EnvInfo { + let env_info = ::vm::EnvInfo { number: old_header.number(), author: *old_header.author(), difficulty: *old_header.difficulty(), diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs index ef6bb64cd..8429255f6 100644 --- a/ethcore/src/ethereum/ethash.rs +++ b/ethcore/src/ethereum/ethash.rs @@ -19,7 +19,7 @@ use ethash::{quick_get_difficulty, slow_get_seedhash, EthashManager}; use util::*; use block::*; use builtin::Builtin; -use evm::env_info::EnvInfo; +use vm::EnvInfo; use error::{BlockError, Error, TransactionError}; use header::{Header, BlockNumber}; use state::CleanupMode; @@ -29,7 +29,7 @@ use engines::{self, Engine}; use evm::Schedule; use ethjson; use rlp::{self, UntrustedRlp}; -use evm::env_info::LastHashes; +use vm::LastHashes; /// Parity tries to round block.gas_limit to multiple of this constant pub const PARITY_GAS_LIMIT_DETERMINANT: U256 = U256([37, 0, 0, 0]); diff --git a/ethcore/src/executed.rs b/ethcore/src/executed.rs index f6508668f..3154903ca 100644 --- a/ethcore/src/executed.rs +++ b/ethcore/src/executed.rs @@ -17,7 +17,7 @@ //! Transaction execution format module. use util::{Bytes, U256, Address, U512, trie}; -use evm; +use vm; use trace::{VMTrace, FlatTrace}; use log_entry::LogEntry; use state_diff::StateDiff; @@ -28,7 +28,7 @@ use std::fmt; #[derive(Debug, PartialEq, Clone)] pub struct Executed { /// True if the outer call/create resulted in an exceptional exit. - pub exception: Option, + pub exception: Option, /// Gas paid up front for execution of transaction. pub gas: U256, diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs index 9e25b6671..26e603700 100644 --- a/ethcore/src/executive.rs +++ b/ethcore/src/executive.rs @@ -16,13 +16,13 @@ //! Transaction Execution environment. use util::*; -use evm::action_params::{ActionParams, ActionValue}; use state::{Backend as StateBackend, State, Substate, CleanupMode}; use engines::Engine; -use evm::CallType; -use evm::env_info::EnvInfo; +use vm::EnvInfo; use error::ExecutionError; -use evm::{self, wasm, Factory, Ext, Finalize, CreateContractAddress, FinalizationResult, ReturnData, CleanDustMode}; +use evm::{CallType, Factory, Finalize, FinalizationResult}; +use vm::{self, Ext, CreateContractAddress, ReturnData, CleanDustMode, ActionParams, ActionValue}; +use wasm; use externalities::*; use trace::{FlatTrace, Tracer, NoopTracer, ExecutiveTracer, VMTrace, VMTracer, ExecutiveVMTracer, NoopVMTracer}; use transaction::{Action, SignedTransaction}; @@ -74,8 +74,8 @@ pub struct TransactOptions { pub check_nonce: bool, } -pub fn executor(engine: &E, vm_factory: &Factory, params: &ActionParams) - -> Box where E: Engine + ?Sized +pub fn executor(engine: &E, vm_factory: &Factory, params: &ActionParams) + -> Box where E: Engine + ?Sized { if engine.supports_wasm() && params.code.as_ref().map_or(false, |code| code.len() > 4 && &code[0..4] == WASM_MAGIC_NUMBER) { Box::new( @@ -269,7 +269,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { output_policy: OutputPolicy, tracer: &mut T, vm_tracer: &mut V - ) -> evm::Result where T: Tracer, V: VMTracer { + ) -> vm::Result where T: Tracer, V: VMTracer { let depth_threshold = ::io::LOCAL_STACK_SIZE.with(|sz| sz.get() / STACK_SIZE_PER_DEPTH); let static_call = params.call_type == CallType::StaticCall; @@ -299,7 +299,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { /// Calls contract function with given contract params. /// NOTE. It does not finalize the transaction (doesn't do refunds, nor suicides). /// Modifies the substate and the output. - /// Returns either gas_left or `evm::Error`. + /// Returns either gas_left or `vm::Error`. pub fn call( &mut self, params: ActionParams, @@ -307,14 +307,14 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { mut output: BytesRef, tracer: &mut T, vm_tracer: &mut V - ) -> evm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer { + ) -> vm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer { trace!("Executive::call(params={:?}) self.env_info={:?}", params, self.info); if (params.call_type == CallType::StaticCall || ((params.call_type == CallType::Call || params.call_type == CallType::DelegateCall) && self.static_flag)) && params.value.value() > 0.into() { - return Err(evm::Error::MutableCallInStaticContext); + return Err(vm::Error::MutableCallInStaticContext); } // backup used in case of running out of gas @@ -344,7 +344,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { if cost <= params.gas { if let Err(e) = builtin.execute(data, &mut output) { self.state.revert_to_checkpoint(); - let evm_err: evm::evm::Error = e.into(); + let evm_err: vm::Error = e.into(); tracer.trace_failed_call(trace_info, vec![], evm_err.clone().into()); Err(evm_err) } else { @@ -371,9 +371,9 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { // just drain the whole gas self.state.revert_to_checkpoint(); - tracer.trace_failed_call(trace_info, vec![], evm::Error::OutOfGas.into()); + tracer.trace_failed_call(trace_info, vec![], vm::Error::OutOfGas.into()); - Err(evm::Error::OutOfGas) + Err(vm::Error::OutOfGas) } } else { let trace_info = tracer.prepare_trace_call(¶ms); @@ -432,17 +432,17 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { substate: &mut Substate, tracer: &mut T, vm_tracer: &mut V, - ) -> evm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer { + ) -> vm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer { let scheme = self.engine.create_address_scheme(self.info.number); if scheme != CreateContractAddress::FromSenderAndNonce && self.state.exists_and_has_code(¶ms.address)? { - return Err(evm::Error::OutOfGas); + return Err(vm::Error::OutOfGas); } if params.call_type == CallType::StaticCall || self.static_flag { let trace_info = tracer.prepare_trace_create(¶ms); - tracer.trace_failed_create(trace_info, vec![], evm::Error::MutableCallInStaticContext.into()); - return Err(evm::Error::MutableCallInStaticContext); + tracer.trace_failed_create(trace_info, vec![], vm::Error::MutableCallInStaticContext.into()); + return Err(vm::Error::MutableCallInStaticContext); } // backup used in case of running out of gas @@ -496,7 +496,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { &mut self, t: &SignedTransaction, mut substate: Substate, - result: evm::Result<(U256, ReturnData)>, + result: vm::Result<(U256, ReturnData)>, output: Bytes, trace: Vec, vm_trace: Option @@ -538,7 +538,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { self.state.kill_garbage(&substate.touched, schedule.kill_empty, &min_balance, schedule.kill_dust == CleanDustMode::WithCodeAndStorage)?; match result { - Err(evm::Error::Internal(msg)) => Err(ExecutionError::Internal(msg)), + Err(vm::Error::Internal(msg)) => Err(ExecutionError::Internal(msg)), Err(exception) => { Ok(Executed { exception: Some(exception), @@ -572,20 +572,20 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> { } } - fn enact_result(&mut self, result: &evm::Result, substate: &mut Substate, un_substate: Substate) { + fn enact_result(&mut self, result: &vm::Result, substate: &mut Substate, un_substate: Substate) { match *result { - Err(evm::Error::OutOfGas) - | Err(evm::Error::BadJumpDestination {..}) - | Err(evm::Error::BadInstruction {.. }) - | Err(evm::Error::StackUnderflow {..}) - | Err(evm::Error::BuiltIn {..}) - | Err(evm::Error::Wasm {..}) - | Err(evm::Error::OutOfStack {..}) - | Err(evm::Error::MutableCallInStaticContext) + Err(vm::Error::OutOfGas) + | Err(vm::Error::BadJumpDestination {..}) + | Err(vm::Error::BadInstruction {.. }) + | Err(vm::Error::StackUnderflow {..}) + | Err(vm::Error::BuiltIn {..}) + | Err(vm::Error::Wasm {..}) + | Err(vm::Error::OutOfStack {..}) + | Err(vm::Error::MutableCallInStaticContext) | Ok(FinalizationResult { apply_state: false, .. }) => { self.state.revert_to_checkpoint(); }, - Ok(_) | Err(evm::Error::Internal(_)) => { + Ok(_) | Err(vm::Error::Internal(_)) => { self.state.discard_checkpoint(); substate.accrue(un_substate); } @@ -602,9 +602,8 @@ mod tests { use super::*; use util::{H256, U256, U512, Address, FromStr}; use util::bytes::BytesRef; - use evm::action_params::{ActionParams, ActionValue}; - use evm::env_info::EnvInfo; - use evm::{Factory, VMType, CreateContractAddress}; + use vm::{ActionParams, ActionValue, CallType, EnvInfo, CreateContractAddress}; + use evm::{Factory, VMType}; use error::ExecutionError; use state::{Substate, CleanupMode}; use tests::helpers::*; @@ -613,8 +612,6 @@ mod tests { use trace::{VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff, VMTracer, NoopVMTracer, ExecutiveVMTracer}; use transaction::{Action, Transaction}; - use evm::CallType; - #[test] fn test_contract_address() { let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap(); diff --git a/ethcore/src/externalities.rs b/ethcore/src/externalities.rs index 39c8673a9..b581acf74 100644 --- a/ethcore/src/externalities.rs +++ b/ethcore/src/externalities.rs @@ -16,13 +16,14 @@ //! Transaction Execution environment. use util::*; -use evm::action_params::{ActionParams, ActionValue}; use state::{Backend as StateBackend, State, Substate, CleanupMode}; use engines::Engine; -use evm::env_info::EnvInfo; use executive::*; -use evm::{self, Schedule, Ext, ContractCreateResult, MessageCallResult, CreateContractAddress, ReturnData}; -use evm::CallType; +use vm::{ + self, ActionParams, ActionValue, EnvInfo, CallType, Schedule, + Ext, ContractCreateResult, MessageCallResult, CreateContractAddress, + ReturnData +}; use transaction::UNSIGNED_SENDER; use trace::{Tracer, VMTracer}; @@ -109,31 +110,31 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Externalities<'a, T, V, B, E> impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E> where T: Tracer, V: VMTracer, B: StateBackend, E: Engine + ?Sized { - fn storage_at(&self, key: &H256) -> evm::Result { + fn storage_at(&self, key: &H256) -> vm::Result { self.state.storage_at(&self.origin_info.address, key).map_err(Into::into) } - fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()> { + fn set_storage(&mut self, key: H256, value: H256) -> vm::Result<()> { if self.static_flag { - Err(evm::Error::MutableCallInStaticContext) + Err(vm::Error::MutableCallInStaticContext) } else { self.state.set_storage(&self.origin_info.address, key, value).map_err(Into::into) } } - fn exists(&self, address: &Address) -> evm::Result { + fn exists(&self, address: &Address) -> vm::Result { self.state.exists(address).map_err(Into::into) } - fn exists_and_not_null(&self, address: &Address) -> evm::Result { + fn exists_and_not_null(&self, address: &Address) -> vm::Result { self.state.exists_and_not_null(address).map_err(Into::into) } - fn origin_balance(&self) -> evm::Result { + fn origin_balance(&self) -> vm::Result { self.balance(&self.origin_info.address).map_err(Into::into) } - fn balance(&self, address: &Address) -> evm::Result { + fn balance(&self, address: &Address) -> vm::Result { self.state.balance(address).map_err(Into::into) } @@ -274,16 +275,16 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E> } } - fn extcode(&self, address: &Address) -> evm::Result> { + fn extcode(&self, address: &Address) -> vm::Result> { Ok(self.state.code(address)?.unwrap_or_else(|| Arc::new(vec![]))) } - fn extcodesize(&self, address: &Address) -> evm::Result { + fn extcodesize(&self, address: &Address) -> vm::Result { Ok(self.state.code_size(address)?.unwrap_or(0)) } #[cfg_attr(feature="dev", allow(match_ref_pats))] - fn ret(mut self, gas: &U256, data: &ReturnData) -> evm::Result + fn ret(mut self, gas: &U256, data: &ReturnData) -> vm::Result where Self: Sized { let handle_copy = |to: &mut Option<&mut Bytes>| { to.as_mut().map(|b| **b = data.to_vec()); @@ -307,7 +308,7 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E> let return_cost = U256::from(data.len()) * U256::from(self.schedule.create_data_gas); if return_cost > *gas || data.len() > self.schedule.create_data_limit { return match self.schedule.exceptional_failed_code_deposit { - true => Err(evm::Error::OutOfGas), + true => Err(vm::Error::OutOfGas), false => Ok(*gas) } } @@ -320,11 +321,11 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E> } } - fn log(&mut self, topics: Vec, data: &[u8]) -> evm::Result<()> { + fn log(&mut self, topics: Vec, data: &[u8]) -> vm::Result<()> { use log_entry::LogEntry; if self.static_flag { - return Err(evm::Error::MutableCallInStaticContext); + return Err(vm::Error::MutableCallInStaticContext); } let address = self.origin_info.address.clone(); @@ -337,9 +338,9 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E> Ok(()) } - fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> { + fn suicide(&mut self, refund_address: &Address) -> vm::Result<()> { if self.static_flag { - return Err(evm::Error::MutableCallInStaticContext); + return Err(vm::Error::MutableCallInStaticContext); } let address = self.origin_info.address.clone(); @@ -396,13 +397,11 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E> mod tests { use util::*; use engines::Engine; - use evm::env_info::EnvInfo; - use evm::Ext; + use evm::{EnvInfo, Ext, CallType}; use state::{State, Substate}; use tests::helpers::*; use super::*; use trace::{NoopTracer, NoopVMTracer}; - use evm::CallType; fn get_test_origin() -> OriginInfo { OriginInfo { diff --git a/ethcore/src/json_tests/executive.rs b/ethcore/src/json_tests/executive.rs index 0c5a6a90d..7ec84fbd6 100644 --- a/ethcore/src/json_tests/executive.rs +++ b/ethcore/src/json_tests/executive.rs @@ -15,15 +15,16 @@ // along with Parity. If not, see . use super::test_common::*; -use evm::action_params::ActionParams; use state::{Backend as StateBackend, State, Substate}; use executive::*; use engines::Engine; -use evm::env_info::EnvInfo; -use evm; -use evm::{Schedule, Ext, Finalize, VMType, ContractCreateResult, MessageCallResult, CreateContractAddress, ReturnData}; +use evm::{VMType, Finalize}; +use vm::{ + self, ActionParams, CallType, Schedule, Ext, + ContractCreateResult, EnvInfo, MessageCallResult, + CreateContractAddress, ReturnData, +}; use externalities::*; -use evm::CallType; use tests::helpers::*; use ethjson; use trace::{Tracer, NoopTracer}; @@ -88,27 +89,27 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> TestExt<'a, T, V, B, E> impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for TestExt<'a, T, V, B, E> where T: Tracer, V: VMTracer, B: StateBackend, E: Engine + ?Sized { - fn storage_at(&self, key: &H256) -> evm::Result { + fn storage_at(&self, key: &H256) -> vm::Result { self.ext.storage_at(key) } - fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()> { + fn set_storage(&mut self, key: H256, value: H256) -> vm::Result<()> { self.ext.set_storage(key, value) } - fn exists(&self, address: &Address) -> evm::Result { + fn exists(&self, address: &Address) -> vm::Result { self.ext.exists(address) } - fn exists_and_not_null(&self, address: &Address) -> evm::Result { + fn exists_and_not_null(&self, address: &Address) -> vm::Result { self.ext.exists_and_not_null(address) } - fn balance(&self, address: &Address) -> evm::Result { + fn balance(&self, address: &Address) -> vm::Result { self.ext.balance(address) } - fn origin_balance(&self) -> evm::Result { + fn origin_balance(&self) -> vm::Result { self.ext.origin_balance() } @@ -146,23 +147,23 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for TestExt<'a, T, V, B, E> MessageCallResult::Success(*gas, ReturnData::empty()) } - fn extcode(&self, address: &Address) -> evm::Result> { + fn extcode(&self, address: &Address) -> vm::Result> { self.ext.extcode(address) } - fn extcodesize(&self, address: &Address) -> evm::Result { + fn extcodesize(&self, address: &Address) -> vm::Result { self.ext.extcodesize(address) } - fn log(&mut self, topics: Vec, data: &[u8]) -> evm::Result<()> { + fn log(&mut self, topics: Vec, data: &[u8]) -> vm::Result<()> { self.ext.log(topics, data) } - fn ret(self, gas: &U256, data: &ReturnData) -> Result { + fn ret(self, gas: &U256, data: &ReturnData) -> Result { self.ext.ret(gas, data) } - fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> { + fn suicide(&mut self, refund_address: &Address) -> vm::Result<()> { self.ext.suicide(refund_address) } diff --git a/ethcore/src/json_tests/state.rs b/ethcore/src/json_tests/state.rs index 74bbfb266..2fdf8875f 100644 --- a/ethcore/src/json_tests/state.rs +++ b/ethcore/src/json_tests/state.rs @@ -22,7 +22,7 @@ use spec::Spec; use ethjson; use ethjson::state::test::ForkSpec; use transaction::SignedTransaction; -use evm::env_info::EnvInfo; +use vm::EnvInfo; lazy_static! { pub static ref FRONTIER: Spec = ethereum::new_frontier_test(); diff --git a/ethcore/src/lib.rs b/ethcore/src/lib.rs index 89f9d2e57..fe8696b56 100644 --- a/ethcore/src/lib.rs +++ b/ethcore/src/lib.rs @@ -106,6 +106,8 @@ extern crate semver; extern crate stats; extern crate time; extern crate transient_hashmap; +extern crate vm; +extern crate wasm; #[macro_use] extern crate log; diff --git a/ethcore/src/spec/spec.rs b/ethcore/src/spec/spec.rs index 959793e4c..384230341 100644 --- a/ethcore/src/spec/spec.rs +++ b/ethcore/src/spec/spec.rs @@ -20,10 +20,9 @@ use rustc_hex::FromHex; use super::genesis::Genesis; use super::seal::Generic as GenericSeal; -use evm::action_params::{ActionValue, ActionParams}; use builtin::Builtin; use engines::{Engine, NullEngine, InstantSeal, BasicAuthority, AuthorityRound, Tendermint, DEFAULT_BLOCKHASH_CONTRACT}; -use evm::env_info::EnvInfo; +use vm::{EnvInfo, CallType, ActionValue, ActionParams}; use error::Error; use ethereum; use ethjson; @@ -36,7 +35,6 @@ use state_db::StateDB; use state::{Backend, State, Substate}; use state::backend::Basic as BasicBackend; use trace::{NoopTracer, NoopVMTracer}; -use evm::CallType; use util::*; /// Parameters common to ethereum-like blockchains. @@ -102,14 +100,14 @@ pub struct CommonParams { impl CommonParams { /// Schedule for an EVM in the post-EIP-150-era of the Ethereum main net. - pub fn schedule(&self, block_number: u64) -> ::evm::Schedule { - let mut schedule = ::evm::Schedule::new_post_eip150(usize::max_value(), true, true, true); + pub fn schedule(&self, block_number: u64) -> ::vm::Schedule { + let mut schedule = ::vm::Schedule::new_post_eip150(usize::max_value(), true, true, true); self.update_schedule(block_number, &mut schedule); schedule } /// Apply common spec config parameters to the schedule. - pub fn update_schedule(&self, block_number: u64, schedule: &mut ::evm::Schedule) { + pub fn update_schedule(&self, block_number: u64, schedule: &mut ::vm::Schedule) { schedule.have_create2 = block_number >= self.eip86_transition; schedule.have_revert = block_number >= self.eip140_transition; schedule.have_static_call = block_number >= self.eip214_transition; @@ -119,8 +117,8 @@ impl CommonParams { } if block_number >= self.dust_protection_transition { schedule.kill_dust = match self.remove_dust_contracts { - true => ::evm::CleanDustMode::WithCodeAndStorage, - false => ::evm::CleanDustMode::BasicOnly, + true => ::vm::CleanDustMode::WithCodeAndStorage, + false => ::vm::CleanDustMode::BasicOnly, }; } } diff --git a/ethcore/src/state/mod.rs b/ethcore/src/state/mod.rs index 354da2cc3..593ec86a6 100644 --- a/ethcore/src/state/mod.rs +++ b/ethcore/src/state/mod.rs @@ -24,7 +24,7 @@ use std::collections::hash_map::Entry; use receipt::Receipt; use engines::Engine; -use evm::env_info::EnvInfo; +use vm::EnvInfo; use error::Error; use executive::{Executive, TransactOptions}; use factory::Factories; @@ -982,7 +982,7 @@ mod tests { use ethkey::Secret; use util::{U256, H256, Address, Hashable}; use tests::helpers::*; - use evm::env_info::EnvInfo; + use vm::EnvInfo; use spec::*; use transaction::*; use ethcore_logger::init_log; diff --git a/ethcore/src/tests/evm.rs b/ethcore/src/tests/evm.rs index c97fd4ac0..c7208b995 100644 --- a/ethcore/src/tests/evm.rs +++ b/ethcore/src/tests/evm.rs @@ -1,9 +1,7 @@ //! Tests of EVM integration with transaction execution. -use evm::action_params::{ActionParams, ActionValue}; -use evm::env_info::EnvInfo; +use vm::{EnvInfo, ActionParams, ActionValue, CallType}; use evm::{Factory, VMType}; -use evm::call_type::CallType; use executive::Executive; use state::Substate; use tests::helpers::*; diff --git a/ethcore/src/trace/executive_tracer.rs b/ethcore/src/trace/executive_tracer.rs index cdfe1e004..860c74223 100644 --- a/ethcore/src/trace/executive_tracer.rs +++ b/ethcore/src/trace/executive_tracer.rs @@ -17,7 +17,7 @@ //! Simple executive tracer. use util::{Bytes, Address, U256}; -use evm::action_params::ActionParams; +use vm::ActionParams; use trace::trace::{Call, Create, Action, Res, CreateResult, CallResult, VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff, Suicide}; use trace::{Tracer, VMTracer, FlatTrace, TraceError}; diff --git a/ethcore/src/trace/mod.rs b/ethcore/src/trace/mod.rs index 39af8a08a..be830430b 100644 --- a/ethcore/src/trace/mod.rs +++ b/ethcore/src/trace/mod.rs @@ -39,7 +39,7 @@ pub use self::types::filter::{Filter, AddressesFilter}; use util::{Bytes, Address, U256, H256, DBTransaction}; use self::trace::{Call, Create}; -use evm::action_params::ActionParams; +use vm::ActionParams; use header::BlockNumber; /// This trait is used by executive to build traces. diff --git a/ethcore/src/trace/noop_tracer.rs b/ethcore/src/trace/noop_tracer.rs index 5fb8a7c55..2c0e1b830 100644 --- a/ethcore/src/trace/noop_tracer.rs +++ b/ethcore/src/trace/noop_tracer.rs @@ -17,7 +17,7 @@ //! Nonoperative tracer. use util::{Bytes, Address, U256}; -use evm::action_params::ActionParams; +use vm::ActionParams; use trace::{Tracer, VMTracer, FlatTrace, TraceError}; use trace::trace::{Call, Create, VMTrace}; diff --git a/ethcore/src/trace/types/error.rs b/ethcore/src/trace/types/error.rs index 4242bfad4..5cedefd09 100644 --- a/ethcore/src/trace/types/error.rs +++ b/ethcore/src/trace/types/error.rs @@ -18,7 +18,7 @@ use std::fmt; use rlp::{Encodable, RlpStream, Decodable, DecoderError, UntrustedRlp}; -use evm::Error as EvmError; +use vm::Error as VmError; /// Trace evm errors. #[derive(Debug, PartialEq, Clone)] @@ -45,24 +45,24 @@ pub enum Error { Wasm, } -impl<'a> From<&'a EvmError> for Error { - fn from(e: &'a EvmError) -> Self { +impl<'a> From<&'a VmError> for Error { + fn from(e: &'a VmError) -> Self { match *e { - EvmError::OutOfGas => Error::OutOfGas, - EvmError::BadJumpDestination { .. } => Error::BadJumpDestination, - EvmError::BadInstruction { .. } => Error::BadInstruction, - EvmError::StackUnderflow { .. } => Error::StackUnderflow, - EvmError::OutOfStack { .. } => Error::OutOfStack, - EvmError::BuiltIn { .. } => Error::BuiltIn, - EvmError::Wasm { .. } => Error::Wasm, - EvmError::Internal(_) => Error::Internal, - EvmError::MutableCallInStaticContext => Error::MutableCallInStaticContext, + VmError::OutOfGas => Error::OutOfGas, + VmError::BadJumpDestination { .. } => Error::BadJumpDestination, + VmError::BadInstruction { .. } => Error::BadInstruction, + VmError::StackUnderflow { .. } => Error::StackUnderflow, + VmError::OutOfStack { .. } => Error::OutOfStack, + VmError::BuiltIn { .. } => Error::BuiltIn, + VmError::Wasm { .. } => Error::Wasm, + VmError::Internal(_) => Error::Internal, + VmError::MutableCallInStaticContext => Error::MutableCallInStaticContext, } } } -impl From for Error { - fn from(e: EvmError) -> Self { +impl From for Error { + fn from(e: VmError) -> Self { Error::from(&e) } } diff --git a/ethcore/src/trace/types/trace.rs b/ethcore/src/trace/types/trace.rs index 24250935f..17c498676 100644 --- a/ethcore/src/trace/types/trace.rs +++ b/ethcore/src/trace/types/trace.rs @@ -21,7 +21,7 @@ use util::sha3::Hashable; use util::bloom::Bloomable; use rlp::*; -use evm::action_params::ActionParams; +use vm::ActionParams; use basic_types::LogBloom; use evm::CallType; use super::error::Error; diff --git a/ethcore/vm/Cargo.toml b/ethcore/vm/Cargo.toml new file mode 100644 index 000000000..50efe936c --- /dev/null +++ b/ethcore/vm/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "vm" +version = "0.1.0" +authors = ["Parity Technologies "] + +[dependencies] +byteorder = "1.0" +ethcore-util = { path = "../../util" } +log = "0.3" +common-types = { path = "../types" } +evmjit = { path = "../../evmjit", optional = true } +ethjson = { path = "../../json" } +lazy_static = "0.2" +rlp = { path = "../../util/rlp" } \ No newline at end of file diff --git a/ethcore/evm/src/action_params.rs b/ethcore/vm/src/action_params.rs similarity index 98% rename from ethcore/evm/src/action_params.rs rename to ethcore/vm/src/action_params.rs index 62bb7fa5b..401d7ee57 100644 --- a/ethcore/evm/src/action_params.rs +++ b/ethcore/vm/src/action_params.rs @@ -20,7 +20,7 @@ use util::hash::{H256}; use util::sha3::{Hashable, SHA3_EMPTY}; use ethjson; -use {CallType}; +use call_type::CallType; use std::sync::Arc; @@ -48,7 +48,7 @@ impl ActionValue { /// Returns the apparent action value of the U256-convertable raw value pub fn apparent>(apparent_value: T) -> ActionValue { - ActionValue::Apparent(apparent_value.into()) + ActionValue::Apparent(apparent_value.into()) } } diff --git a/ethcore/evm/src/call_type.rs b/ethcore/vm/src/call_type.rs similarity index 100% rename from ethcore/evm/src/call_type.rs rename to ethcore/vm/src/call_type.rs diff --git a/ethcore/evm/src/env_info.rs b/ethcore/vm/src/env_info.rs similarity index 100% rename from ethcore/evm/src/env_info.rs rename to ethcore/vm/src/env_info.rs diff --git a/ethcore/vm/src/error.rs b/ethcore/vm/src/error.rs new file mode 100644 index 000000000..e4b199438 --- /dev/null +++ b/ethcore/vm/src/error.rs @@ -0,0 +1,100 @@ +// Copyright 2015-2017 Parity Technologies (UK) Ltd. +// This file is part of Parity. + +// Parity 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. + +// Parity 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 Parity. If not, see . + +//! VM errors module + +use util::trie; +use std::fmt; + +/// VM errors. +#[derive(Debug, Clone, PartialEq)] +pub enum Error { + /// `OutOfGas` is returned when transaction execution runs out of gas. + /// The state should be reverted to the state from before the + /// transaction execution. But it does not mean that transaction + /// was invalid. Balance still should be transfered and nonce + /// should be increased. + OutOfGas, + /// `BadJumpDestination` is returned when execution tried to move + /// to position that wasn't marked with JUMPDEST instruction + BadJumpDestination { + /// Position the code tried to jump to. + destination: usize + }, + /// `BadInstructions` is returned when given instruction is not supported + BadInstruction { + /// Unrecognized opcode + instruction: u8, + }, + /// `StackUnderflow` when there is not enough stack elements to execute instruction + StackUnderflow { + /// Invoked instruction + instruction: &'static str, + /// How many stack elements was requested by instruction + wanted: usize, + /// How many elements were on stack + on_stack: usize + }, + /// When execution would exceed defined Stack Limit + OutOfStack { + /// Invoked instruction + instruction: &'static str, + /// How many stack elements instruction wanted to push + wanted: usize, + /// What was the stack limit + limit: usize + }, + /// Built-in contract failed on given input + BuiltIn(&'static str), + /// When execution tries to modify the state in static context + MutableCallInStaticContext, + /// Likely to cause consensus issues. + Internal(String), + /// Wasm runtime error + Wasm(String), +} + + +impl From> for Error { + fn from(err: Box) -> Self { + Error::Internal(format!("Internal error: {}", err)) + } +} + +// impl From for Error { +// fn from(err: wasm::RuntimeError) -> Self { +// Error::Wasm(format!("Runtime error: {:?}", err)) +// } +// } + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + use self::Error::*; + match *self { + OutOfGas => write!(f, "Out of gas"), + BadJumpDestination { destination } => write!(f, "Bad jump destination {:x}", destination), + BadInstruction { instruction } => write!(f, "Bad instruction {:x}", instruction), + StackUnderflow { instruction, wanted, on_stack } => write!(f, "Stack underflow {} {}/{}", instruction, wanted, on_stack), + OutOfStack { instruction, wanted, limit } => write!(f, "Out of stack {} {}/{}", instruction, wanted, limit), + BuiltIn(name) => write!(f, "Built-in failed: {}", name), + Internal(ref msg) => write!(f, "Internal error: {}", msg), + MutableCallInStaticContext => write!(f, "Mutable call in static context"), + Wasm(ref msg) => write!(f, "Internal error: {}", msg), + } + } +} + +pub type Result = ::std::result::Result; diff --git a/ethcore/evm/src/ext.rs b/ethcore/vm/src/ext.rs similarity index 85% rename from ethcore/evm/src/ext.rs rename to ethcore/vm/src/ext.rs index 1c3ddb317..e6ce3fbe3 100644 --- a/ethcore/evm/src/ext.rs +++ b/ethcore/vm/src/ext.rs @@ -20,7 +20,8 @@ use util::*; use call_type::CallType; use env_info::EnvInfo; use schedule::Schedule; -use evm::{self, ReturnData}; +use return_data::ReturnData; +use error::Result; /// Result of externalities create function. pub enum ContractCreateResult { @@ -56,22 +57,22 @@ pub enum CreateContractAddress { /// Externalities interface for EVMs pub trait Ext { /// Returns a value for given key. - fn storage_at(&self, key: &H256) -> evm::Result; + fn storage_at(&self, key: &H256) -> Result; /// Stores a value for given key. - fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()>; + fn set_storage(&mut self, key: H256, value: H256) -> Result<()>; /// Determine whether an account exists. - fn exists(&self, address: &Address) -> evm::Result; + fn exists(&self, address: &Address) -> Result; /// Determine whether an account exists and is not null (zero balance/nonce, no code). - fn exists_and_not_null(&self, address: &Address) -> evm::Result; + fn exists_and_not_null(&self, address: &Address) -> Result; /// Balance of the origin account. - fn origin_balance(&self) -> evm::Result; + fn origin_balance(&self) -> Result; /// Returns address balance. - fn balance(&self, address: &Address) -> evm::Result; + fn balance(&self, address: &Address) -> Result; /// Returns the hash of one of the 256 most recent complete blocks. fn blockhash(&mut self, number: &U256) -> H256; @@ -99,21 +100,21 @@ pub trait Ext { ) -> MessageCallResult; /// Returns code at given address - fn extcode(&self, address: &Address) -> evm::Result>; + fn extcode(&self, address: &Address) -> Result>; /// Returns code size at given address - fn extcodesize(&self, address: &Address) -> evm::Result; + fn extcodesize(&self, address: &Address) -> Result; /// Creates log entry with given topics and data - fn log(&mut self, topics: Vec, data: &[u8]) -> evm::Result<()>; + fn log(&mut self, topics: Vec, data: &[u8]) -> Result<()>; /// Should be called when transaction calls `RETURN` opcode. /// Returns gas_left if cost of returning the data is not too high. - fn ret(self, gas: &U256, data: &ReturnData) -> evm::Result; + fn ret(self, gas: &U256, data: &ReturnData) -> Result; /// Should be called when contract commits suicide. /// Address to which funds should be refunded. - fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> ; + fn suicide(&mut self, refund_address: &Address) -> Result<()> ; /// Returns schedule. fn schedule(&self) -> &Schedule; diff --git a/ethcore/vm/src/lib.rs b/ethcore/vm/src/lib.rs new file mode 100644 index 000000000..2bf669951 --- /dev/null +++ b/ethcore/vm/src/lib.rs @@ -0,0 +1,46 @@ +// Copyright 2015-2017 Parity Technologies (UK) Ltd. +// This file is part of Parity. + +// Parity 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. + +// Parity 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 Parity. If not, see . + +//! Virtual machines support library + +extern crate ethcore_util as util; +extern crate common_types as types; +extern crate ethjson; +extern crate rlp; + +mod action_params; +mod call_type; +mod env_info; +mod schedule; +mod ext; +mod return_data; +mod error; + +pub use action_params::{ActionParams, ActionValue}; +pub use call_type::CallType; +pub use env_info::{EnvInfo, LastHashes}; +pub use schedule::{Schedule, CleanDustMode}; +pub use ext::{Ext, MessageCallResult, ContractCreateResult, CreateContractAddress}; +pub use return_data::{ReturnData, GasLeft}; +pub use error::{Error, Result}; + +/// Virtual Machine interface +pub trait Vm { + /// This function should be used to execute transaction. + /// It returns either an error, a known amount of gas left, or parameters to be used + /// to compute the final gas left. + fn exec(&mut self, params: ActionParams, ext: &mut Ext) -> Result; +} \ No newline at end of file diff --git a/ethcore/vm/src/return_data.rs b/ethcore/vm/src/return_data.rs new file mode 100644 index 000000000..3c8bd182f --- /dev/null +++ b/ethcore/vm/src/return_data.rs @@ -0,0 +1,68 @@ + +// Parity 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. + +// Parity 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 Parity. If not, see . + +//! Return data structures + +use util::U256; + +/// Return data buffer. Holds memory from a previous call and a slice into that memory. +#[derive(Debug)] +pub struct ReturnData { + mem: Vec, + offset: usize, + size: usize, +} + +impl ::std::ops::Deref for ReturnData { + type Target = [u8]; + fn deref(&self) -> &[u8] { + &self.mem[self.offset..self.offset + self.size] + } +} + +impl ReturnData { + /// Create empty `ReturnData`. + pub fn empty() -> Self { + ReturnData { + mem: Vec::new(), + offset: 0, + size: 0, + } + } + /// Create `ReturnData` from give buffer and slice. + pub fn new(mem: Vec, offset: usize, size: usize) -> Self { + ReturnData { + mem: mem, + offset: offset, + size: size, + } + } +} + +/// Gas Left: either it is a known value, or it needs to be computed by processing +/// a return instruction. +#[derive(Debug)] +pub enum GasLeft { + /// Known gas left + Known(U256), + /// Return or Revert instruction must be processed. + NeedsReturn { + /// Amount of gas left. + gas_left: U256, + /// Return data buffer. + data: ReturnData, + /// Apply or revert state changes on revert. + apply_state: bool + }, +} \ No newline at end of file diff --git a/ethcore/evm/src/schedule.rs b/ethcore/vm/src/schedule.rs similarity index 98% rename from ethcore/evm/src/schedule.rs rename to ethcore/vm/src/schedule.rs index e721dc803..6966c26e6 100644 --- a/ethcore/evm/src/schedule.rs +++ b/ethcore/vm/src/schedule.rs @@ -250,6 +250,12 @@ impl Schedule { } } +impl Default for Schedule { + fn default() -> Self { + Schedule::new_frontier() + } +} + #[test] #[cfg(test)] fn schedule_evm_assumptions() { @@ -260,3 +266,4 @@ fn schedule_evm_assumptions() { assert_eq!(s1.quad_coeff_div, 512); assert_eq!(s2.quad_coeff_div, 512); } + diff --git a/ethcore/wasm/Cargo.toml b/ethcore/wasm/Cargo.toml new file mode 100644 index 000000000..bda35e3ef --- /dev/null +++ b/ethcore/wasm/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "wasm" +version = "0.1.0" +authors = ["Parity Technologies "] + +[dependencies] +byteorder = "1.0" +ethcore-util = { path = "../../util" } +log = "0.3" +parity-wasm = "0.12" +wasm-utils = { git = "https://github.com/paritytech/wasm-utils" } +vm = { path = "../vm" } \ No newline at end of file diff --git a/ethcore/evm/src/wasm/call_args.rs b/ethcore/wasm/src/call_args.rs similarity index 100% rename from ethcore/evm/src/wasm/call_args.rs rename to ethcore/wasm/src/call_args.rs diff --git a/ethcore/evm/src/wasm/env.rs b/ethcore/wasm/src/env.rs similarity index 100% rename from ethcore/evm/src/wasm/env.rs rename to ethcore/wasm/src/env.rs diff --git a/ethcore/evm/src/wasm/mod.rs b/ethcore/wasm/src/lib.rs similarity index 83% rename from ethcore/evm/src/wasm/mod.rs rename to ethcore/wasm/src/lib.rs index a7186add5..9ca3869ef 100644 --- a/ethcore/evm/src/wasm/mod.rs +++ b/ethcore/wasm/src/lib.rs @@ -16,6 +16,13 @@ //! Wasm Interpreter +extern crate vm; +extern crate ethcore_util as util; +#[macro_use] extern crate log; +extern crate byteorder; +extern crate parity_wasm; +extern crate wasm_utils; + mod runtime; mod ptr; mod call_args; @@ -30,10 +37,8 @@ const DEFAULT_STACK_SPACE: u32 = 5 * 1024 * 1024; use parity_wasm::{interpreter, elements}; use parity_wasm::interpreter::ModuleInstanceInterface; -use wasm_utils; -use evm::{self, GasLeft, ReturnData}; -use action_params::ActionParams; +use vm::{GasLeft, ReturnData, ActionParams}; use self::runtime::Runtime; pub use self::runtime::Error as RuntimeError; @@ -56,9 +61,9 @@ impl WasmInterpreter { } } -impl evm::Evm for WasmInterpreter { +impl vm::Vm for WasmInterpreter { - fn exec(&mut self, params: ActionParams, ext: &mut ::ext::Ext) -> evm::Result { + fn exec(&mut self, params: ActionParams, ext: &mut vm::Ext) -> vm::Result { use parity_wasm::elements::Deserialize; let code = params.code.expect("exec is only called on contract with code; qed"); @@ -74,7 +79,7 @@ impl evm::Evm for WasmInterpreter { .expect("Linear memory to exist in wasm runtime"); if params.gas > ::std::u64::MAX.into() { - return Err(evm::Error::Wasm("Wasm interpreter cannot run contracts with gas >= 2^64".to_owned())); + return Err(vm::Error::Wasm("Wasm interpreter cannot run contracts with gas >= 2^64".to_owned())); } let mut runtime = Runtime::with_params( @@ -90,7 +95,7 @@ impl evm::Evm for WasmInterpreter { elements::Module::deserialize( &mut cursor ).map_err(|err| { - evm::Error::Wasm(format!("Error deserializing contract code ({:?})", err)) + vm::Error::Wasm(format!("Error deserializing contract code ({:?})", err)) })? ); @@ -111,7 +116,7 @@ impl evm::Evm for WasmInterpreter { interpreter::env_native_module(env_instance, native_bindings(&mut runtime)) .map_err(|err| { // todo: prefer explicit panic here also? - evm::Error::Wasm(format!("Error instantiating native bindings: {:?}", err)) + vm::Error::Wasm(format!("Error instantiating native bindings: {:?}", err)) })? ) ).add_argument(interpreter::RuntimeValue::I32(d_ptr.as_raw() as i32)); @@ -119,13 +124,13 @@ impl evm::Evm for WasmInterpreter { let module_instance = self.program.add_module("contract", contract_module, Some(&execution_params.externals)) .map_err(|err| { trace!(target: "wasm", "Error adding contract module: {:?}", err); - evm::Error::from(RuntimeError::Interpreter(err)) + vm::Error::from(RuntimeError::Interpreter(err)) })?; module_instance.execute_export("_call", execution_params) .map_err(|err| { trace!(target: "wasm", "Error executing contract: {:?}", err); - evm::Error::from(RuntimeError::Interpreter(err)) + vm::Error::from(RuntimeError::Interpreter(err)) })?; } @@ -157,3 +162,9 @@ fn native_bindings<'a>(runtime: &'a mut Runtime) -> interpreter::UserFunctions<' functions: ::std::borrow::Cow::from(env::SIGNATURES), } } + +impl From for vm::Error { + fn from(err: runtime::Error) -> vm::Error { + vm::Error::Wasm(format!("WASM runtime-error: {:?}", err)) + } +} \ No newline at end of file diff --git a/ethcore/evm/src/wasm/ptr.rs b/ethcore/wasm/src/ptr.rs similarity index 100% rename from ethcore/evm/src/wasm/ptr.rs rename to ethcore/wasm/src/ptr.rs diff --git a/ethcore/evm/src/wasm/result.rs b/ethcore/wasm/src/result.rs similarity index 100% rename from ethcore/evm/src/wasm/result.rs rename to ethcore/wasm/src/result.rs diff --git a/ethcore/evm/src/wasm/runtime.rs b/ethcore/wasm/src/runtime.rs similarity index 97% rename from ethcore/evm/src/wasm/runtime.rs rename to ethcore/wasm/src/runtime.rs index 7beb4c599..5c6a4a626 100644 --- a/ethcore/evm/src/wasm/runtime.rs +++ b/ethcore/wasm/src/runtime.rs @@ -20,8 +20,7 @@ use std::sync::Arc; use byteorder::{LittleEndian, ByteOrder}; -use ext; - +use vm; use parity_wasm::interpreter; use util::{Address, H256, U256}; @@ -62,14 +61,14 @@ pub struct Runtime<'a> { gas_counter: u64, gas_limit: u64, dynamic_top: u32, - ext: &'a mut ext::Ext, + ext: &'a mut vm::Ext, memory: Arc, } impl<'a> Runtime<'a> { /// New runtime for wasm contract with specified params pub fn with_params<'b>( - ext: &'b mut ext::Ext, + ext: &'b mut vm::Ext, memory: Arc, stack_space: u32, gas_limit: u64, @@ -153,14 +152,14 @@ impl<'a> Runtime<'a> { .map_err(|_| interpreter::Error::Trap("Gas state error".to_owned()))? .into(); - match self.ext.create(&gas_left, &endowment, &code, ext::CreateContractAddress::FromSenderAndCodeHash) { - ext::ContractCreateResult::Created(address, gas_left) => { + match self.ext.create(&gas_left, &endowment, &code, vm::CreateContractAddress::FromSenderAndCodeHash) { + vm::ContractCreateResult::Created(address, gas_left) => { self.memory.set(result_ptr, &*address)?; self.gas_counter = self.gas_limit - gas_left.low_u64(); trace!(target: "wasm", "runtime: create contract success (@{:?})", address); Ok(Some(0i32.into())) }, - ext::ContractCreateResult::Failed => { + vm::ContractCreateResult::Failed => { trace!(target: "wasm", "runtime: create contract fail"); Ok(Some((-1i32).into())) } diff --git a/ethcore/evm/src/wasm/tests.rs b/ethcore/wasm/src/tests.rs similarity index 99% rename from ethcore/evm/src/wasm/tests.rs rename to ethcore/wasm/src/tests.rs index 8c2ec0b3f..f856ae767 100644 --- a/ethcore/evm/src/wasm/tests.rs +++ b/ethcore/wasm/src/tests.rs @@ -28,7 +28,7 @@ macro_rules! load_sample { } } -fn test_finalize(res: Result) -> Result { +fn test_finalize(res: Result) -> Result { match res { Ok(GasLeft::Known(gas)) => Ok(gas), Ok(GasLeft::NeedsReturn{..}) => unimplemented!(), // since ret is unimplemented. diff --git a/evmbin/benches/mod.rs b/evmbin/benches/mod.rs index d7d67a551..f4deda88e 100644 --- a/evmbin/benches/mod.rs +++ b/evmbin/benches/mod.rs @@ -31,7 +31,7 @@ extern crate rustc_hex; use self::test::{Bencher, black_box}; use evm::run_vm; -use ethcore::evm::action_params::ActionParams; +use ethcore::vm::ActionParams; use ethcore_util::U256; use rustc_hex::FromHex; diff --git a/evmbin/src/main.rs b/evmbin/src/main.rs index 7e89c7c7f..eda0aee66 100644 --- a/evmbin/src/main.rs +++ b/evmbin/src/main.rs @@ -34,7 +34,7 @@ use docopt::Docopt; use rustc_hex::FromHex; use util::{U256, Bytes, Address}; use ethcore::spec; -use evm::action_params::ActionParams; +use vm::ActionParams; mod vm; mod display; diff --git a/evmbin/src/vm.rs b/evmbin/src/vm.rs index c4530bb9e..617ebc7b9 100644 --- a/evmbin/src/vm.rs +++ b/evmbin/src/vm.rs @@ -20,7 +20,7 @@ use std::time::{Instant, Duration}; use util::U256; use ethcore::{trace, spec}; use ethcore::client::{EvmTestClient, EvmTestError}; -use evm::action_params::ActionParams; +use vm::ActionParams; /// VM execution informant pub trait Informant: trace::VMTracer { diff --git a/rpc/Cargo.toml b/rpc/Cargo.toml index e1212100c..2619c754f 100644 --- a/rpc/Cargo.toml +++ b/rpc/Cargo.toml @@ -46,7 +46,7 @@ ethjson = { path = "../json" } ethcore-devtools = { path = "../devtools" } ethcore-light = { path = "../ethcore/light" } ethcore-logger = { path = "../logger" } -evm = { path = "../ethcore/evm" } +vm = { path = "../ethcore/vm" } parity-updater = { path = "../updater" } parity-reactor = { path = "../util/reactor" } rlp = { path = "../util/rlp" } diff --git a/rpc/src/lib.rs b/rpc/src/lib.rs index 0e96ac509..fec19f78a 100644 --- a/rpc/src/lib.rs +++ b/rpc/src/lib.rs @@ -52,7 +52,7 @@ extern crate ethkey; extern crate ethstore; extern crate ethsync; extern crate ethcore_logger; -extern crate evm; +extern crate vm; extern crate fetch; extern crate parity_reactor; extern crate parity_updater as updater; diff --git a/rpc/src/v1/helpers/light_fetch.rs b/rpc/src/v1/helpers/light_fetch.rs index 4b5e0f815..972315272 100644 --- a/rpc/src/v1/helpers/light_fetch.rs +++ b/rpc/src/v1/helpers/light_fetch.rs @@ -327,7 +327,7 @@ struct ExecuteParams { from: Address, tx: EthTransaction, hdr: encoded::Header, - env_info: ::evm::env_info::EnvInfo, + env_info: ::vm::EnvInfo, engine: Arc<::ethcore::engines::Engine>, on_demand: Arc, sync: Arc, diff --git a/rpc/src/v1/tests/mocked/traces.rs b/rpc/src/v1/tests/mocked/traces.rs index b1b297eb1..f64142f8c 100644 --- a/rpc/src/v1/tests/mocked/traces.rs +++ b/rpc/src/v1/tests/mocked/traces.rs @@ -21,7 +21,7 @@ use ethcore::trace::trace::{Action, Res, Call}; use ethcore::trace::LocalizedTrace; use ethcore::client::TestBlockChainClient; -use evm::CallType; +use vm::CallType; use jsonrpc_core::IoHandler; use v1::tests::helpers::{TestMinerService}; diff --git a/rpc/src/v1/types/trace.rs b/rpc/src/v1/types/trace.rs index b01d04c3f..f9cf0bb40 100644 --- a/rpc/src/v1/types/trace.rs +++ b/rpc/src/v1/types/trace.rs @@ -22,7 +22,7 @@ use ethcore::trace as et; use ethcore::state_diff; use ethcore::account_diff; use ethcore::client::Executed; -use evm; +use vm; use v1::types::{Bytes, H160, H256, U256}; #[derive(Debug, Serialize)] @@ -256,14 +256,14 @@ pub enum CallType { StaticCall, } -impl From for CallType { - fn from(c: evm::CallType) -> Self { +impl From for CallType { + fn from(c: vm::CallType) -> Self { match c { - evm::CallType::None => CallType::None, - evm::CallType::Call => CallType::Call, - evm::CallType::CallCode => CallType::CallCode, - evm::CallType::DelegateCall => CallType::DelegateCall, - evm::CallType::StaticCall => CallType::StaticCall, + vm::CallType::None => CallType::None, + vm::CallType::Call => CallType::Call, + vm::CallType::CallCode => CallType::CallCode, + vm::CallType::DelegateCall => CallType::DelegateCall, + vm::CallType::StaticCall => CallType::StaticCall, } } }