fix: account for global offset in import calculations

Author: andreiltd

Cargo.toml

@@ -4,7 +4,7 @@ exclude = ["StarlingMonkey/crates/rust-url"]
 resolver = "2"
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 version = "0.1.0"
 
 [workspace.lints.clippy]

crates/spidermonkey-embedding-splicer/src/bindgen.rs

@@ -6,7 +6,7 @@ use heck::*;
 use js_component_bindgen::function_bindgen::{
     ErrHandling, FunctionBindgen, ResourceData, ResourceMap, ResourceTable,
 };
-use js_component_bindgen::intrinsics::{render_intrinsics, Intrinsic};
+use js_component_bindgen::intrinsics::{Intrinsic, render_intrinsics};
 use js_component_bindgen::names::LocalNames;
 use js_component_bindgen::source::Source;
 use wit_bindgen_core::abi::{self, LiftLower};
@@ -1238,9 +1238,15 @@ impl EsmBindgen {
                             "verifyInterfaceFn"
                         };
                         if let Some(alias) = self.export_aliases.get(export_name) {
-                            uwriteln!(bind_exports, "{verify_name}({local_name}, '{export_name}', '{external_name}', '{alias}');");
+                            uwriteln!(
+                                bind_exports,
+                                "{verify_name}({local_name}, '{export_name}', '{external_name}', '{alias}');"
+                            );
                         } else {
-                            uwriteln!(bind_exports, "{verify_name}({local_name}, '{export_name}', '{external_name}', null);");
+                            uwriteln!(
+                                bind_exports,
+                                "{verify_name}({local_name}, '{export_name}', '{external_name}', null);"
+                            );
                         };
                     }
                 }

crates/spidermonkey-embedding-splicer/src/lib.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use wit_parser::{PackageId, Resolve};
 
 pub mod bindgen;

crates/spidermonkey-embedding-splicer/src/splice.rs

@@ -6,14 +6,15 @@ use wasmparser::ExternalKind;
 use wasmparser::MemArg;
 use wasmparser::Operator;
 use wirm::ir::function::{FunctionBuilder, FunctionModifier};
-use wirm::ir::id::{ExportsID, FunctionID, LocalID};
+use wirm::ir::id::{ExportsID, FunctionID, GlobalID, LocalID};
 use wirm::ir::module::Module;
-use wirm::ir::types::{BlockType, ElementItems, InstrumentationMode};
+use wirm::ir::module::module_globals::GlobalKind;
+use wirm::ir::types::{BlockType, ElementItems, InitInstr, InstrumentationMode, Value};
 use wirm::module_builder::AddLocal;
 use wirm::opcode::{Inject, InjectAt};
 use wirm::{DataType, Opcode};
-use wit_component::metadata::{decode, Bindgen};
 use wit_component::StringEncoding;
+use wit_component::metadata::{Bindgen, decode};
 use wit_parser::Resolve;
 
 use crate::bindgen::BindingItem;
@@ -757,7 +758,27 @@ fn synthesize_import_functions(
             .get_fn_modifier(coreabi_get_import_fid)
             .unwrap();
 
-        // Find the I32Const base index and compute the delta to new base
+        // Save the idx parameter to local at the start of the function,
+        // so that orignal code does not oeverwrit it.
+        let idx_local = builder.add_local(DataType::I32);
+        builder.inject_at(
+            0,
+            InstrumentationMode::Before,
+            Operator::LocalGet {
+                local_index: *arg_idx,
+            },
+        );
+        builder.inject_at(
+            0,
+            InstrumentationMode::Before,
+            Operator::LocalSet {
+                local_index: *idx_local,
+            },
+        );
+
+        // Find the I32Const base index and compute the delta to new base.
+        // The codegen may split the base index into:
+        // `global.get N` + `i32.const X` where the global is a constant.
         let mut table_instr_idx = 0usize;
         let mut delta: i32 = 0;
         {
@@ -769,7 +790,20 @@ fn synthesize_import_functions(
                     if *value < 1000 || *value > 5000 {
                         continue;
                     }
-                    delta = import_fn_table_start_idx - *value;
+                    // Check if instruction just before is a global.get with a
+                    // constant value and if so, include the global's init value
+                    // in the base computation.
+                    let mut base = *value;
+                    if idx > 0
+                        && let Operator::GlobalGet { global_index } = &ops_ro[idx - 1]
+                        && let GlobalKind::Local(local_global) =
+                            module.globals.get_kind(GlobalID(*global_index))
+                        && let [InitInstr::Value(Value::I32(v))] =
+                            local_global.init_expr.instructions()
+                    {
+                        base += v;
+                    }
+                    delta = import_fn_table_start_idx - base;
                     table_instr_idx = idx;
                     break;
                 }
@@ -780,7 +814,7 @@ fn synthesize_import_functions(
             table_instr_idx,
             InstrumentationMode::Before,
             Operator::LocalGet {
-                local_index: *arg_idx,
+                local_index: *idx_local,
             },
         );
         builder.inject_at(

crates/spidermonkey-embedding-splicer/src/stub_wasi.rs

@@ -2,7 +2,7 @@ use std::collections::HashSet;
 use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use wasmparser::{MemArg, TypeRef};
 use wirm::ir::function::FunctionBuilder;
 use wirm::ir::id::{FunctionID, LocalID};

crates/spidermonkey-embedding-splicer/src/wit.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 
 wit_bindgen::generate!({
     world: "spidermonkey-embedding-splicer",