feat: add env var-based trace options: looks simpler than adding cli params

we need to pass cli params through many layers/calls: done in another branch
and too big patch; also we can just keep tracer local, instead of passing it everywhere

Author: alehander92

crates/tracer/src/lib.rs

@@ -1,10 +1,6 @@
 use std::path::{Path, PathBuf};
 use std::println;
 
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
-}
-
 // TODO
 #[derive(Debug, Clone)]
 struct DebugInfo {
@@ -25,20 +21,30 @@ impl DebugInfo {
 
 #[derive(Debug, Clone)]
 pub struct WasmTracer {
+    pub tracing: bool,
     debug_info: DebugInfo,
+    info: Vec<String>,
+    index: usize,
     // TODO: tracer: runtime_tracing.Tracer,
     // etc
 }
 
 // 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),
+            info: vec![],
+            index: 0,
         }
     }
 
+    pub fn no_tracing() -> Self {
+        Self::new(false, &Path::new(""))
+    }
+
     pub fn load_local_variables(&mut self, address: usize) { // -> ???
         println!("load_local_variables {address}");
         // e.g. here we might call something like
@@ -49,7 +55,10 @@ impl WasmTracer {
         if !cached {
             // TODO etc
             // load debuginfo etc
+            self.info.push(format!("{}", self.index));
+            self.index += 1;
         }
+        println!("{:?}", self.info);
     }
 }
 
@@ -68,7 +77,5 @@ mod tests {
 
     #[test]
     fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
     }
 }

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

@@ -129,24 +129,29 @@ impl<'engine> Executor<'engine> {
     #[inline(always)]
     fn execute<T>(mut self, store: &mut Store<T>) -> Result<(), Error> {
         use Instruction as Instr;
+        let tracing = std::env::var("CODETRACER_WASMI_TRACING").unwrap_or(std::string::String::from("")) == "1";
+        let env_wasm_path = std::env::var("CODETRACER_WASM_PATH").unwrap_or(std::string::String::from(""));
+        let wasm_path = std::path::Path::new(&env_wasm_path);
+        let mut tracer = WasmTracer::new(tracing, &wasm_path);
         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 tracer.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
+                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
-            // -> load them with some general(for us) mechanism from wasmi's memory(?)
-            // e.g. load_expression(expr, location, ..) -> ValueRecord
-            // (to be iterated on, just an idea)
-            match *self.ip.get() {
+                // load debuginfo from gimli <- for this ip;
+                // -> find out current scope and vars in it:
+                //   some kind of mapping between them and locations
+                // -> load them with some general(for us) mechanism from wasmi's memory(?)
+                // e.g. load_expression(expr, location, ..) -> ValueRecord
+                // (to be iterated on, just an idea)
+            }
+                match *self.ip.get() {
                 Instr::Trap { trap_code } => self.execute_trap(trap_code)?,
                 Instr::ConsumeFuel { block_fuel } => {
                     self.execute_consume_fuel(&mut store.inner, block_fuel)?