move mem_written to trace_executed

ethcore/evm/src/interpreter/mod.rs

@@ -314,8 +314,8 @@ impl<Cost: CostType> Interpreter<Cost> {
 	/// Inner helper function for step.
 	#[inline(always)]
 	fn step_inner(&mut self, ext: &mut dyn vm::Ext) -> InterpreterResult {
-		let result = match self.resume_result.take() {
-			Some(result) => result,
+		let (result, mem_written, store_written) = match self.resume_result.take() {
+			Some(result) => (result, None, None),
 			None => {
 				let opcode = self.reader.code[self.reader.position];
 				let instruction = Instruction::from_u8(opcode);
@@ -344,9 +344,12 @@ impl<Cost: CostType> Interpreter<Cost> {
 					Ok(t) => t,
 					Err(e) => return InterpreterResult::Done(Err(e)),
 				};
-				if self.do_trace {
-					ext.trace_prepare_execute(self.reader.position - 1, opcode, requirements.gas_cost.as_u256(), Self::mem_written(instruction, &self.stack), Self::store_written(instruction, &self.stack));
-				}
+				let (mem_written, store_written) = if self.do_trace {
+					ext.trace_prepare_execute(self.reader.position - 1, opcode, requirements.gas_cost.as_u256());
+					(Self::mem_written(instruction, &self.stack), Self::store_written(instruction, &self.stack))
+				} else {
+					(None, None)
+				};
 				if let Err(e) = self.gasometer.as_mut().expect(GASOMETER_PROOF).verify_gas(&requirements.gas_cost) {
 					return InterpreterResult::Done(Err(e));
 				}
@@ -365,7 +368,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 					Ok(x) => x,
 				};
 				evm_debug!({ self.informant.after_instruction(instruction) });
-				result
+				(result, mem_written, store_written)
 			},
 		};
 
@@ -382,6 +385,8 @@ impl<Cost: CostType> Interpreter<Cost> {
 				self.gasometer.as_mut().expect(GASOMETER_PROOF).current_gas.as_u256(),
 				self.stack.peek_top(self.last_stack_ret_len),
 				&self.mem,
+				mem_written,
+				store_written,
 			);
 		}
 

ethcore/machine/src/externalities.rs

@@ -432,12 +432,19 @@ impl<'a, T: 'a, V: 'a, B: 'a> Ext for Externalities<'a, T, V, B>
 		self.vm_tracer.trace_next_instruction(pc, instruction, current_gas)
 	}
 
-	fn trace_prepare_execute(&mut self, pc: usize, instruction: u8, gas_cost: U256, mem_written: Option<(usize, usize)>, store_written: Option<(U256, U256)>) {
-		self.vm_tracer.trace_prepare_execute(pc, instruction, gas_cost, mem_written, store_written)
+	fn trace_prepare_execute(&mut self, pc: usize, instruction: u8, gas_cost: U256) {
+		self.vm_tracer.trace_prepare_execute(pc, instruction, gas_cost)
 	}
 
-	fn trace_executed(&mut self, gas_used: U256, stack_push: &[U256], mem: &[u8]) {
-		self.vm_tracer.trace_executed(gas_used, stack_push, mem)
+	fn trace_executed(
+		&mut self,
+		gas_used: U256,
+		stack_push: &[U256],
+		mem: &[u8],
+		mem_written: Option<(usize, usize)>,
+		store_written: Option<(U256, U256)>,
+	) {
+		self.vm_tracer.trace_executed(gas_used, stack_push, mem, mem_written, store_written)
 	}
 
 	fn is_static(&self) -> bool {

ethcore/trace/src/executive_tracer.rs

@@ -200,8 +200,6 @@ impl Tracer for ExecutiveTracer {
 pub struct ExecutiveVMTracer {
 	data: VMTrace,
 	depth: usize,
-	last_mem_written: Option<(usize, usize)>,
-	last_store_written: Option<(U256, U256)>,
 }
 
 impl ExecutiveVMTracer {
@@ -215,8 +213,6 @@ impl ExecutiveVMTracer {
 				subs: vec![],
 			},
 			depth: 0,
-			last_mem_written: None,
-			last_store_written: None,
 		}
 	}
 
@@ -234,7 +230,7 @@ impl VMTracer for ExecutiveVMTracer {
 
 	fn trace_next_instruction(&mut self, _pc: usize, _instruction: u8, _current_gas: U256) -> bool { true }
 
-	fn trace_prepare_execute(&mut self, pc: usize, instruction: u8, gas_cost: U256, mem_written: Option<(usize, usize)>, store_written: Option<(U256, U256)>) {
+	fn trace_prepare_execute(&mut self, pc: usize, instruction: u8, gas_cost: U256) {
 		Self::with_trace_in_depth(&mut self.data, self.depth, move |trace| {
 			trace.operations.push(VMOperation {
 				pc: pc,
@@ -243,13 +239,18 @@ impl VMTracer for ExecutiveVMTracer {
 				executed: None,
 			});
 		});
-		self.last_mem_written = mem_written;
-		self.last_store_written = store_written;
 	}
 
-	fn trace_executed(&mut self, gas_used: U256, stack_push: &[U256], mem: &[u8]) {
-		let mem_diff = self.last_mem_written.take().map(|(o, s)| (o, &(mem[o..o+s])));
-		let store_diff = self.last_store_written.take();
+	fn trace_executed(
+		&mut self,
+		gas_used: U256,
+		stack_push: &[U256],
+		mem: &[u8],
+		mem_written: Option<(usize, usize)>,
+		store_written: Option<(U256, U256)>,
+	) {
+		let mem_diff = mem_written.map(|(o, s)| (o, &(mem[o..o+s])));
+		let store_diff = store_written;
 		Self::with_trace_in_depth(&mut self.data, self.depth, move |trace| {
 			let ex = VMExecutedOperation {
 				gas_used: gas_used,

ethcore/trace/src/lib.rs

@@ -91,10 +91,17 @@ pub trait VMTracer: Send {
 	fn trace_next_instruction(&mut self, _pc: usize, _instruction: u8, _current_gas: U256) -> bool { false }
 
 	/// Trace the preparation to execute a single valid instruction.
-	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: U256, _mem_written: Option<(usize, usize)>, _store_written: Option<(U256, U256)>) {}
+	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: U256) {}
 
 	/// Trace the finalised execution of a single valid instruction.
-	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem: &[u8]) {}
+	fn trace_executed(
+		&mut self,
+		_gas_used: U256,
+		_stack_push: &[U256],
+		_mem: &[u8],
+		_mem_written: Option<(usize, usize)>,
+		_store_written: Option<(U256, U256)>,
+	) {}
 
 	/// Spawn subtracer which will be used to trace deeper levels of execution.
 	fn prepare_subtrace(&mut self, _code: &[u8]) {}

ethcore/vm/src/ext.rs

@@ -161,10 +161,17 @@ pub trait Ext {
 	fn trace_next_instruction(&mut self, _pc: usize, _instruction: u8, _current_gas: U256) -> bool { false }
 
 	/// Prepare to trace an operation. Passthrough for the VM trace.
-	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: U256, _mem_written: Option<(usize, usize)>, _store_written: Option<(U256, U256)>) {}
+	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: U256) {}
 
 	/// Trace the finalised execution of a single instruction.
-	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem: &[u8]) {}
+	fn trace_executed(
+		&mut self,
+		_gas_used: U256,
+		_stack_push: &[U256],
+		_mem: &[u8],
+		_mem_written: Option<(usize, usize)>,
+		_store_written: Option<(U256, U256)>
+	) {}
 
 	/// Check if running in static context.
 	fn is_static(&self) -> bool;