feat: try to add --trace arg mapped to tracing flag: too many file changes?

Author: alehander92

crates/c_api/src/func.rs

@@ -210,7 +210,7 @@ pub unsafe extern "C" fn wasm_func_call(
             // can. As a result we catch panics here and transform them to traps to
             // allow the caller to have any insulation possible against Rust panics.
             std::panic::catch_unwind(AssertUnwindSafe(|| {
-                f.call(func.inner.store.context_mut(), wt_params, wt_results)
+                f.call(func.inner.store.context_mut(), wt_params, wt_results, false)
             }))
         }
         #[cfg(not(feature = "std"))]

crates/c_api/src/instance.rs

@@ -56,7 +56,7 @@ pub unsafe extern "C" fn wasm_instance_new(
         .iter()
         .filter_map(|import| import.as_ref().map(|i| i.which))
         .collect::<Box<[_]>>();
-    match Instance::new(store.inner.context_mut(), &wasm_module.inner, &imports) {
+    match Instance::new(store.inner.context_mut(), &wasm_module.inner, &imports, false) {
         Ok(instance) => Some(Box::new(wasm_instance_t::new(
             store.inner.clone(),
             instance,

crates/cli/src/args.rs

@@ -99,6 +99,12 @@ pub struct Args {
     /// Arguments given to the Wasm module or the invoked function.
     #[clap(value_name = "ARGS")]
     func_args: Vec<String>,
+
+    #[clap(
+        long = "trace",
+        default_value_t = false,
+    )]
+    tracing: bool,
 }
 
 /// The chosen Wasmi compilation mode.
@@ -151,6 +157,11 @@ impl Args {
         self.verbose
     }
 
+    /// Returns `true` if tracing is enabled.
+    pub fn tracing(&self) -> bool {
+        self.tracing
+    }
+
     /// Pre-opens all directories given in `--dir` and returns them for use by the [`WasiCtx`].
     ///
     /// # Errors

crates/cli/src/context.rs

@@ -13,6 +13,8 @@ pub struct Context {
     store: Store<WasiCtx>,
     /// The Wasm module instance to operate on.
     instance: Instance,
+    // Is the tracing enabled
+    // tracing: bool,
 }
 
 impl Context {
@@ -27,6 +29,7 @@ impl Context {
         wasi_ctx: WasiCtx,
         fuel: Option<u64>,
         compilation_mode: CompilationMode,
+        tracing: bool,
     ) -> Result<Self, Error> {
         let mut config = Config::default();
         if fuel.is_some() {
@@ -52,12 +55,13 @@ impl Context {
             .map_err(|error| anyhow!("failed to add WASI definitions to the linker: {error}"))?;
         let instance = linker
             .instantiate(&mut store, &module)
-            .and_then(|pre| pre.start(&mut store))
+            .and_then(|pre| pre.start(&mut store, tracing))
             .map_err(|error| anyhow!("failed to instantiate and start the Wasm module: {error}"))?;
         Ok(Self {
             module,
             store,
             instance,
+            // tracing,
         })
     }
 

crates/cli/src/main.rs

@@ -20,7 +20,7 @@ fn main() -> Result<()> {
     let args = Args::parse();
     let wasm_file = args.wasm_file();
     let wasi_ctx = args.wasi_context()?;
-    let mut ctx = Context::new(wasm_file, wasi_ctx, args.fuel(), args.compilation_mode())?;
+    let mut ctx = Context::new(wasm_file, wasi_ctx, args.fuel(), args.compilation_mode(), args.tracing())?;
     let (func_name, func) = get_invoked_func(&args, &ctx)?;
     let ty = func.ty(ctx.store());
     let func_args = utils::decode_func_args(&ty, args.func_args())?;
@@ -39,7 +39,7 @@ fn main() -> Result<()> {
         )
     }
 
-    match func.call(ctx.store_mut(), &func_args, &mut func_results) {
+    match func.call(ctx.store_mut(), &func_args, &mut func_results, args.tracing()) {
         Ok(()) => {
             print_remaining_fuel(&args, &ctx);
             print_pretty_results(&func_results);

crates/wasmi/src/engine/executor/instrs.rs

@@ -71,10 +71,11 @@ pub fn execute_instrs<'engine, T>(
     store: &mut Store<T>,
     stack: &'engine mut Stack,
     code_map: &'engine CodeMap,
+    tracing: bool,
 ) -> Result<(), Error> {
     let instance = stack.calls.instance_expect();
     let cache = CachedInstance::new(&mut store.inner, instance);
-    Executor::new(stack, code_map, cache).execute(store)
+    Executor::new(stack, code_map, cache, tracing).execute(store)
 }
 
 /// An execution context for executing a Wasmi function frame.
@@ -95,6 +96,7 @@ struct Executor<'engine> {
 
     // debug:
     // TODO tracer: &'engine mut WasmTracer,
+    tracing: bool,
 }
 
 impl<'engine> Executor<'engine> {
@@ -104,6 +106,7 @@ impl<'engine> Executor<'engine> {
         stack: &'engine mut Stack,
         code_map: &'engine CodeMap,
         cache: CachedInstance,
+        tracing: bool,
     ) -> Self {
         let frame = stack
             .calls
@@ -122,6 +125,7 @@ impl<'engine> Executor<'engine> {
             stack,
             code_map,
             // TODO tracer: &mut tracer, // probably were not gonna make it
+            tracing,
         }
     }
 
@@ -130,16 +134,17 @@ impl<'engine> Executor<'engine> {
     fn execute<T>(mut self, store: &mut Store<T>) -> Result<(), Error> {
         use Instruction as Instr;
         loop {
-            // TODO: change that, just startting from somewehre
-            // Args: path : Path, instruction address(?) , step?
-            // TODO: good way to take address
-            //let address = usize::from(self.ip.get());
-            let address = 0x000000010; // should be in the main subprogram >= low_pc
-            //std::println!("address of {:?}: {:?}", *self.ip.get(), address);
-            // TODO: make this be a field with correct lifetime
-            let mut tracer = WasmTracer::new(std::path::Path::new("/home/pesho/code/codetracer-wasmi-recorder/wasm_test.wasm")); // "<path to test.wasm>: for now hardcoded TODO pass");
-            tracer.load_local_variables(address);
-
+            if self.tracing {
+                // TODO: change that, just startting from somewehre
+                // Args: path : Path, instruction address(?) , step?
+                // TODO: good way to take address
+                //let address = usize::from(self.ip.get());
+                let address = 0x000000010; // should be in the main subprogram >= low_pc
+                //std::println!("address of {:?}: {:?}", *self.ip.get(), address);
+                // TODO: make this be a field with correct lifetime
+                let mut tracer = WasmTracer::new(std::path::Path::new("/home/pesho/code/codetracer-wasmi-recorder/wasm_test.wasm")); // "<path to test.wasm>: for now hardcoded TODO pass");
+                tracer.load_local_variables(address);
+            }
             // load debuginfo from gimli <- for this ip;
             // -> find out current scope and vars in it:
             //   some kind of mapping between them and locations

crates/wasmi/src/engine/executor/mod.rs

@@ -41,13 +41,14 @@ impl EngineInner {
         func: &Func,
         params: impl CallParams,
         results: Results,
+        tracing: bool,
     ) -> Result<<Results as CallResults>::Results, Error>
     where
         Results: CallResults,
     {
         let mut stack = self.stacks.lock().reuse_or_new();
         let results = EngineExecutor::new(&self.code_map, &mut stack)
-            .execute_root_func(ctx.store, func, params, results)
+            .execute_root_func(ctx.store, func, params, results, tracing)
             .map_err(|error| match error.into_resumable() {
                 Ok(error) => error.into_error(),
                 Err(error) => error,
@@ -69,14 +70,15 @@ impl EngineInner {
         func: &Func,
         params: impl CallParams,
         results: Results,
+        tracing: bool,
     ) -> Result<ResumableCallBase<<Results as CallResults>::Results>, Error>
     where
         Results: CallResults,
     {
         let store = ctx.store;
         let mut stack = self.stacks.lock().reuse_or_new();
         let results = EngineExecutor::new(&self.code_map, &mut stack)
-            .execute_root_func(store, func, params, results);
+            .execute_root_func(store, func, params, results, tracing);
         match results {
             Ok(results) => {
                 self.stacks.lock().recycle(stack);
@@ -117,6 +119,7 @@ impl EngineInner {
         mut invocation: ResumableInvocation,
         params: impl CallParams,
         results: Results,
+        tracing: bool,
     ) -> Result<ResumableCallBase<<Results as CallResults>::Results>, Error>
     where
         Results: CallResults,
@@ -129,6 +132,7 @@ impl EngineInner {
             params,
             caller_results,
             results,
+            tracing,
         );
         match results {
             Ok(results) => {
@@ -185,6 +189,7 @@ impl<'engine> EngineExecutor<'engine> {
         func: &Func,
         params: impl CallParams,
         results: Results,
+        tracing: bool,
     ) -> Result<<Results as CallResults>::Results, Error>
     where
         Results: CallResults,
@@ -217,7 +222,7 @@ impl<'engine> EngineExecutor<'engine> {
                     Some(instance),
                 )?;
                 store.invoke_call_hook(CallHook::CallingWasm)?;
-                self.execute_func(store)?;
+                self.execute_func(store, tracing)?;
                 store.invoke_call_hook(CallHook::ReturningFromWasm)?;
             }
             FuncEntity::Host(host_func) => {
@@ -259,6 +264,7 @@ impl<'engine> EngineExecutor<'engine> {
         params: impl CallParams,
         caller_results: RegSpan,
         results: Results,
+        tracing: bool,
     ) -> Result<<Results as CallResults>::Results, Error>
     where
         Results: CallResults,
@@ -274,7 +280,7 @@ impl<'engine> EngineExecutor<'engine> {
         for (result, param) in caller_results.iter_sized(len_params).zip(call_params) {
             unsafe { caller_sp.set(result, param) };
         }
-        self.execute_func(store)?;
+        self.execute_func(store, tracing)?;
         let results = self.write_results_back(results);
         Ok(results)
     }
@@ -285,8 +291,8 @@ impl<'engine> EngineExecutor<'engine> {
     ///
     /// When encountering a Wasm or host trap during execution.
     #[inline(always)]
-    fn execute_func<T>(&mut self, store: &mut Store<T>) -> Result<(), Error> {
-        execute_instrs(store, self.stack, self.code_map)
+    fn execute_func<T>(&mut self, store: &mut Store<T>, tracing: bool) -> Result<(), Error> {
+        execute_instrs(store, self.stack, self.code_map, tracing)
     }
 
     /// Convenience forwarder to [`dispatch_host_func`].

crates/wasmi/src/engine/mod.rs

@@ -295,11 +295,12 @@ impl Engine {
         func: &Func,
         params: impl CallParams,
         results: Results,
+        tracing: bool,
     ) -> Result<<Results as CallResults>::Results, Error>
     where
         Results: CallResults,
     {
-        self.inner.execute_func(ctx, func, params, results)
+        self.inner.execute_func(ctx, func, params, results, tracing)
     }
 
     /// Executes the given [`Func`] resumably with parameters `params` and returns.
@@ -331,12 +332,13 @@ impl Engine {
         func: &Func,
         params: impl CallParams,
         results: Results,
+        tracing: bool,
     ) -> Result<ResumableCallBase<<Results as CallResults>::Results>, Error>
     where
         Results: CallResults,
     {
         self.inner
-            .execute_func_resumable(ctx, func, params, results)
+            .execute_func_resumable(ctx, func, params, results, tracing)
     }
 
     /// Resumes the given `invocation` given the `params`.
@@ -368,11 +370,12 @@ impl Engine {
         invocation: ResumableInvocation,
         params: impl CallParams,
         results: Results,
+        tracing: bool,
     ) -> Result<ResumableCallBase<<Results as CallResults>::Results>, Error>
     where
         Results: CallResults,
     {
-        self.inner.resume_func(ctx, invocation, params, results)
+        self.inner.resume_func(ctx, invocation, params, results, tracing)
     }
 
     /// Recycles the given [`Stack`] for reuse in the [`Engine`].

crates/wasmi/src/engine/resumable.rs

@@ -212,6 +212,7 @@ impl ResumableInvocation {
         mut ctx: impl AsContextMut<Data = T>,
         inputs: &[Val],
         outputs: &mut [Val],
+        tracing: bool,
     ) -> Result<ResumableCall, Error> {
         self.engine
             .resolve_func_type(self.host_func().ty_dedup(ctx.as_context()), |func_type| {
@@ -225,7 +226,7 @@ impl ResumableInvocation {
             })?;
         self.engine
             .clone()
-            .resume_func(ctx.as_context_mut(), self, inputs, outputs)
+            .resume_func(ctx.as_context_mut(), self, inputs, outputs, tracing)
             .map(ResumableCall::new)
     }
 }
@@ -288,6 +289,7 @@ impl<Results> TypedResumableInvocation<Results> {
         self,
         mut ctx: impl AsContextMut<Data = T>,
         inputs: &[Val],
+        tracing: bool,
     ) -> Result<TypedResumableCall<Results>, Error>
     where
         Results: WasmResults,
@@ -303,6 +305,7 @@ impl<Results> TypedResumableInvocation<Results> {
                 self.invocation,
                 inputs,
                 <CallResultsTuple<Results>>::default(),
+                tracing,
             )
             .map(TypedResumableCall::new)
     }

crates/wasmi/src/func/mod.rs

@@ -415,6 +415,7 @@ impl Func {
         mut ctx: impl AsContextMut<Data = T>,
         inputs: &[Val],
         outputs: &mut [Val],
+        tracing: bool,
     ) -> Result<(), Error> {
         self.verify_and_prepare_inputs_outputs(ctx.as_context(), inputs, outputs)?;
         // Note: Cloning an [`Engine`] is intentionally a cheap operation.
@@ -423,6 +424,7 @@ impl Func {
             self,
             inputs,
             outputs,
+            tracing,
         )?;
         Ok(())
     }
@@ -455,14 +457,15 @@ impl Func {
         mut ctx: impl AsContextMut<Data = T>,
         inputs: &[Val],
         outputs: &mut [Val],
+        tracing: bool,
     ) -> Result<ResumableCall, Error> {
         self.verify_and_prepare_inputs_outputs(ctx.as_context(), inputs, outputs)?;
         // Note: Cloning an [`Engine`] is intentionally a cheap operation.
         ctx.as_context()
             .store
             .engine()
             .clone()
-            .execute_func_resumable(ctx.as_context_mut(), self, inputs, outputs)
+            .execute_func_resumable(ctx.as_context_mut(), self, inputs, outputs, tracing)
             .map(ResumableCall::new)
     }