feature: convert all intrinsics::felt to use .rlib stub library

instead of WIT interface

Author: greenhat

frontend/wasm/src/module/linker_stubs.rs

@@ -18,8 +18,7 @@ use wasmparser::{FunctionBody, Operator};
 use crate::{
     intrinsics::{convert_intrinsics_call, Intrinsic},
     miden_abi::{
-        is_miden_abi_module, miden_abi_function_type,
-        transform::transform_miden_abi_call,
+        is_miden_abi_module, miden_abi_function_type, transform::transform_miden_abi_call,
     },
     module::{
         function_builder_ext::{FunctionBuilderContext, FunctionBuilderExt, SSABuilderListener},
@@ -70,6 +69,7 @@ pub fn maybe_lower_linker_stub(
         let borrowed = function_ref.borrow();
         borrowed.name().as_str().to_string()
     };
+    // Expect stub export names to be fully-qualified MASM paths already (e.g. "intrinsics::felt::add").
     let func_ident = match midenc_hir::FunctionIdent::from_str(&name_string) {
         Ok(id) => id,
         Err(_) => return Ok(false),
@@ -82,19 +82,20 @@ pub fn maybe_lower_linker_stub(
     }
 
     // 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,
-            )
-        }
-    };
+    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
     let span = function_ref.borrow().name().span;
@@ -117,9 +118,7 @@ pub fn maybe_lower_linker_stub(
     // Declare MASM import callee in world and exec via TransformStrategy
     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");
+        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

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

@@ -1,68 +1,63 @@
 use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
-#[link(wasm_import_module = "miden:core-intrinsics/[email protected]")]
 extern "C" {
-    #[link_name = "from-u64-unchecked"]
+    #[link_name = "intrinsics::felt::from_u64_unchecked"]
     fn extern_from_u64_unchecked(value: u64) -> Felt;
 
-    #[link_name = "from-u32"]
+    #[link_name = "intrinsics::felt::from_u32"]
     fn extern_from_u32(value: u32) -> Felt;
 
-    #[link_name = "as-u64"]
+    #[link_name = "intrinsics::felt::as_u64"]
     fn extern_as_u64(felt: Felt) -> u64;
-    // add moved to stub; see separate extern block below
 
-    #[link_name = "sub"]
+    #[link_name = "intrinsics::felt::sub"]
     fn extern_sub(a: Felt, b: Felt) -> Felt;
 
-    #[link_name = "mul"]
+    #[link_name = "intrinsics::felt::mul"]
     fn extern_mul(a: Felt, b: Felt) -> Felt;
 
-    #[link_name = "div"]
+    #[link_name = "intrinsics::felt::div"]
     fn extern_div(a: Felt, b: Felt) -> Felt;
 
-    #[link_name = "neg"]
+    #[link_name = "intrinsics::felt::neg"]
     fn extern_neg(a: Felt) -> Felt;
 
-    #[link_name = "inv"]
+    #[link_name = "intrinsics::felt::inv"]
     fn extern_inv(a: Felt) -> Felt;
 
-    #[link_name = "pow2"]
+    #[link_name = "intrinsics::felt::pow2"]
     fn extern_pow2(a: Felt) -> Felt;
 
-    #[link_name = "exp"]
+    #[link_name = "intrinsics::felt::exp"]
     fn extern_exp(a: Felt, b: Felt) -> Felt;
 
-    #[link_name = "eq"]
+    #[link_name = "intrinsics::felt::eq"]
     fn extern_eq(a: Felt, b: Felt) -> i32;
 
-    #[link_name = "gt"]
+    #[link_name = "intrinsics::felt::gt"]
     fn extern_gt(a: Felt, b: Felt) -> i32;
 
-    #[link_name = "lt"]
+    #[link_name = "intrinsics::felt::lt"]
     fn extern_lt(a: Felt, b: Felt) -> i32;
 
-    #[link_name = "ge"]
+    #[link_name = "intrinsics::felt::ge"]
     fn extern_ge(a: Felt, b: Felt) -> i32;
 
-    #[link_name = "le"]
+    #[link_name = "intrinsics::felt::le"]
     fn extern_le(a: Felt, b: Felt) -> i32;
 
-    #[link_name = "is-odd"]
+    #[link_name = "intrinsics::felt::is_odd"]
     fn extern_is_odd(a: Felt) -> i32;
 
-    #[link_name = "assert"]
+    #[link_name = "intrinsics::felt::assert"]
     fn extern_assert(a: Felt);
 
-    #[link_name = "assertz"]
+    #[link_name = "intrinsics::felt::assertz"]
     fn extern_assertz(a: Felt);
 
-    #[link_name = "assert-eq"]
+    #[link_name = "intrinsics::felt::assert_eq"]
     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;
 }

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

@@ -8,39 +8,39 @@ interface intrinsics-mem {
     heap-base: func() -> s32;
 }
 
-interface intrinsics-felt {
+// interface intrinsics-felt {
 
     // See sdk/stdlib-sys/src/intrinsics/felt.rs for `extern` function signatures
 
     // Conversion operations
-    from-u64-unchecked: func(a: u64) -> f32;
-    from-u32: func(a: u32) -> f32;
-    as-u64: func(a: f32) -> u64;
+    // from-u64-unchecked: func(a: u64) -> f32;
+    // from-u32: func(a: u32) -> f32;
+    // as-u64: func(a: f32) -> u64;
 
     // Arithmetic operations
     // 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;
-    neg: func(a: f32) -> f32;
-    inv: func(a: f32) -> f32;
-    pow2: func(a: f32) -> f32;
-    exp: 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;
+    // neg: func(a: f32) -> f32;
+    // inv: func(a: f32) -> f32;
+    // pow2: func(a: f32) -> f32;
+    // exp: func(a: f32, b: f32) -> f32;
 
     // Comparison operations
-    eq: func(a: f32, b: f32) -> s32;
-    gt: func(a: f32, b: f32) -> s32;
-    lt: func(a: f32, b: f32) -> s32;
-    ge: func(a: f32, b: f32) -> s32;
-    le: func(a: f32, b: f32) -> s32;
-    is-odd: func(a: f32) -> s32;
+    // eq: func(a: f32, b: f32) -> s32;
+    // gt: func(a: f32, b: f32) -> s32;
+    // lt: func(a: f32, b: f32) -> s32;
+    // ge: func(a: f32, b: f32) -> s32;
+    // le: func(a: f32, b: f32) -> s32;
+    // is-odd: func(a: f32) -> s32;
 
     // Assertion operations
-    assert: func(a: f32);
-    assertz: func(a: f32);
-    assert-eq: func(a: f32, b: f32);
-}
+    // assert: func(a: f32);
+    // assertz: func(a: f32);
+    // assert-eq: func(a: f32, b: f32);
+// }
 
 interface intrinsics-debug {
 
@@ -66,7 +66,7 @@ interface intrinsics-advice {
 
 world intrinsics {
     import intrinsics-mem;
-    import intrinsics-felt;
+    // import intrinsics-felt;
     import intrinsics-debug;
     import intrinsics-crypto;
     import intrinsics-advice;