feat: try to add --trace arg, and pass tracer: &mut WasmTracer everywhere

initially was passing `tracing`, but this seems more flexible: to both hold our state
and our flag;
too many file changes?

Author: alehander92

Cargo.lock

@@ -17,6 +17,7 @@ links = "wasmi_c_api"
 [dependencies]
 wasmi = { workspace = true }
 wasmi_c_api_macros = { workspace = true }
+wasmi_tracer = { workspace = true }
 
 [lib]
 name = "wasmi_c_api"

crates/c_api/Cargo.toml

@@ -9,6 +9,7 @@ use crate::{
 use alloc::{boxed::Box, string::String, vec, vec::Vec};
 use core::{any::Any, ffi::c_void, hint, iter, ptr, str};
 use wasmi::{Error, Extern, Func, FuncRef, Val};
+use wasmi_tracer::WasmTracer;
 
 #[cfg(feature = "std")]
 use core::panic::AssertUnwindSafe;
@@ -210,7 +211,8 @@ 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)
+                let mut tracer = WasmTracer::no_tracing();
+                f.call(func.inner.store.context_mut(), wt_params, wt_results, &mut tracer)
             }))
         }
         #[cfg(not(feature = "std"))]

crates/c_api/src/func.rs

@@ -8,6 +8,7 @@ use crate::{
 };
 use alloc::boxed::Box;
 use wasmi::Instance;
+use wasmi_tracer::WasmTracer;
 
 /// A Wasm instance.
 ///
@@ -56,7 +57,8 @@ 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) {
+    let mut tracer = WasmTracer::no_tracing();
+    match Instance::new(store.inner.context_mut(), &wasm_module.inner, &imports, &mut tracer) {
         Ok(instance) => Some(Box::new(wasm_instance_t::new(
             store.inner.clone(),
             instance,

crates/c_api/src/instance.rs

@@ -16,6 +16,7 @@ exclude.workspace = true
 [dependencies]
 wasmi = { workspace = true, features = ["wat"] }
 wasmi_wasi = { workspace = true }
+wasmi_tracer = { workspace = true }
 anyhow = "1"
 clap = { version = "4", features = ["derive"] }
 

crates/cli/Cargo.toml

@@ -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/args.rs

@@ -2,6 +2,7 @@ use anyhow::{anyhow, Error};
 use std::{fs, path::Path};
 use wasmi::{CompilationMode, Config, ExternType, Func, FuncType, Instance, Module, Store};
 use wasmi_wasi::WasiCtx;
+use wasmi_tracer::WasmTracer;
 
 /// The [`Context`] for the Wasmi CLI application.
 ///
@@ -13,6 +14,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 +30,7 @@ impl Context {
         wasi_ctx: WasiCtx,
         fuel: Option<u64>,
         compilation_mode: CompilationMode,
+        tracer: &mut WasmTracer,
     ) -> Result<Self, Error> {
         let mut config = Config::default();
         if fuel.is_some() {
@@ -52,7 +56,7 @@ 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, tracer))
             .map_err(|error| anyhow!("failed to instantiate and start the Wasm module: {error}"))?;
         Ok(Self {
             module,

crates/cli/src/context.rs

@@ -7,6 +7,7 @@ use clap::Parser;
 use context::Context;
 use std::{path::Path, process};
 use wasmi::{Func, FuncType, Val};
+use wasmi_tracer::WasmTracer;
 
 mod args;
 mod context;
@@ -20,7 +21,9 @@ 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 wasm_file_full_path = std::fs::canonicalize(&wasm_file)?;
+    let mut tracer = WasmTracer::new(args.tracing(), &wasm_file_full_path);
+    let mut ctx = Context::new(wasm_file, wasi_ctx, args.fuel(), args.compilation_mode(), &mut tracer)?;
     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 +42,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, &mut tracer) {
         Ok(()) => {
             print_remaining_fuel(&args, &ctx);
             print_pretty_results(&func_results);

crates/cli/src/main.rs

@@ -25,6 +25,7 @@ impl DebugInfo {
 
 #[derive(Debug, Clone)]
 pub struct WasmTracer {
+    pub tracing: bool,
     debug_info: DebugInfo,
     // TODO: tracer: runtime_tracing.Tracer,
     // etc
@@ -33,12 +34,20 @@ pub struct WasmTracer {
 // just to make it build so we can branch-out
 
 impl WasmTracer {
-    pub fn new(wasm_exe_path: &Path) -> Self {
+    pub fn new(tracing: bool, wasm_exe_path: &Path) -> Self {
         WasmTracer {
+            tracing,
             debug_info: DebugInfo::new(wasm_exe_path),
         }
     }
 
+    pub fn no_tracing() -> Self {
+        WasmTracer {
+            tracing: false,
+            debug_info: DebugInfo::new(&Path::new("")),
+        }
+    }
+
     pub fn load_local_variables(&mut self, address: usize) { // -> ???
         println!("load_local_variables {address}");
         // e.g. here we might call something like

crates/tracer/src/lib.rs

@@ -27,6 +27,7 @@ pub struct Config {
     compilation_mode: CompilationMode,
     /// Enforced limits for Wasm module parsing and compilation.
     limits: EnforcedLimits,
+    // tracing: bool,
 }
 
 /// Type storing all kinds of fuel costs of instructions.