Merge branch 'stable-tracer-interface' into fvs-circuit-statistics-tr…

…acers-interface

src/instruction_handlers/common.rs

@@ -24,14 +24,19 @@ pub(crate) fn instruction_boilerplate_ext<Opcode: OpcodeType, T: Tracer, W>(
     vm: &mut VirtualMachine<T, W>,
     world: &mut W,
     tracer: &mut T,
-    business_logic: impl FnOnce(&mut VirtualMachine<T, W>, &Arguments, &mut W) -> ExecutionStatus,
+    business_logic: impl FnOnce(
+        &mut VirtualMachine<T, W>,
+        &Arguments,
+        &mut T,
+        &mut W,
+    ) -> ExecutionStatus,
 ) -> ExecutionStatus {
     tracer.before_instruction::<Opcode, _>(vm);
     let result = unsafe {
         let instruction = vm.state.current_frame.pc;
         vm.state.current_frame.pc = instruction.add(1);
 
-        business_logic(vm, &(*instruction).arguments, world)
+        business_logic(vm, &(*instruction).arguments, tracer, world)
     };
     tracer.after_instruction::<Opcode, _>(vm);
 

src/instruction_handlers/far_call.rs

@@ -1,5 +1,5 @@
 use super::{
-    common::instruction_boilerplate,
+    common::instruction_boilerplate_ext,
     heap_access::grow_heap,
     ret::{panic_from_failed_far_call, RETURN_COST},
     AuxHeap, Heap,
@@ -45,7 +45,7 @@ fn far_call<
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<FarCall<M>, _, _>(vm, world, tracer, |vm, args, world| {
+    instruction_boilerplate_ext::<FarCall<M>, _, _>(vm, world, tracer, |vm, args, tracer, world| {
         let (raw_abi, raw_abi_is_pointer) = Register1::get_with_pointer_flag(args, &mut vm.state);
 
         let address_mask: U256 = U256::MAX >> (256 - 160);
@@ -118,8 +118,8 @@ fn far_call<
 
         let Some((calldata, program, is_evm_interpreter)) = failing_part else {
             vm.state.current_frame.gas += new_frame_gas.saturating_sub(RETURN_COST);
-            panic_from_failed_far_call(vm, exception_handler);
-            return;
+            panic_from_failed_far_call(vm, tracer, exception_handler);
+            return ExecutionStatus::Running;
         };
 
         let stipend = if is_evm_interpreter {
@@ -165,6 +165,8 @@ fn far_call<
             | u8::from(abi.is_constructor_call);
 
         vm.state.registers[2] = call_type.into();
+
+        ExecutionStatus::Running
     })
 }
 

src/instruction_handlers/heap_access.rs

@@ -107,7 +107,7 @@ fn store<
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate_ext::<H::Write, _, _>(vm, world, tracer, |vm, args, _| {
+    instruction_boilerplate_ext::<H::Write, _, _>(vm, world, tracer, |vm, args, _, _| {
         // Pointers need not be masked here even though we do not care about them being pointers.
         // They will panic, though because they are larger than 2^32.
         let (pointer, _) = In::get_with_pointer_flag(args, &mut vm.state);

src/instruction_handlers/ret.rs

@@ -18,7 +18,7 @@ fn ret<T: Tracer, W, RT: TypeLevelReturnType, const TO_LABEL: bool>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate_ext::<opcodes::Ret<RT>, _, _>(vm, world, tracer, |vm, args, _| {
+    instruction_boilerplate_ext::<opcodes::Ret<RT>, _, _>(vm, world, tracer, |vm, args, _, _| {
         let mut return_type = RT::VALUE;
         let near_call_leftover_gas = vm.state.current_frame.gas;
 
@@ -120,11 +120,13 @@ fn ret<T: Tracer, W, RT: TypeLevelReturnType, const TO_LABEL: bool>(
 
 /// Formally, a far call pushes a new frame and returns from it immediately if it panics.
 /// This function instead panics without popping a frame to save on allocation.
-/// TODO: when tracers are implemented, this function should count as a separate instruction!
 pub(crate) fn panic_from_failed_far_call<T: Tracer, W>(
     vm: &mut VirtualMachine<T, W>,
+    tracer: &mut T,
     exception_handler: u16,
 ) {
+    tracer.before_instruction::<opcodes::Ret<Panic>, _>(vm);
+
     // Gas is already subtracted in the far call code.
     // No need to roll back, as no changes are made in this "frame".
 
@@ -136,6 +138,8 @@ pub(crate) fn panic_from_failed_far_call<T: Tracer, W>(
     vm.state.flags = Flags::new(true, false, false);
 
     vm.state.current_frame.set_pc_from_u16(exception_handler);
+
+    tracer.after_instruction::<opcodes::Ret<Panic>, _>(vm);
 }
 
 /// Panics, burning all available gas.

src/vm.rs

@@ -40,7 +40,8 @@ pub struct VirtualMachine<T, W> {
 
     pub(crate) stack_pool: StackPool,
 
-    // Instructions that are jumped to when things go wrong.
+    /// Instruction that is jumped to when things go wrong while executing another.
+    /// Boxed, so the pointer isn't invalidated by moves.
     pub(crate) panic: Box<Instruction<T, W>>,
 }