From f2ae8708de20daed307ed4719a96add1ec60f5b6 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Mon, 28 Dec 2015 15:11:05 +0100
Subject: [PATCH] fixed env address

---
 rust-evmjit/src/lib.rs | 34 ++++++++++++++++++++--------------
 src/evm/env.rs         |  8 ++++++--
 src/evm/jit.rs         | 29 +++++++++++++++++++++++++++--
 3 files changed, 53 insertions(+), 18 deletions(-)

diff --git a/rust-evmjit/src/lib.rs b/rust-evmjit/src/lib.rs
index bcae4b666..58cb4a1f5 100644
--- a/rust-evmjit/src/lib.rs
+++ b/rust-evmjit/src/lib.rs
@@ -68,20 +68,23 @@ impl DerefMut for RuntimeDataHandle {
 /// Safe handle for jit context.
 pub struct ContextHandle {
 	context: *mut JitContext,
-	_data_handle: RuntimeDataHandle,
-	_env: EnvHandle
+	data_handle: RuntimeDataHandle,
+	env: EnvHandle
 }
 
 impl ContextHandle {
 	/// Creates new context handle.
-	pub fn new(mut data_handle: RuntimeDataHandle, mut env: EnvHandle) -> Self {
+	pub fn new(data_handle: RuntimeDataHandle, env: EnvHandle) -> Self {
 		import_evmjit_abi();
-		let context = unsafe { evmjit_create_context(data_handle.mut_runtime_data(), &mut env) };
-		ContextHandle {
-			context: context,
-			_data_handle: data_handle,
-			_env: env
-		}
+		let mut handle = ContextHandle {
+			context: unsafe {::std::mem::uninitialized()},
+			data_handle: data_handle,
+			env: env
+		};
+
+		println!("env address: {:?}", &handle.env as *const _);
+		handle.context = unsafe { evmjit_create_context(handle.data_handle.mut_runtime_data(), &mut handle.env) };
+		handle
 	}
 
 	/// Executes context.
@@ -156,7 +159,7 @@ impl Deref for EnvHandle {
 	fn deref(&self) -> &Self::Target {
 		match self.env_impl {
 			Some(ref env) => env,
-			None => { panic!(); }
+			None => { panic!("Handle is empty!"); }
 		}
 	}
 }
@@ -165,7 +168,7 @@ impl DerefMut for EnvHandle {
 	fn deref_mut(&mut self) -> &mut Self::Target {
 		match self.env_impl {
 			Some(ref mut env) => env,
-			None => { panic!(); }
+			None => { panic!("Handle is empty!"); }
 		}
 	}
 }
@@ -201,6 +204,7 @@ pub mod ffi {
 	}
 
 	#[repr(C)]
+	#[derive(Debug)]
 	/// Jit runtime data.
 	pub struct JitRuntimeData {
 		pub gas: i64,
@@ -232,7 +236,7 @@ pub mod ffi {
 	///	nm your_executable -g | grep env 
 	/// ```
 	/// 
-	/// It Should give the following output:
+	/// It should give the following output:
 	///
 	/// ```bash
 	/// 00000001000779e0 T _env_balance
@@ -258,13 +262,15 @@ pub mod ffi {
 	}
 
 	#[no_mangle]
-	pub unsafe extern fn env_sload(env: *const EnvHandle, index: *const JitI256, out_value: *mut JitI256) {
+	pub unsafe extern "C" fn env_sload(env: *const EnvHandle, index: *const JitI256, out_value: *mut JitI256) {
+		println!("sload env address: {:?}", env);
 		let env = &*env;
 		env.sload(index, out_value);
 	}
 
 	#[no_mangle]
-	pub unsafe extern fn env_sstore(env: *mut EnvHandle, index: *const JitI256, value: *const JitI256) {
+	pub unsafe extern "C" fn env_sstore(env: *mut EnvHandle, index: *mut JitI256, value: *mut JitI256) {
+		println!("sstore");
 		let env = &mut *env;
 		env.sstore(index, value);
 	}
diff --git a/src/evm/env.rs b/src/evm/env.rs
index 9221b5a6c..42d7031e3 100644
--- a/src/evm/env.rs
+++ b/src/evm/env.rs
@@ -8,11 +8,15 @@ impl Env {
 	}
 
 	pub fn sload(&self, _index: &H256) -> H256 {
-		unimplemented!();
+		println!("sload!");
+		//unimplemented!();
+		H256::new()
 	}
 
 	pub fn sstore(&self, _index: &H256, _value: &H256) {
-		unimplemented!();
+		println!("sstore!");
+		//unimplemented!();
+		
 	}
 }
 
diff --git a/src/evm/jit.rs b/src/evm/jit.rs
index 72b71cec3..e004c87fc 100644
--- a/src/evm/jit.rs
+++ b/src/evm/jit.rs
@@ -162,9 +162,10 @@ impl evmjit::Env for EnvAdapter {
 
 #[cfg(test)]
 mod tests {
+	use std::str::FromStr;
 	use util::hash::*;
 	use util::uint::*;
-	use evmjit::{ContextHandle, RuntimeDataHandle, EnvHandle, ReturnCode};
+	use evmjit::{ContextHandle, RuntimeDataHandle, EnvHandle, ReturnCode, ffi};
 	use evm::*;
 	use evm::jit::{FromJit, IntoJit};
 
@@ -188,13 +189,37 @@ mod tests {
 		assert_eq!(h, h2);
 	}
 
+	#[test]
+	fn test_env_sload() {
+		let env = EnvHandle::new(EnvAdapter::new());
+		let i = U256::from(0).into_jit();
+		let mut o = U256::from(0).into_jit();
+		unsafe {
+			ffi::env_sload(&env as *const _, &i as *const _, &mut o as *mut _);
+		}
+	}
+
 	#[test]
 	fn test_env_adapter() {
 		let mut data = RuntimeData::new();
-		data.code = vec![0x60, 0x00, 0x60, 0x00, 0x20, 0x60, 0x00, 0x55];
+		data.coinbase = Address::from_str("2adc25665018aa1fe0e6bc666dac8fc2697ff9ba").unwrap();
+		data.difficulty = U256::from(0x0100);
+		data.gas_limit = U256::from(0x0f4240);
+		data.number = 0;
+		data.timestamp = 1;
+		
+		data.address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
+		data.caller = Address::from_str("cd1722f3947def4cf144679da39c4c32bdc35681").unwrap();
+		data.code = vec![0x60, 0x00, 0x60, 0x00, 0x55];
+		data.gas = 0x174876e800;
+		data.gas_price = 0x3b9aca00;
+		data.origin = Address::from_str("cd1722f3947def4cf144679da39c4c32bdc35681").unwrap();
+		data.call_value = U256::from_str("0de0b6b3a7640000").unwrap();
 		let env = EnvAdapter::new();
 		let mut context = ContextHandle::new(data.into_jit(), EnvHandle::new(env));
+		// crashes with signal 11 on env.sload
 		assert_eq!(context.exec(), ReturnCode::Stop);
+		assert!(false);
 	}
 
 }