Can now pass in bytes to WasmExecutor.

executor/src/wasm_executor.rs

@@ -24,6 +24,21 @@ use state_machine::{Externalities, CodeExecutor};
 
 use error::{Error, ErrorKind, Result};
 
+use std::sync::{Weak};
+
+fn program_with_externals<E: parity_wasm::interpreter::UserFunctionExecutor + 'static>(externals: parity_wasm::interpreter::UserDefinedElements<E>, module_name: &str) -> result::Result<parity_wasm::ProgramInstance, parity_wasm::interpreter::Error> {
+	let program = parity_wasm::ProgramInstance::new();
+	let instance = {
+		let module = parity_wasm::builder::module().build();
+		let mut instance = parity_wasm::ModuleInstance::new(Weak::default(), module_name.into(), module)?;
+		instance.instantiate(None)?;
+		instance
+	};
+	let other_instance = parity_wasm::interpreter::native_module(Arc::new(instance), externals)?;
+	program.insert_loaded_module(module_name, other_instance)?;
+	Ok(program)
+}
+
 pub trait ConvertibleToWasm { const VALUE_TYPE: parity_wasm::elements::ValueType; type NativeType; fn to_runtime_value(self) -> parity_wasm::interpreter::RuntimeValue; }
 impl ConvertibleToWasm for i32 { type NativeType = i32; const VALUE_TYPE: parity_wasm::elements::ValueType = parity_wasm::elements::ValueType::I32; fn to_runtime_value(self) -> parity_wasm::interpreter::RuntimeValue { parity_wasm::interpreter::RuntimeValue::I32(self) } }
 impl ConvertibleToWasm for u32 { type NativeType = u32; const VALUE_TYPE: parity_wasm::elements::ValueType = parity_wasm::elements::ValueType::I32; fn to_runtime_value(self) -> parity_wasm::interpreter::RuntimeValue { parity_wasm::interpreter::RuntimeValue::I32(self as i32) } }
@@ -44,8 +59,8 @@ macro_rules! convert_args {
 
 #[macro_export]
 macro_rules! convert_fn {
-	( $name:ident ( $( $params:ty ),* ) ) => ( UserFunctionDescriptor::Static(stringify!($name), &convert_args!($($params),*), None) );
-	( $name:ident ( $( $params:ty ),* ) -> $returns:ty ) => ( UserFunctionDescriptor::Static(stringify!($name), &convert_args!($($params),*), Some(<$returns>::VALUE_TYPE) ) );
+	( $name:ident ( $( $params:ty ),* ) ) => ( parity_wasm::interpreter::UserFunctionDescriptor::Static(stringify!($name), &convert_args!($($params),*), None) );
+	( $name:ident ( $( $params:ty ),* ) -> $returns:ty ) => ( parity_wasm::interpreter::UserFunctionDescriptor::Static(stringify!($name), &convert_args!($($params),*), Some(<$returns>::VALUE_TYPE) ) );
 }
 
 #[macro_export]
@@ -83,7 +98,7 @@ macro_rules! marshall {
 #[macro_export]
 macro_rules! dispatch {
 	( $objectname:ident, $( $name:ident ( $( $names:ident : $params:ty ),* ) $( -> $returns:ty )* => $body:tt ),* ) => (
-		fn execute(&mut self, name: &str, context: CallerContext)
+		fn execute(&mut self, name: &str, context: parity_wasm::interpreter::CallerContext)
 			-> result::Result<Option<parity_wasm::interpreter::RuntimeValue>, parity_wasm::interpreter::Error> {
 			let $objectname = self;
 			match name {
@@ -99,7 +114,7 @@ macro_rules! dispatch {
 #[macro_export]
 macro_rules! signatures {
 	( $( $name:ident ( $( $params:ty ),* ) $( -> $returns:ty )* ),* ) => (
-		const SIGNATURES: &'static [UserFunctionDescriptor] = &[
+		const SIGNATURES: &'static [parity_wasm::interpreter::UserFunctionDescriptor] = &[
 			$(
 				convert_fn!( $name ( $( $params ),* ) $( -> $returns )* ),
 			)*
@@ -110,7 +125,7 @@ macro_rules! signatures {
 #[macro_export]
 macro_rules! function_executor {
 	( $objectname:ident : $structname:ident, $( $name:ident ( $( $names:ident : $params:ty ),* ) $( -> $returns:ty )* => $body:tt ),* ) => (
-		impl UserFunctionExecutor for $structname {
+		impl parity_wasm::interpreter::UserFunctionExecutor for $structname {
 			dispatch!($objectname, $( $name( $( $names : $params ),* ) $( -> $returns )* => $body ),*);
 		}
 		impl $structname {
@@ -119,6 +134,57 @@ macro_rules! function_executor {
 	);
 }
 
+use std::result;
+use std::sync::{Arc, Mutex};
+
+// user function executor
+#[derive(Default)]
+struct FunctionExecutor {
+	context: Arc<Mutex<Option<FEContext>>>,
+}
+
+struct FEContext {
+	heap_end: u32,
+	memory: Arc<parity_wasm::interpreter::MemoryInstance>,
+}
+
+impl FEContext {
+	fn new(m: &Arc<parity_wasm::interpreter::ModuleInstance>) -> Self {
+		use parity_wasm::ModuleInstanceInterface;
+		FEContext { heap_end: 1024, memory: Arc::clone(&m.memory(parity_wasm::interpreter::ItemIndex::Internal(0)).unwrap()) }
+	}
+	fn allocate(&mut self, size: u32) -> u32 {
+		let r = self.heap_end;
+		self.heap_end += size;
+		r
+	}
+	fn deallocate(&mut self, _offset: u32) {
+	}
+}
+
+function_executor!(this: FunctionExecutor,
+	imported(n: u64) -> u64 => { println!("imported {:?}", n); n + 1 },
+	ext_memcpy(dest: *mut u8, src: *const u8, count: usize) -> *mut u8 => {
+		let mut context = this.context.lock().unwrap();
+		context.as_mut().unwrap().memory.copy_nonoverlapping(src as usize, dest as usize, count as usize).unwrap();
+		println!("memcpy {} from {}, {} bytes", dest, src, count);
+		dest
+	},
+	ext_memmove(dest: *mut u8, src: *const u8, count: usize) -> *mut u8 => { println!("memmove {} from {}, {} bytes", dest, src, count); dest },
+	ext_memset(dest: *mut u8, val: i32, count: usize) -> *mut u8 => { println!("memset {} with {}, {} bytes", dest, val, count); dest },
+	ext_malloc(size: usize) -> *mut u8 => {
+		let mut context = this.context.lock().unwrap();
+		let r = context.as_mut().unwrap().allocate(size);
+		println!("malloc {} bytes at {}", size, r);
+		r
+	},
+	ext_free(addr: *mut u8) => {
+		let mut context = this.context.lock().unwrap();
+		context.as_mut().unwrap().deallocate(addr);
+		println!("free {}", addr)
+	}
+);
+
 
 /// Dummy rust executor for contracts.
 ///
@@ -137,7 +203,6 @@ impl CodeExecutor for WasmExecutor {
 		method: &str,
 		data: &CallData,
 	) -> Result<OutData> {
-
 		// TODO: avoid copying code by requiring code to remain immutable through execution,
 		// splitting it off from potentially mutable externalities.
 		let code = match ext.code() {
@@ -146,12 +211,31 @@ impl CodeExecutor for WasmExecutor {
 		};
 
 		use parity_wasm::ModuleInstanceInterface;
-		use parity_wasm::RuntimeValue::{I64};
-		let program = parity_wasm::ProgramInstance::new();
+		use parity_wasm::interpreter::UserDefinedElements;
+		use parity_wasm::RuntimeValue::I32;
+		use std::collections::HashMap;
+
+		let fe_context = Arc::new(Mutex::new(None));
+		let externals = UserDefinedElements {
+			executor: Some(FunctionExecutor { context: Arc::clone(&fe_context) }),
+			globals: HashMap::new(),
+			functions: ::std::borrow::Cow::from(FunctionExecutor::SIGNATURES),
+		};
+
+		let program = program_with_externals(externals, "env").unwrap();
 		let module = parity_wasm::deserialize_buffer(code).expect("Failed to load module");
-		let module = program.add_module("main", module, None).expect("Failed to initialize module");
-		module.execute_export(method, vec![I64(data.0.len() as i64)].into())
-			.map(|o| OutData(vec![1; if let Some(I64(l)) = o { l as usize } else { 0 }]))
+		let module = program.add_module("test", module, None).expect("Failed to initialize module");
+		*fe_context.lock().unwrap() = Some(FEContext::new(&module));
+
+		let size = data.0.len() as u32;
+		let offset = fe_context.lock().unwrap().as_mut().unwrap().allocate(size);
+		module.memory(parity_wasm::interpreter::ItemIndex::Internal(0)).unwrap().set(offset, &data.0).unwrap();
+
+		module.execute_export(method, vec![I32(offset as i32), I32(size as i32)].into())
+			.map(|o| {
+				// TODO: populate vec properly
+				OutData(vec![1; if let Some(I32(l)) = o { l as usize } else { 0 }])
+			})
 			.map_err(|_| ErrorKind::Runtime.into())
 	}
 }
@@ -188,9 +272,11 @@ mod tests {
 	}
 
 	use std::result;
-	use std::sync::{Arc, Weak, Mutex};
+	use std::sync::{Arc, Mutex};
 	use std::mem::transmute;
-	use parity_wasm::interpreter::{CallerContext, MemoryInstance, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor};
+	use parity_wasm::interpreter::{MemoryInstance, UserDefinedElements};
+	use parity_wasm::ModuleInstanceInterface;
+	use parity_wasm::RuntimeValue::{I32, I64};
 
 	// user function executor
 	#[derive(Default)]
@@ -236,24 +322,8 @@ mod tests {
 		}
 	);
 
-	fn program_with_externals<E: UserFunctionExecutor + 'static>(externals: UserDefinedElements<E>, module_name: &str) -> result::Result<parity_wasm::ProgramInstance, parity_wasm::interpreter::Error> {
-		let program = parity_wasm::ProgramInstance::new();
-		let instance = {
-			let module = parity_wasm::builder::module().build();
-			let mut instance = parity_wasm::ModuleInstance::new(Weak::default(), module_name.into(), module)?;
-			instance.instantiate(None)?;
-			instance
-		};
-		let other_instance = parity_wasm::interpreter::native_module(Arc::new(instance), externals)?;
-		program.insert_loaded_module(module_name, other_instance)?;
-		Ok(program)
-	}
-
 	#[test]
 	fn should_pass_freeable_data() {
-		use parity_wasm::ModuleInstanceInterface;
-		use parity_wasm::RuntimeValue::{I32};
-
 		let fe_context = Arc::new(Mutex::new(None));
 		let externals = UserDefinedElements {
 			executor: Some(FunctionExecutor { context: Arc::clone(&fe_context) }),
@@ -281,9 +351,6 @@ mod tests {
 
 	#[test]
 	fn should_provide_externalities() {
-		use parity_wasm::ModuleInstanceInterface;
-		use parity_wasm::RuntimeValue::{I64};
-
 		let fe_context = Arc::new(Mutex::new(None));
 		let externals = UserDefinedElements {
 			executor: Some(FunctionExecutor { context: Arc::clone(&fe_context) }),
@@ -310,9 +377,6 @@ mod tests {
 
 	#[test]
 	fn should_run_wasm() {
-		use parity_wasm::ModuleInstanceInterface;
-		use parity_wasm::RuntimeValue::{I64};
-
 		let program = parity_wasm::ProgramInstance::new();
 		let test_module = include_bytes!("../../runtime/target/wasm32-unknown-unknown/release/runtime.wasm");
 		let module = parity_wasm::deserialize_buffer(test_module.to_vec()).expect("Failed to load module");