feature: convert add felt intrinsic to use stub library instead of WIT interface

Author: greenhat

frontend/wasm/src/module/linker_stubs.rs

@@ -16,10 +16,10 @@ use midenc_hir::{
 use wasmparser::{FunctionBody, Operator};
 
 use crate::{
-    intrinsics::Intrinsic,
+    intrinsics::{convert_intrinsics_call, Intrinsic},
     miden_abi::{
         is_miden_abi_module, miden_abi_function_type,
-        transform::{no_transform, transform_miden_abi_call},
+        transform::transform_miden_abi_call,
     },
     module::{
         function_builder_ext::{FunctionBuilderContext, FunctionBuilderExt, SSABuilderListener},
@@ -81,16 +81,19 @@ pub fn maybe_lower_linker_stub(
         return Ok(false);
     }
 
-    // MASM callee function type
-    let import_sig = if is_intrinsic {
-        // For intrinsics, use the same signature as the stub function
-        function_ref.borrow().signature().clone()
-    } else {
-        let import_ft: FunctionType = miden_abi_function_type(&import_path);
-        Signature::new(
-            import_ft.params.into_iter().map(AbiParam::new),
-            import_ft.results.into_iter().map(AbiParam::new),
-        )
+    // Classify intrinsics and obtain signature when needed
+    let (import_sig, intrinsic): (Signature, Option<Intrinsic>) = match Intrinsic::try_from(&import_path) {
+        Ok(intr) => (function_ref.borrow().signature().clone(), Some(intr)),
+        Err(_) => {
+            let import_ft: FunctionType = miden_abi_function_type(&import_path);
+            (
+                Signature::new(
+                    import_ft.params.into_iter().map(AbiParam::new),
+                    import_ft.results.into_iter().map(AbiParam::new),
+                ),
+                None,
+            )
+        }
     };
 
     // Build the function body for the stub and replace it with an exec to MASM
@@ -112,18 +115,40 @@ pub fn maybe_lower_linker_stub(
         .collect();
 
     // Declare MASM import callee in world and exec via TransformStrategy
-    let import_module_ref = module_state
-        .world_builder
-        .declare_module_tree(&import_path.without_leaf())
-        .wrap_err("failed to create module for MASM imports")?;
-    let mut import_module_builder = ModuleBuilder::new(import_module_ref);
-    let import_func_ref = import_module_builder
-        .define_function(import_path.name().into(), import_sig)
-        .expect("failed to create MASM import function ref");
-
-    let results = if is_intrinsic {
-        no_transform(import_func_ref, &args, &mut fb)
+    let results: Vec<ValueRef> = if let Some(intr) = intrinsic {
+        // Decide whether the intrinsic is implemented as a function or an operation
+        let conv = intr
+            .conversion_result()
+            .expect("unknown intrinsic");
+        if conv.is_function() {
+            // Declare callee and call via convert_intrinsics_call with function_ref
+            let import_module_ref = module_state
+                .world_builder
+                .declare_module_tree(&import_path.without_leaf())
+                .wrap_err("failed to create module for intrinsics imports")?;
+            let mut import_module_builder = ModuleBuilder::new(import_module_ref);
+            let intrinsic_func_ref = import_module_builder
+                .define_function(import_path.name().into(), import_sig.clone())
+                .expect("failed to create intrinsic function ref");
+            convert_intrinsics_call(intr, Some(intrinsic_func_ref), &args, &mut fb, span)
+                .expect("convert_intrinsics_call failed")
+                .to_vec()
+        } else {
+            // Inline conversion of intrinsic operation
+            convert_intrinsics_call(intr, None, &args, &mut fb, span)
+                .expect("convert_intrinsics_call failed")
+                .to_vec()
+        }
     } else {
+        // Miden ABI path: exec import with TransformStrategy
+        let import_module_ref = module_state
+            .world_builder
+            .declare_module_tree(&import_path.without_leaf())
+            .wrap_err("failed to create module for MASM imports")?;
+        let mut import_module_builder = ModuleBuilder::new(import_module_ref);
+        let import_func_ref = import_module_builder
+            .define_function(import_path.name().into(), import_sig)
+            .expect("failed to create MASM import function ref");
         transform_miden_abi_call(import_func_ref, &import_path, &args, &mut fb)
     };
 

sdk/stdlib-sys/src/intrinsics/felt.rs

@@ -10,9 +10,7 @@ extern "C" {
 
     #[link_name = "as-u64"]
     fn extern_as_u64(felt: Felt) -> u64;
-
-    #[link_name = "add"]
-    fn extern_add(a: Felt, b: Felt) -> Felt;
+    // add moved to stub; see separate extern block below
 
     #[link_name = "sub"]
     fn extern_sub(a: Felt, b: Felt) -> Felt;
@@ -63,6 +61,12 @@ extern "C" {
     fn extern_assert_eq(a: Felt, b: Felt);
 }
 
+// Resolve add via linker stub rather than WIT import
+extern "C" {
+    #[link_name = "intrinsics::felt::add"]
+    fn extern_add(a: Felt, b: Felt) -> Felt;
+}
+
 /// Creates a `Felt` from an integer constant checking that it is within the
 /// valid range at compile time.
 #[macro_export]

sdk/stdlib-sys/wit/miden-core-intrinsics.wit

@@ -18,7 +18,8 @@ interface intrinsics-felt {
     as-u64: func(a: f32) -> u64;
 
     // Arithmetic operations
-    add: func(a: f32, b: f32) -> f32;
+    // add moved to linker stub
+    // add: func(a: f32, b: f32) -> f32;
     sub: func(a: f32, b: f32) -> f32;
     mul: func(a: f32, b: f32) -> f32;
     div: func(a: f32, b: f32) -> f32;

tests/integration/expected/add_felt.hir

@@ -2,10 +2,16 @@ builtin.component root_ns:[email protected] {
     builtin.module public @add_felt {
         public builtin.function @entrypoint(v0: felt, v1: felt) -> felt {
         ^block4(v0: felt, v1: felt):
-            v3 = arith.add v0, v1 : felt #[overflow = unchecked];
+            v3 = hir.exec @root_ns:[email protected]/add_felt/intrinsics::felt::add(v0, v1) : felt
             builtin.ret v3;
         };
 
+        private builtin.function @intrinsics::felt::add(v4: felt, v5: felt) -> felt {
+        ^block6(v4: felt, v5: felt):
+            v6 = arith.add v4, v5 : felt #[overflow = unchecked];
+            builtin.ret v6;
+        };
+
         builtin.global_variable private @#__stack_pointer : i32 {
             builtin.ret_imm 1048576;
         };

tests/integration/expected/add_felt.masm

@@ -13,6 +13,14 @@ end
 # mod root_ns:[email protected]::add_felt
 
 export.entrypoint
+    trace.240
+    nop
+    exec.::root_ns:[email protected]::add_felt::intrinsics::felt::add
+    trace.252
+    nop
+end
+
+proc.intrinsics::felt::add
     add
 end
 

tests/integration/expected/add_felt.wat

@@ -1,14 +1,16 @@
 (module $add_felt.wasm
   (type (;0;) (func (param f32 f32) (result f32)))
-  (import "miden:core-intrinsics/[email protected]" "add" (func $miden_stdlib_sys::intrinsics::felt::extern_add (;0;) (type 0)))
   (table (;0;) 1 1 funcref)
   (memory (;0;) 16)
   (global $__stack_pointer (;0;) (mut i32) i32.const 1048576)
   (export "memory" (memory 0))
   (export "entrypoint" (func $entrypoint))
-  (func $entrypoint (;1;) (type 0) (param f32 f32) (result f32)
+  (func $entrypoint (;0;) (type 0) (param f32 f32) (result f32)
     local.get 0
     local.get 1
-    call $miden_stdlib_sys::intrinsics::felt::extern_add
+    call $intrinsics::felt::add
+  )
+  (func $intrinsics::felt::add (;1;) (type 0) (param f32 f32) (result f32)
+    unreachable
   )
 )