evmjit output data

rust-evmjit/src/lib.rs

@@ -110,6 +110,11 @@ impl ContextHandle {
 	pub fn exec(&mut self) -> JitReturnCode {
 		unsafe { evmjit_exec(self.context) }
 	}
+
+	/// Returns output data.
+	pub fn output_data(&self) -> &[u8] {
+		unsafe { std::slice::from_raw_parts(self.data_handle.call_data, self.data_handle.call_data_size as usize) }
+	}
 }
 
 impl Drop for ContextHandle {

src/evm/evm.rs

@@ -1,16 +1,17 @@
 //! Evm interface.
 
+use util::bytes::Bytes;
 use evm::{EvmParams, Ext};
 
 #[derive(Debug, Eq, PartialEq)]
-pub enum ReturnCode {
+pub enum EvmResult {
 	Stop,
-	Return,
+	Return(Bytes),
 	Suicide,
 	OutOfGas,
 	InternalError
 }
 
 pub trait Evm {
-	fn exec(&self, params: &EvmParams, ext: &mut Ext) -> ReturnCode;
+	fn exec(&self, params: &EvmParams, ext: &mut Ext) -> EvmResult;
 }

src/evm/executive.rs

@@ -8,7 +8,7 @@ use state::*;
 use env_info::*;
 use engine::*;
 use transaction::*;
-use evm::{VmFactory, Ext, LogEntry, EvmParams, ReturnCode};
+use evm::{VmFactory, Ext, LogEntry, EvmParams, EvmResult};
 
 /// Returns new address created from address and given nonce.
 pub fn contract_address(address: &Address, nonce: &U256) -> Address {
@@ -96,26 +96,24 @@ impl<'a> Executive<'a> {
 	
 	fn create(e: &mut Executive<'a>, params: &EvmParams) -> ExecutiveResult {
 		//self.state.require_or_from(&self.params.address, false, ||Account::new_contract(U256::from(0)));
+		//TODO: ensure that account at given address is created
 		e.state.transfer_balance(&params.sender, &params.address, &params.value);
-		let mut ext = Externalities::new(e.state, e.info, e.engine, e.depth, params);
 
 		let code = {
+			let mut ext = Externalities::new(e.state, e.info, e.engine, e.depth, params);
 			let evm = VmFactory::create();
 			evm.exec(&params, &mut ext)
 		};
 
 		match code {
-			ReturnCode::Stop => {  //| ReturnCode::Return => {
+			EvmResult::Stop => {
-				//println!("code: {:?}", code);
-				//self.state.set_code(&self.params.address, self.params.code.clone());
 				ExecutiveResult::Ok
 			},
-			ReturnCode::Return => {
+			EvmResult::Return(output) => {
-				//self.state.transfer_balance(&self.params.sender, &self.params.address, &self.params.value);
+				//e.state.set_code(&params.address, output);
-				//self.state.set_code(&self.params.address, self.params.code.clone());
 				ExecutiveResult::Ok
 			},
-			ReturnCode::OutOfGas => {
+			EvmResult::OutOfGas => {
 				ExecutiveResult::OutOfGas
 			},
 			err => {

src/evm/jit.rs

@@ -286,22 +286,10 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 	}
 }
 
-impl From<evmjit::ReturnCode> for evm::ReturnCode {
-	fn from(code: evmjit::ReturnCode) -> Self {
-		match code {
-			evmjit::ReturnCode::Stop => evm::ReturnCode::Stop,
-			evmjit::ReturnCode::Return => evm::ReturnCode::Return,
-			evmjit::ReturnCode::Suicide => evm::ReturnCode::Suicide,
-			evmjit::ReturnCode::OutOfGas => evm::ReturnCode::OutOfGas,
-			_ => evm::ReturnCode::InternalError
-		}
-	}
-}
-
 pub struct JitEvm;
 
 impl evm::Evm for JitEvm {
-	fn exec(&self, params: &evm::EvmParams, ext: &mut evm::Ext) -> evm::ReturnCode {
+	fn exec(&self, params: &evm::EvmParams, ext: &mut evm::Ext) -> evm::EvmResult {
 		// 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)) };
 		let mut ext_handle = evmjit::ExtHandle::new(ext_adapter);
@@ -314,7 +302,6 @@ impl evm::Evm for JitEvm {
 		data.origin = params.origin.clone();
 		data.call_value = params.value;
 		data.code = params.code.clone();
-		println!("params.address: {:?}, params.code: {:?}", params.address, params.code);
 
 		// TODO:
 		data.coinbase = Address::new();
@@ -324,7 +311,13 @@ impl evm::Evm for JitEvm {
 		data.timestamp = 0;
 		
 		let mut context = unsafe { evmjit::ContextHandle::new(data.into_jit(), &mut ext_handle) };
-		From::from(context.exec())
+		match context.exec() {
+			evmjit::ReturnCode::Stop => evm::EvmResult::Stop,
+			evmjit::ReturnCode::Return => evm::EvmResult::Return(context.output_data().to_vec()),
+			evmjit::ReturnCode::Suicide => evm::EvmResult::Suicide,
+			evmjit::ReturnCode::OutOfGas => evm::EvmResult::OutOfGas,
+			_ => evm::EvmResult::InternalError
+		}
 	}
 }
 
@@ -406,7 +399,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(state.storage_at(&address, &H256::new()), 
@@ -428,7 +421,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(state.storage_at(&address, &H256::new()), 
@@ -450,7 +443,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(state.storage_at(&address, &H256::new()), 
@@ -473,7 +466,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(Address::from(state.storage_at(&address, &H256::new())), address.clone());
@@ -496,7 +489,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(Address::from(state.storage_at(&address, &H256::new())), address.clone());
@@ -535,7 +528,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(state.storage_at(&address, &H256::new()), 
@@ -559,7 +552,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(state.storage_at(&address, &H256::new()), H256::from(&U256::from(0x10)));
@@ -578,7 +571,7 @@ mod tests {
 		let engine = TestEngine::new();
 		let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 		let evm = JitEvm;
-		assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+		assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		let logs = ext.logs();
 		assert_eq!(logs.len(), 1);
 		let log = &logs[0];
@@ -609,7 +602,7 @@ mod tests {
 		let engine = TestEngine::new();
 		let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 		let evm = JitEvm;
-		assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+		assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		let logs = ext.logs();
 		assert_eq!(logs.len(), 1);
 		let log = &logs[0];
@@ -638,7 +631,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(state.storage_at(&address, &H256::new()), H256::from(address.clone()));
@@ -662,7 +655,7 @@ mod tests {
 		{
 			let mut ext = Externalities::new(&mut state, &info, &engine, 0, &params);
 			let evm = JitEvm;
-			assert_eq!(evm.exec(&params, &mut ext), ReturnCode::Stop);
+			assert_eq!(evm.exec(&params, &mut ext), EvmResult::Stop);
 		}
 
 		assert_eq!(state.storage_at(&address, &H256::new()), H256::from_str("23ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23").unwrap());

src/evm/mod.rs

@@ -9,7 +9,7 @@ pub mod params;
 #[cfg(feature = "jit" )]
 mod jit;
 
-pub use self::evm::{Evm, ReturnCode};
+pub use self::evm::{Evm, EvmResult};
 pub use self::ext::{Ext};
 pub use self::logentry::LogEntry;
 pub use self::vmfactory::VmFactory;