Generate rust bindings and test code

Author: sayantn

crates/intrinsic-test/src/arm/mod.rs

@@ -13,16 +13,11 @@ use json_parser::get_neon_intrinsics;
 
 pub struct ArmArchitectureTest {
     intrinsics: Vec<Intrinsic<ArmIntrinsicType>>,
-    cli_options: ProcessedCli,
 }
 
 impl SupportedArchitectureTest for ArmArchitectureTest {
     type IntrinsicImpl = ArmIntrinsicType;
 
-    fn cli_options(&self) -> &ProcessedCli {
-        &self.cli_options
-    }
-
     fn intrinsics(&self) -> &[Intrinsic<ArmIntrinsicType>] {
         &self.intrinsics
     }
@@ -34,6 +29,10 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
     const PLATFORM_RUST_DEFINITIONS: &str = config::PLATFORM_RUST_DEFINITIONS;
     const PLATFORM_RUST_CFGS: &str = config::PLATFORM_RUST_CFGS;
 
+    fn arch_flags(&self) -> Vec<&str> {
+        vec!["-march=armv8.6a+crypto+crc+dotprod+fp16"]
+    }
+
     fn create(cli_options: ProcessedCli) -> Self {
         let a32 = cli_options.target.starts_with("armv7");
         let mut intrinsics = get_neon_intrinsics(&cli_options.filename, &cli_options.target)
@@ -60,9 +59,6 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             .take(sample_size)
             .collect::<Vec<_>>();
 
-        Self {
-            intrinsics,
-            cli_options,
-        }
+        Self { intrinsics }
     }
 }

crates/intrinsic-test/src/arm/types.rs

@@ -6,8 +6,8 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
     fn c_type(&self) -> String {
         let prefix = self.kind.c_prefix();
 
-        if let (Some(bit_len), simd_len, vec_len) = (self.bit_len, self.simd_len, self.vec_len) {
-            match (simd_len, vec_len) {
+        if let Some(bit_len) = self.bit_len {
+            match (self.simd_len, self.vec_len) {
                 (None, None) => format!("{prefix}{bit_len}_t"),
                 (Some(simd), None) => format!("{prefix}{bit_len}x{simd}_t"),
                 (Some(simd), Some(vec)) => format!("{prefix}{bit_len}x{simd}x{vec}_t"),
@@ -18,6 +18,22 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
         }
     }
 
+    fn rust_type(&self) -> String {
+        let rust_prefix = self.kind.rust_prefix();
+        let c_prefix = self.kind.c_prefix();
+
+        if let Some(bit_len) = self.bit_len {
+            match (self.simd_len, self.vec_len) {
+                (None, None) => format!("{rust_prefix}{bit_len}"),
+                (Some(simd), None) => format!("{c_prefix}{bit_len}x{simd}_t"),
+                (Some(simd), Some(vec)) => format!("{c_prefix}{bit_len}x{simd}x{vec}_t"),
+                (None, Some(_)) => todo!("{self:#?}"), // Likely an invalid case
+            }
+        } else {
+            todo!("{self:#?}")
+        }
+    }
+
     /// Determines the load function for this type.
     fn get_load_function(&self) -> String {
         if let IntrinsicType {

crates/intrinsic-test/src/common/argument.rs

@@ -94,6 +94,15 @@ where
             .to_string()
     }
 
+    pub fn as_non_imm_arglist_rust(&self) -> String {
+        self.iter()
+            .filter(|arg| !arg.has_constraint())
+            .format_with(", ", |arg, fmt| {
+                fmt(&format_args!("{}: {}", arg.name, arg.ty.rust_type()))
+            })
+            .to_string()
+    }
+
     pub fn as_call_params_c(&self, imm_args: &[i64]) -> String {
         let mut imm_args = imm_args.iter();
         self.iter()
@@ -113,7 +122,6 @@ where
         self.iter()
             .filter(|a| !a.has_constraint())
             .map(|arg| arg.generate_name() + " as _")
-            .collect::<Vec<String>>()
             .join(", ")
     }
 

crates/intrinsic-test/src/common/gen_c.rs

@@ -1,56 +1,9 @@
 use itertools::Itertools;
 
-use crate::common::constraint::Constraint;
 use crate::common::intrinsic::Intrinsic;
 
 use super::intrinsic_helpers::IntrinsicTypeDefinition;
 
-fn generate_c_wrapper<'a, T: IntrinsicTypeDefinition + 'a>(
-    w: &mut impl std::io::Write,
-    intrinsic: &Intrinsic<T>,
-    constraints: &mut (impl Iterator<Item = &'a Constraint> + Clone),
-    imm_values: &mut Vec<i64>,
-) -> std::io::Result<()> {
-    if let Some(current) = constraints.next() {
-        for i in current.iter() {
-            imm_values.push(i);
-            generate_c_wrapper(w, intrinsic, &mut constraints.clone(), imm_values)?;
-            imm_values.pop();
-        }
-    } else {
-        writeln!(
-            w,
-            "
-{return_ty} {name}_wrapper{imm_arglist}({arglist}) {{
-    return {name}({params});
-}}",
-            return_ty = intrinsic.results.c_type(),
-            name = intrinsic.name,
-            imm_arglist = imm_values
-                .iter()
-                .format_with("", |i, fmt| fmt(&format_args!("_{i}"))),
-            arglist = intrinsic.arguments.as_non_imm_arglist_c(),
-            params = intrinsic.arguments.as_call_params_c(&imm_values)
-        )?;
-    }
-    Ok(())
-}
-
-fn create_c_wrapper<T: IntrinsicTypeDefinition>(
-    w: &mut impl std::io::Write,
-    intrinsic: &Intrinsic<T>,
-) -> std::io::Result<()> {
-    generate_c_wrapper(
-        w,
-        intrinsic,
-        &mut intrinsic
-            .arguments
-            .iter()
-            .filter_map(|arg| arg.constraint.as_ref()),
-        &mut Vec::new(),
-    )
-}
-
 pub fn write_wrapper_c<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
     notice: &str,
@@ -59,12 +12,30 @@ pub fn write_wrapper_c<T: IntrinsicTypeDefinition>(
 ) -> std::io::Result<()> {
     write!(w, "{notice}")?;
 
+    writeln!(w, "#include <stdint.h>")?;
+    writeln!(w, "#include <stddef.h>")?;
+
     for header in platform_headers {
         writeln!(w, "#include <{header}>")?;
     }
 
     for intrinsic in intrinsics {
-        create_c_wrapper(w, intrinsic)?;
+        intrinsic.iter_specializations(|imm_values| {
+            writeln!(
+                w,
+                "
+{return_ty} {name}_wrapper{imm_arglist}({arglist}) {{
+    return {name}({params});
+}}",
+                return_ty = intrinsic.results.c_type(),
+                name = intrinsic.name,
+                imm_arglist = imm_values
+                    .iter()
+                    .format_with("", |i, fmt| fmt(&format_args!("_{i}"))),
+                arglist = intrinsic.arguments.as_non_imm_arglist_c(),
+                params = intrinsic.arguments.as_call_params_c(&imm_values)
+            )
+        })?;
     }
 
     Ok(())