Add some features to enable implementing an opcode category monitor (#…

…196) * Add some features to enable implementing an opcode category monitor * Remove rust exp file, until we need it * fmt/clippy
ejrgilbert · Feb 21, 2025 · cb769de · cb769de
1 parent 7875ecd
commit cb769de
Show file tree

Hide file tree

Showing 19 changed files with 565 additions and 349 deletions.
diff --git a/src/emitter/rewriting/rules/wasm.rs b/src/emitter/rewriting/rules/wasm.rs
@@ -82,7 +82,7 @@ pub struct OpcodeEvent {
     probes: HashMap<WhammModeKind, Vec<SimpleProbe>>,
 }
 macro_rules! define_opcode_event {
-($($op:ident, $name:ident, $num_args:expr, $imms:expr, $globals:expr, $fns:expr, $supported_modes:expr, $req_map:expr, $docs:expr)*) => {
+($($op:ident, $category:expr, $name:ident, $num_args:expr, $imms:expr, $globals:expr, $fns:expr, $supported_modes:expr, $req_map:expr, $docs:expr)*) => {
 impl FromStr for OpcodeEvent {
     fn from_str(name: &str) -> Self {
         match name {
@@ -533,6 +533,13 @@ impl OpcodeEvent {
 impl Event for OpcodeEvent {
     fn get_loc_info(&self, app_wasm: &Module, instr: &Operator) -> Option<LocInfo> {
         let mut loc_info = LocInfo::new();
+        // define the opcode category
+        loc_info.static_data.insert(
+            "category".to_string(),
+            Some(Value::Str {
+                val: self.kind.category().to_string(),
+            }),
+        );
 
         match self.kind {
             OpcodeEventKind::Unreachable { .. } => {

diff --git a/src/generator/mod.rs b/src/generator/mod.rs
@@ -4,6 +4,7 @@ use crate::parser::types::{
     BinOp, Block, DataType, Definition, Expr, Fn, Global, ProvidedFunction, Script, Statement,
     UnOp, Value, Whamm, WhammVisitorMut,
 };
+use crate::verifier::types::Record;
 use log::{debug, trace, warn};
 use orca_wasm::ir::id::FunctionID;
 use std::collections::HashMap;
@@ -47,6 +48,7 @@ pub trait GeneratingVisitor: WhammVisitorMut<bool> {
     fn enter_named_scope(&mut self, name: &str);
     fn enter_scope(&mut self);
     fn exit_scope(&mut self);
+    fn lookup_var_mut(&mut self, name: &str) -> Option<&mut Record>;
     fn visit_stmts(&mut self, stmts: &mut [Statement]) -> bool {
         let mut is_success = true;
         stmts.iter_mut().for_each(|stmt| {
@@ -391,9 +393,41 @@ impl<T: GeneratingVisitor> WhammVisitorMut<bool> for T {
                 is_success
             }
             Expr::Primitive { val, .. } => self.visit_value(val),
-            Expr::VarId { .. } => {
-                // ignore, will not have a string to emit
-                true
+            Expr::VarId {
+                definition, name, ..
+            } => {
+                if matches!(definition, Definition::CompilerStatic) {
+                    // (Hacky to fix the borrow issues with rust)
+                    let mut val = {
+                        if let Some(Record::Var {
+                            value: Some(val), ..
+                        }) = self.lookup_var_mut(name)
+                        {
+                            val.clone()
+                        } else {
+                            // ignore, nothing to emit here
+                            return true;
+                        }
+                    };
+
+                    if let Value::Str { .. } = val {
+                        self.emit_string(&mut val);
+                    }
+
+                    // look back up to overwrite the value!
+                    let Some(Record::Var {
+                        value: Some(old_val),
+                        ..
+                    }) = self.lookup_var_mut(name)
+                    else {
+                        panic!("Unable to find the definition for a static compiler variable!")
+                    };
+                    *old_val = val;
+                    true
+                } else {
+                    // ignore, will not have a string to emit
+                    true
+                }
             }
             Expr::MapGet { map, key, .. } => {
                 let mut is_success = true;

diff --git a/src/generator/rewriting/init_generator.rs b/src/generator/rewriting/init_generator.rs
@@ -7,6 +7,7 @@ use crate::emitter::module_emitter::ModuleEmitter;
 use crate::generator::GeneratingVisitor;
 use crate::lang_features::report_vars::LocationData;
 use crate::parser::types::{DataType, Fn, Value, Whamm, WhammVisitorMut};
+use crate::verifier::types::Record;
 use orca_wasm::ir::id::FunctionID;
 
 /// Serves as the first phase of instrumenting a module by setting up
@@ -86,4 +87,7 @@ impl GeneratingVisitor for InitGenerator<'_, '_, '_, '_, '_, '_, '_, '_, '_> {
     fn exit_scope(&mut self) {
         self.emitter.exit_scope(self.err);
     }
+    fn lookup_var_mut(&mut self, name: &str) -> Option<&mut Record> {
+        self.emitter.table.lookup_var_mut(name, &None, self.err)
+    }
 }
diff --git a/src/generator/wizard/mod.rs b/src/generator/wizard/mod.rs
@@ -369,4 +369,7 @@ impl GeneratingVisitor for WizardGenerator<'_, '_, '_, '_, '_, '_, '_, '_, '_, '
     fn exit_scope(&mut self) {
         self.emitter.exit_scope(self.err);
     }
+    fn lookup_var_mut(&mut self, name: &str) -> Option<&mut Record> {
+        self.emitter.table.lookup_var_mut(name, &None, self.err)
+    }
 }
diff --git a/src/lang_features/libraries/core/maps/map_adapter.rs b/src/lang_features/libraries/core/maps/map_adapter.rs
@@ -90,10 +90,12 @@ impl MapLibAdapter {
             // insert map
             ("insert_i32_i32".to_string(), 0),
             ("insert_i32_string".to_string(), 0),
+            ("insert_string_i32".to_string(), 0),
             ("insert_i32i32i32tuple_i32".to_string(), 0),
             // get from map
             ("get_i32_i32".to_string(), 0),
             ("get_i32_string".to_string(), 0),
+            ("get_string_i32".to_string(), 0),
             ("get_i32i32i32tuple_i32".to_string(), 0),
             // printing maps
             ("print_map".to_string(), 0),
@@ -287,7 +289,7 @@ impl MapLibAdapter {
             err.type_check_error(
                 true,
                 format!(
-                    "MapLibAdapter.map_create_fname: Unsupported map type: {:?} -> {:?}",
+                    "MapLibAdapter.map_create_fname: Unsupported map type: {:?} -> {:?}, need function with name '{fname}'",
                     key, val
                 ),
                 &None,
@@ -306,7 +308,7 @@ impl MapLibAdapter {
             err.type_check_error(
                 true,
                 format!(
-                    "MapLibAdapter.map_insert_fname: Unsupported map type: {:?} -> {:?}",
+                    "MapLibAdapter.map_insert_fname: Unsupported map type: {:?} -> {:?}, need function with name '{fname}'",
                     key, val
                 ),
                 &None,
@@ -325,7 +327,7 @@ impl MapLibAdapter {
             err.type_check_error(
                 true,
                 format!(
-                    "MapLibAdapter.map_get_fname: Unsupported map type: {:?} -> {:?}",
+                    "MapLibAdapter.map_get_fname: Unsupported map type: {:?} -> {:?}, need function with name '{fname}'",
                     key, val
                 ),
                 &None,