Re-organize intrinsic-test to enable seamless addition of behaviour testing for more architectures

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

@@ -0,0 +1,64 @@
+use crate::common::compile_c::CompilationCommandBuilder;
+use crate::common::gen_c::compile_c;
+
+pub fn compile_c_arm(
+    intrinsics_name_list: &Vec<String>,
+    compiler: &str,
+    target: &str,
+    cxx_toolchain_dir: Option<&str>,
+) -> bool {
+    // -ffp-contract=off emulates Rust's approach of not fusing separate mul-add operations
+    let mut command = CompilationCommandBuilder::new()
+        .add_arch_flags(vec!["armv8.6-a", "crypto", "crc", "dotprod", "fp16"])
+        .set_compiler(compiler)
+        .set_target(target)
+        .set_opt_level("2")
+        .set_cxx_toolchain_dir(cxx_toolchain_dir)
+        .set_project_root("c_programs")
+        .add_extra_flags(vec!["-ffp-contract=off", "-Wno-narrowing"]);
+
+    if !target.contains("v7") {
+        command = command.add_arch_flags(vec!["faminmax", "lut", "sha3"]);
+    }
+
+    /*
+     * clang++ cannot link an aarch64_be object file, so we invoke
+     * aarch64_be-unknown-linux-gnu's C++ linker. This ensures that we
+     * are testing the intrinsics against LLVM.
+     *
+     * Note: setting `--sysroot=<...>` which is the obvious thing to do
+     * does not work as it gets caught up with `#include_next <stdlib.h>`
+     * not existing...
+     */
+    if target.contains("aarch64_be") {
+        command = command
+            .set_linker(
+                cxx_toolchain_dir.unwrap_or("").to_string() + "/bin/aarch64_be-none-linux-gnu-g++",
+            )
+            .set_include_paths(vec![
+                "/include",
+                "/aarch64_be-none-linux-gnu/include",
+                "/aarch64_be-none-linux-gnu/include/c++/14.2.1",
+                "/aarch64_be-none-linux-gnu/include/c++/14.2.1/aarch64_be-none-linux-gnu",
+                "/aarch64_be-none-linux-gnu/include/c++/14.2.1/backward",
+                "/aarch64_be-none-linux-gnu/libc/usr/include",
+            ]);
+    }
+
+    if !compiler.contains("clang") {
+        command = command.add_extra_flag("-flax-vector-conversions");
+    }
+
+    let compiler_commands = intrinsics_name_list
+        .iter()
+        .map(|intrinsic_name| {
+            command
+                .clone()
+                .set_input_name(intrinsic_name)
+                .set_output_name(intrinsic_name)
+                .to_string()
+        })
+        .collect::<Vec<_>>();
+
+    compile_c(&compiler_commands)
+}

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

@@ -0,0 +1,122 @@
+pub fn build_notices(line_prefix: &str) -> String {
+    format!(
+        "\
+{line_prefix}This is a transient test file, not intended for distribution. Some aspects of the
+{line_prefix}test are derived from a JSON specification, published under the same license as the
+{line_prefix}`intrinsic-test` crate.\n
+"
+    )
+}
+
+pub const POLY128_OSTREAM_DEF: &str = r#"std::ostream& operator<<(std::ostream& os, poly128_t value) {
+    std::stringstream temp;
+    do {
+      int n = value % 10;
+      value /= 10;
+      temp << n;
+    } while (value != 0);
+    std::string tempstr(temp.str());
+    std::string res(tempstr.rbegin(), tempstr.rend());
+    os << res;
+    return os;
+}"#;
+
+// Format f16 values (and vectors containing them) in a way that is consistent with C.
+pub const F16_FORMATTING_DEF: &str = r#"
+/// Used to continue `Debug`ging SIMD types as `MySimd(1, 2, 3, 4)`, as they
+/// were before moving to array-based simd.
+#[inline]
+fn debug_simd_finish<T: core::fmt::Debug, const N: usize>(
+    formatter: &mut core::fmt::Formatter<'_>,
+    type_name: &str,
+    array: &[T; N],
+) -> core::fmt::Result {
+    core::fmt::Formatter::debug_tuple_fields_finish(
+        formatter,
+        type_name,
+        &core::array::from_fn::<&dyn core::fmt::Debug, N, _>(|i| &array[i]),
+    )
+}
+
+#[repr(transparent)]
+struct Hex<T>(T);
+
+impl<T: DebugHexF16> core::fmt::Debug for Hex<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        <T as DebugHexF16>::fmt(&self.0, f)
+    }
+}
+
+fn debug_f16<T: DebugHexF16>(x: T) -> impl core::fmt::Debug {
+    Hex(x)
+}
+
+trait DebugHexF16 {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result;
+}
+
+impl DebugHexF16 for f16 {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#06x?}", self.to_bits())
+    }
+}
+
+impl DebugHexF16 for float16x4_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let array = unsafe { core::mem::transmute::<_, [Hex<f16>; 4]>(*self) };
+        debug_simd_finish(f, "float16x4_t", &array)
+    }
+}
+
+impl DebugHexF16 for float16x8_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let array = unsafe { core::mem::transmute::<_, [Hex<f16>; 8]>(*self) };
+        debug_simd_finish(f, "float16x8_t", &array)
+    }
+}
+
+impl DebugHexF16 for float16x4x2_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        debug_simd_finish(f, "float16x4x2_t", &[Hex(self.0), Hex(self.1)])
+    }
+}
+impl DebugHexF16 for float16x4x3_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        debug_simd_finish(f, "float16x4x3_t", &[Hex(self.0), Hex(self.1), Hex(self.2)])
+    }
+}
+impl DebugHexF16 for float16x4x4_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        debug_simd_finish(f, "float16x4x4_t", &[Hex(self.0), Hex(self.1), Hex(self.2), Hex(self.3)])
+    }
+}
+
+impl DebugHexF16 for float16x8x2_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        debug_simd_finish(f, "float16x8x2_t", &[Hex(self.0), Hex(self.1)])
+    }
+}
+impl DebugHexF16 for float16x8x3_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        debug_simd_finish(f, "float16x8x3_t", &[Hex(self.0), Hex(self.1), Hex(self.2)])
+    }
+}
+impl DebugHexF16 for float16x8x4_t {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        debug_simd_finish(f, "float16x8x4_t", &[Hex(self.0), Hex(self.1), Hex(self.2), Hex(self.3)])
+    }
+}
+ "#;
+
+pub const AARCH_CONFIGURATIONS: &str = r#"
+#![cfg_attr(target_arch = "arm", feature(stdarch_arm_neon_intrinsics))]
+#![cfg_attr(target_arch = "arm", feature(stdarch_aarch32_crc32))]
+#![cfg_attr(any(target_arch = "aarch64", target_arch = "arm64ec"), feature(stdarch_neon_fcma))]
+#![cfg_attr(any(target_arch = "aarch64", target_arch = "arm64ec"), feature(stdarch_neon_dotprod))]
+#![cfg_attr(any(target_arch = "aarch64", target_arch = "arm64ec"), feature(stdarch_neon_i8mm))]
+#![cfg_attr(any(target_arch = "aarch64", target_arch = "arm64ec"), feature(stdarch_neon_sha3))]
+#![cfg_attr(any(target_arch = "aarch64", target_arch = "arm64ec"), feature(stdarch_neon_sm4))]
+#![cfg_attr(any(target_arch = "aarch64", target_arch = "arm64ec"), feature(stdarch_neon_ftts))]
+#![feature(fmt_helpers_for_derive)]
+#![feature(stdarch_neon_f16)]
+"#;

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

@@ -1,41 +1,43 @@
-use crate::format::Indentation;
-use crate::types::{IntrinsicType, TypeKind};
+use crate::base_intrinsictype_trait_def_macro;
+use crate::common::argument::ArgumentList;
+use crate::common::cli::Language;
+use crate::common::indentation::Indentation;
+use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
+use crate::common::intrinsic_helpers::{
+    BaseIntrinsicTypeDefinition, IntrinsicTypeDefinition, TypeKind,
+};
 
-use super::argument::ArgumentList;
+base_intrinsictype_trait_def_macro! {ArmIntrinsicType}
 
-/// An intrinsic
-#[derive(Debug, PartialEq, Clone)]
-pub struct Intrinsic {
-    /// The function name of this intrinsic.
-    pub name: String,
-
-    /// Any arguments for this intrinsic.
-    pub arguments: ArgumentList,
+impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
+    fn arguments(&self) -> ArgumentList<ArmIntrinsicType> {
+        self.arguments.clone()
+    }
 
-    /// The return type of this intrinsic.
-    pub results: IntrinsicType,
+    fn results(&self) -> ArmIntrinsicType {
+        self.results.clone()
+    }
 
-    /// Whether this intrinsic is only available on A64.
-    pub a64_only: bool,
-}
+    fn name(&self) -> String {
+        self.name.clone()
+    }
 
-impl Intrinsic {
     /// Generates a std::cout for the intrinsics results that will match the
     /// rust debug output format for the return type. The generated line assumes
     /// there is an int i in scope which is the current pass number.
-    pub fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
-        let lanes = if self.results.num_vectors() > 1 {
-            (0..self.results.num_vectors())
+    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
+        let lanes = if self.results().num_vectors() > 1 {
+            (0..self.results().num_vectors())
                 .map(|vector| {
                     format!(
                         r#""{ty}(" << {lanes} << ")""#,
-                        ty = self.results.c_single_vector_type(),
-                        lanes = (0..self.results.num_lanes())
+                        ty = self.results().c_single_vector_type(),
+                        lanes = (0..self.results().num_lanes())
                             .map(move |idx| -> std::string::String {
                                 format!(
                                     "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
-                                    cast = self.results.c_promotion(),
-                                    lane_fn = self.results.get_lane_function(),
+                                    cast = self.results().c_promotion(),
+                                    lane_fn = self.results().get_lane_function(),
                                     lane = idx,
                                     vector = vector,
                                 )
@@ -46,13 +48,13 @@ impl Intrinsic {
                 })
                 .collect::<Vec<_>>()
                 .join(r#" << ", " << "#)
-        } else if self.results.num_lanes() > 1 {
-            (0..self.results.num_lanes())
+        } else if self.results().num_lanes() > 1 {
+            (0..self.results().num_lanes())
                 .map(|idx| -> std::string::String {
                     format!(
                         "{cast}{lane_fn}(__return_value, {lane})",
-                        cast = self.results.c_promotion(),
-                        lane_fn = self.results.get_lane_function(),
+                        cast = self.results().c_promotion(),
+                        lane_fn = self.results().get_lane_function(),
                         lane = idx
                     )
                 })
@@ -62,37 +64,35 @@ impl Intrinsic {
             format!(
                 "{promote}cast<{cast}>(__return_value)",
                 cast = match self.results.kind() {
-                    TypeKind::Float if self.results.inner_size() == 16 => "float16_t".to_string(),
-                    TypeKind::Float if self.results.inner_size() == 32 => "float".to_string(),
-                    TypeKind::Float if self.results.inner_size() == 64 => "double".to_string(),
-                    TypeKind::Int => format!("int{}_t", self.results.inner_size()),
-                    TypeKind::UInt => format!("uint{}_t", self.results.inner_size()),
-                    TypeKind::Poly => format!("poly{}_t", self.results.inner_size()),
+                    TypeKind::Float if self.results().inner_size() == 16 => "float16_t".to_string(),
+                    TypeKind::Float if self.results().inner_size() == 32 => "float".to_string(),
+                    TypeKind::Float if self.results().inner_size() == 64 => "double".to_string(),
+                    TypeKind::Int => format!("int{}_t", self.results().inner_size()),
+                    TypeKind::UInt => format!("uint{}_t", self.results().inner_size()),
+                    TypeKind::Poly => format!("poly{}_t", self.results().inner_size()),
                     ty => todo!("print_result_c - Unknown type: {:#?}", ty),
                 },
-                promote = self.results.c_promotion(),
+                promote = self.results().c_promotion(),
             )
         };
 
         format!(
             r#"{indentation}std::cout << "Result {additional}-" << i+1 << ": {ty}" << std::fixed << std::setprecision(150) <<  {lanes} << "{close}" << std::endl;"#,
-            ty = if self.results.is_simd() {
-                format!("{}(", self.results.c_type())
+            ty = if self.results().is_simd() {
+                format!("{}(", self.results().c_type())
             } else {
                 String::from("")
             },
             close = if self.results.is_simd() { ")" } else { "" },
-            lanes = lanes,
-            additional = additional,
         )
     }
 
-    pub fn generate_loop_c(
+    fn generate_loop_c(
         &self,
         indentation: Indentation,
         additional: &str,
         passes: u32,
-        target: &str,
+        _target: &str,
     ) -> String {
         let body_indentation = indentation.nested();
         format!(
@@ -101,14 +101,14 @@ impl Intrinsic {
                 {body_indentation}auto __return_value = {intrinsic_call}({args});\n\
                 {print_result}\n\
             {indentation}}}",
-            loaded_args = self.arguments.load_values_c(body_indentation, target),
+            loaded_args = self.arguments.load_values_c(body_indentation),
             intrinsic_call = self.name,
             args = self.arguments.as_call_param_c(),
             print_result = self.print_result_c(body_indentation, additional)
         )
     }
 
-    pub fn generate_loop_rust(
+    fn generate_loop_rust(
         &self,
         indentation: Indentation,
         additional: &str,
@@ -146,7 +146,6 @@ impl Intrinsic {
             intrinsic_call = self.name,
             const = constraints,
             args = self.arguments.as_call_param_rust(),
-            additional = additional,
         )
     }
 }