refactore: IR: removed global type

Author: Arnaud Riess

crates/herkos/src/codegen/constructor.rs

@@ -23,8 +23,7 @@ pub fn emit_const_globals<B: Backend>(_backend: &B, info: &ModuleInfo) -> String
     let mut code = String::new();
     for (idx, g) in info.globals.iter().enumerate() {
         if !g.mutable {
-            let (rust_ty, value_str) =
-                crate::codegen::types::global_init_to_rust(&g.init_value, &g.wasm_type);
+            let (rust_ty, value_str) = crate::codegen::types::global_init_to_rust(&g.init_value);
             code.push_str(&format!("pub const G{idx}: {rust_ty} = {value_str};\n"));
         }
     }
@@ -88,8 +87,7 @@ pub fn generate_constructor<B: Backend>(
                 if !first {
                     fields.push_str(", ");
                 }
-                let (_, value_str) =
-                    crate::codegen::types::global_init_to_rust(&g.init_value, &g.wasm_type);
+                let (_, value_str) = crate::codegen::types::global_init_to_rust(&g.init_value);
                 fields.push_str(&format!("g{idx}: {value_str}"));
                 first = false;
             }

crates/herkos/src/codegen/function.rs

@@ -116,7 +116,7 @@ pub fn generate_function_with_info<B: Backend>(
                         let local_idx = *index - info.imported_globals.len();
                         info.globals
                             .get(local_idx)
-                            .map(|g| g.wasm_type)
+                            .map(|g| g.init_value.ty())
                             .unwrap_or(WasmType::I32)
                     };
                     var_types.insert(*dest, ty);

crates/herkos/src/codegen/mod.rs

@@ -483,7 +483,6 @@ mod tests {
             table_max: 0,
             element_segments: Vec::new(),
             globals: vec![GlobalDef {
-                wasm_type: WasmType::I32,
                 mutable: true,
                 init_value: GlobalInit::I32(0),
             }],
@@ -616,7 +615,6 @@ mod tests {
             table_max: 0,
             element_segments: Vec::new(),
             globals: vec![GlobalDef {
-                wasm_type: WasmType::I32,
                 mutable: false,
                 init_value: GlobalInit::I32(42),
             }],

crates/herkos/src/codegen/module.rs

@@ -36,7 +36,7 @@ fn generate_wrapper_module<B: Backend>(backend: &B, info: &ModuleInfo) -> Result
         rust_code.push_str("pub struct Globals {\n");
         for (idx, g) in info.globals.iter().enumerate() {
             if g.mutable {
-                let rust_ty = crate::codegen::types::wasm_type_to_rust(&g.wasm_type);
+                let rust_ty = crate::codegen::types::wasm_type_to_rust(&g.init_value.ty());
                 rust_code.push_str(&format!("    pub g{idx}: {rust_ty},\n"));
             }
         }

crates/herkos/src/codegen/types.rs

@@ -25,8 +25,9 @@ pub fn format_return_type(ty: Option<&WasmType>) -> String {
 }
 
 /// Convert a GlobalInit to (Rust type string, value literal string).
-pub fn global_init_to_rust(init: &GlobalInit, ty: &WasmType) -> (&'static str, String) {
-    let rust_ty = wasm_type_to_rust(ty);
+pub fn global_init_to_rust(init: &GlobalInit) -> (&'static str, String) {
+    let ty = init.ty();
+    let rust_ty = wasm_type_to_rust(&ty);
     let value = match init {
         GlobalInit::I32(v) => format!("{v}i32"),
         GlobalInit::I64(v) => format!("{v}i64"),

crates/herkos/src/ir/builder/assembly.rs

@@ -55,15 +55,13 @@ fn build_globals(parsed: &ParsedModule) -> Vec<GlobalDef> {
         .globals
         .iter()
         .map(|g| {
-            let wasm_type = WasmType::from_wasmparser(g.val_type);
             let init_value = match g.init_value {
                 crate::parser::InitValue::I32(v) => GlobalInit::I32(v),
                 crate::parser::InitValue::I64(v) => GlobalInit::I64(v),
                 crate::parser::InitValue::F32(v) => GlobalInit::F32(v),
                 crate::parser::InitValue::F64(v) => GlobalInit::F64(v),
             };
             GlobalDef {
-                wasm_type,
                 mutable: g.mutable,
                 init_value,
             }

crates/herkos/src/ir/types.rs

@@ -654,11 +654,9 @@ impl fmt::Display for BinOp {
 /// Definition of a Wasm global variable.
 #[derive(Debug, Clone)]
 pub struct GlobalDef {
-    /// The Wasm value type of the global.
-    pub wasm_type: WasmType,
     /// Whether the global is mutable.
     pub mutable: bool,
-    /// The constant initializer value.
+    /// The constant initializer value (also encodes the type).
     pub init_value: GlobalInit,
 }
 
@@ -671,6 +669,18 @@ pub enum GlobalInit {
     F64(f64),
 }
 
+impl GlobalInit {
+    /// Get the WasmType of this global init value.
+    pub fn ty(&self) -> WasmType {
+        match self {
+            GlobalInit::I32(_) => WasmType::I32,
+            GlobalInit::I64(_) => WasmType::I64,
+            GlobalInit::F32(_) => WasmType::F32,
+            GlobalInit::F64(_) => WasmType::F64,
+        }
+    }
+}
+
 /// A data segment to initialize memory.
 #[derive(Debug, Clone)]
 pub struct DataSegmentDef {
@@ -1138,14 +1148,12 @@ mod tests {
         assert!(!info.has_mutable_globals());
 
         info.globals.push(GlobalDef {
-            wasm_type: WasmType::I32,
             mutable: false,
             init_value: GlobalInit::I32(0),
         });
         assert!(!info.has_mutable_globals());
 
         info.globals.push(GlobalDef {
-            wasm_type: WasmType::I32,
             mutable: true,
             init_value: GlobalInit::I32(0),
         });