feat: initial global support

Signed-off-by: Henry Gressmann <mail@henrygressmann.de>

Author: explodingcamera

crates/tinywasm/src/instance.rs

@@ -76,6 +76,10 @@ impl ModuleInstance {
         &self.0.func_addrs
     }
 
+    pub(crate) fn global_addrs(&self) -> &[GlobalAddr] {
+        &self.0.global_addrs
+    }
+
     pub(crate) fn func_ty_addrs(&self) -> &[FuncType] {
         &self.0.types
     }
@@ -93,6 +97,11 @@ impl ModuleInstance {
         self.0.func_addrs[addr as usize]
     }
 
+    // resolve a global address to the global store address
+    pub(crate) fn resolve_global_addr(&self, addr: GlobalAddr) -> GlobalAddr {
+        self.0.global_addrs[addr as usize]
+    }
+
     /// Get an exported function by name
     pub fn exported_func_by_name(&self, store: &Store, name: &str) -> Result<FuncHandle> {
         if self.0.store_id != store.id() {

crates/tinywasm/src/runtime/executor/mod.rs

@@ -75,19 +75,6 @@ enum ExecResult {
     Trap(crate::Trap),
 }
 
-/// Execute a const instruction
-pub(crate) fn exec_const(instr: ConstInstruction) -> RawWasmValue {
-    match instr {
-        ConstInstruction::F32Const(val) => val.into(),
-        ConstInstruction::F64Const(val) => val.into(),
-        ConstInstruction::I32Const(val) => val.into(),
-        ConstInstruction::I64Const(val) => val.into(),
-        ConstInstruction::GlobalGet(_) => unimplemented!("global get"),
-        ConstInstruction::RefFunc(_) => unimplemented!("ref func"),
-        ConstInstruction::RefNull(_) => unimplemented!("ref null"),
-    }
-}
-
 /// Run a single step of the interpreter
 /// A seperate function is used so later, we can more easily implement
 /// a step-by-step debugger (using generators once they're stable?)
@@ -269,6 +256,17 @@ fn exec_one(
         LocalSet(local_index) => cf.set_local(*local_index as usize, stack.values.pop()?),
         LocalTee(local_index) => cf.set_local(*local_index as usize, *stack.values.last()?),
 
+        GlobalGet(global_index) => {
+            let idx = module.resolve_global_addr(*global_index);
+            let global = store.get_global_val(idx as usize)?;
+            stack.values.push(global);
+        }
+
+        GlobalSet(global_index) => {
+            let idx = module.resolve_global_addr(*global_index);
+            store.set_global_val(idx as usize, stack.values.pop()?)?;
+        }
+
         I32Const(val) => stack.values.push((*val).into()),
         I64Const(val) => stack.values.push((*val).into()),
         F32Const(val) => stack.values.push((*val).into()),

crates/tinywasm/src/runtime/value.rs

@@ -1,6 +1,6 @@
 use core::fmt::Debug;
 
-use tinywasm_types::{ValType, WasmValue};
+use tinywasm_types::{ConstInstruction, ValType, WasmValue};
 
 /// A raw wasm value.
 ///

crates/tinywasm/src/store.rs

@@ -1,4 +1,7 @@
-use core::sync::atomic::{AtomicUsize, Ordering};
+use core::{
+    cell::RefCell,
+    sync::atomic::{AtomicUsize, Ordering},
+};
 
 use alloc::{format, rc::Rc, vec::Vec};
 use tinywasm_types::{
@@ -8,7 +11,7 @@ use tinywasm_types::{
 
 use crate::{
     runtime::{self, DefaultRuntime},
-    Error, ModuleInstance, Result,
+    Error, ModuleInstance, RawWasmValue, Result,
 };
 
 // global store id counter
@@ -82,7 +85,7 @@ pub(crate) struct StoreData {
     pub(crate) funcs: Vec<Rc<FunctionInstance>>,
     pub(crate) tables: Vec<TableInstance>,
     pub(crate) mems: Vec<Rc<MemoryInstance>>,
-    pub(crate) globals: Vec<Rc<GlobalInstance>>,
+    pub(crate) globals: Vec<Rc<RefCell<GlobalInstance>>>,
     pub(crate) elems: Vec<ElemInstance>,
     pub(crate) datas: Vec<DataInstance>,
 }
@@ -143,8 +146,26 @@ impl Store {
         let mut global_addrs = Vec::with_capacity(global_count);
         for (i, global) in globals.into_iter().enumerate() {
             // TODO: initialize globals
-            // Don't fail here yet - we'll fail when we try to use the global
-            self.data.globals.push(Rc::new(GlobalInstance::new(global.ty, 0, idx)));
+            use tinywasm_types::ConstInstruction::*;
+            let val = match global.init {
+                F32Const(f) => RawWasmValue::from(f),
+                F64Const(f) => RawWasmValue::from(f),
+                I32Const(i) => RawWasmValue::from(i),
+                I64Const(i) => RawWasmValue::from(i),
+                GlobalGet(addr) => {
+                    let addr = global_addrs[addr as usize];
+                    let global = self.data.globals[addr as usize].clone();
+                    let val = global.borrow().value;
+                    val
+                }
+                RefNull(_) => RawWasmValue::default(),
+                RefFunc(idx) => RawWasmValue::from(idx as i64),
+            };
+
+            self.data
+                .globals
+                .push(Rc::new(RefCell::new(GlobalInstance::new(global.ty, val, idx))));
+
             global_addrs.push((i + global_count) as Addr);
         }
         global_addrs
@@ -179,6 +200,22 @@ impl Store {
             .get(addr)
             .ok_or_else(|| Error::Other(format!("function {} not found", addr)))
     }
+
+    pub(crate) fn get_global_val(&self, addr: usize) -> Result<RawWasmValue> {
+        self.data
+            .globals
+            .get(addr)
+            .ok_or_else(|| Error::Other(format!("global {} not found", addr)))
+            .map(|global| global.borrow().value)
+    }
+
+    pub(crate) fn set_global_val(&mut self, addr: usize, value: RawWasmValue) -> Result<()> {
+        self.data
+            .globals
+            .get(addr)
+            .ok_or_else(|| Error::Other(format!("global {} not found", addr)))
+            .map(|global| global.borrow_mut().value = value)
+    }
 }
 
 #[derive(Debug)]
@@ -254,12 +291,12 @@ impl MemoryInstance {
 #[derive(Debug)]
 pub(crate) struct GlobalInstance {
     pub(crate) ty: GlobalType,
-    pub(crate) value: Addr,
+    pub(crate) value: RawWasmValue,
     owner: ModuleInstanceAddr, // index into store.module_instances
 }
 
 impl GlobalInstance {
-    pub(crate) fn new(ty: GlobalType, value: Addr, owner: ModuleInstanceAddr) -> Self {
+    pub(crate) fn new(ty: GlobalType, value: RawWasmValue, owner: ModuleInstanceAddr) -> Self {
         Self { ty, value, owner }
     }
 }