intrinsic-test: Adding x86 behavioural testing.

ci/run.sh

@@ -91,6 +91,9 @@ fi
 # Test targets compiled with extra features.
 case ${TARGET} in
     x86_64-unknown-linux-gnu)
+        TEST_CPPFLAGS="-fuse-ld=lld -I/usr/include/x86_64-linux-gnu/"
+        TEST_CXX_COMPILER="clang++-19"
+        TEST_RUNNER="${CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER}"
         export STDARCH_DISABLE_ASSERT_INSTR=1
 
         export RUSTFLAGS="${RUSTFLAGS} -C target-feature=+avx"
@@ -181,6 +184,16 @@ case "${TARGET}" in
             --linker "${CARGO_TARGET_AARCH64_BE_UNKNOWN_LINUX_GNU_LINKER}" \
             --cxx-toolchain-dir "${AARCH64_BE_TOOLCHAIN}"
         ;;
+
+    x86_64-unknown-linux-gnu*)
+        CPPFLAGS="${TEST_CPPFLAGS}" RUSTFLAGS="${HOST_RUSTFLAGS}" RUST_LOG=warn \
+            CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="true" \
+            cargo run "${INTRINSIC_TEST}" "${PROFILE}"  \
+            --bin intrinsic-test -- intrinsics_data/x86-intel.xml \
+            --runner "${TEST_RUNNER}" \
+            --cppcompiler "${TEST_CXX_COMPILER}" \
+            --target "${TARGET}"
+        ;;
      *)
         ;;
 esac

crates/intrinsic-test/Cargo.toml

@@ -19,3 +19,6 @@ pretty_env_logger = "0.5.0"
 rayon = "1.5.0"
 diff = "0.1.12"
 itertools = "0.14.0"
+quick-xml = { version = "0.37.5", features = ["serialize", "overlapped-lists"] }
+serde-xml-rs = "0.8.0"
+regex = "1.11.1"

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

@@ -31,7 +31,17 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
 
     const NOTICE: &str = config::NOTICE;
 
-    const PLATFORM_C_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
+    const PLATFORM_C_HEADERS: &[&str] = &[
+        "iostream",
+        "cstring",
+        "iomanip",
+        "sstream",
+        "cstddef",
+        "cstdint",
+        "arm_neon.h",
+        "arm_acle.h",
+        "arm_fp16.h",
+    ];
     const PLATFORM_C_DEFINITIONS: &str = config::POLY128_OSTREAM_DEF;
     const PLATFORM_C_FORWARD_DECLARATIONS: &str = config::POLY128_OSTREAM_DECL;
 

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

@@ -108,7 +108,7 @@ where
         for arg in self.iter().filter(|&arg| !arg.has_constraint()) {
             writeln!(
                 w,
-                "{indentation}const {ty} {name}_vals[] = {values};",
+                "{indentation}alignas(64) const {ty} {name}_vals[] = {values};",
                 ty = arg.ty.c_scalar_type(),
                 name = arg.name,
                 values = arg.ty.populate_random(indentation, loads, &Language::C)

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

@@ -47,7 +47,7 @@ pub fn generate_c_constraint_blocks<'a, T: IntrinsicTypeDefinition + 'a>(
         let ty = current.ty.c_type();
 
         writeln!(w, "{indentation}{{")?;
-        writeln!(w, "{body_indentation}{ty} {} = {i};", current.name)?;
+        writeln!(w, "{body_indentation}const {ty} {} = {i};", current.name)?;
 
         generate_c_constraint_blocks(
             w,
@@ -103,14 +103,11 @@ pub fn write_mod_cpp<T: IntrinsicTypeDefinition>(
         writeln!(w, "#include <{header}>")?;
     }
 
+    writeln!(w, "{}", forward_declarations)?;
+
     writeln!(
         w,
         r#"
-#include <iostream>
-#include <cstring>
-#include <iomanip>
-#include <sstream>
-
 template<typename T1, typename T2> T1 cast(T2 x) {{
   static_assert(sizeof(T1) == sizeof(T2), "sizeof T1 and T2 must be the same");
   T1 ret{{}};
@@ -120,13 +117,9 @@ template<typename T1, typename T2> T1 cast(T2 x) {{
 
 std::ostream& operator<<(std::ostream& os, float16_t value);
 
-
-
 "#
     )?;
 
-    writeln!(w, "{}", forward_declarations)?;
-
     for intrinsic in intrinsics {
         create_c_test_function(w, intrinsic)?;
     }
@@ -137,12 +130,13 @@ std::ostream& operator<<(std::ostream& os, float16_t value);
 pub fn write_main_cpp<'a>(
     w: &mut impl std::io::Write,
     arch_specific_definitions: &str,
+    arch_specific_headers: &[&str],
     intrinsics: impl Iterator<Item = &'a str> + Clone,
 ) -> std::io::Result<()> {
     writeln!(w, "#include <iostream>")?;
     writeln!(w, "#include <string>")?;
 
-    for header in ["arm_neon.h", "arm_acle.h", "arm_fp16.h"] {
+    for header in arch_specific_headers {
         writeln!(w, "#include <{header}>")?;
     }
 

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

@@ -190,7 +190,7 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
     intrinsic: &Intrinsic<T>,
     indentation: Indentation,
-    specializations: &[Vec<u8>],
+    specializations: &[Vec<i64>],
     passes: u32,
 ) -> std::io::Result<()> {
     let intrinsic_name = &intrinsic.name;
@@ -255,15 +255,15 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
 /// Generate the specializations (unique sequences of const-generic arguments) for this intrinsic.
 fn generate_rust_specializations<'a>(
     constraints: &mut impl Iterator<Item = impl Iterator<Item = i64>>,
-) -> Vec<Vec<u8>> {
+) -> Vec<Vec<i64>> {
     let mut specializations = vec![vec![]];
 
     for constraint in constraints {
         specializations = constraint
             .flat_map(|right| {
                 specializations.iter().map(move |left| {
                     let mut left = left.clone();
-                    left.push(u8::try_from(right).unwrap());
+                    left.push(i64::try_from(right).unwrap());
                     left
                 })
             })

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

@@ -75,8 +75,10 @@ impl TypeKind {
             Self::Float => "float",
             Self::Int(Sign::Signed) => "int",
             Self::Int(Sign::Unsigned) => "uint",
+            Self::Mask => "uint",
             Self::Poly => "poly",
             Self::Char(Sign::Signed) => "char",
+            Self::Vector => "int",
             _ => unreachable!("Not used: {:#?}", self),
         }
     }
@@ -131,7 +133,7 @@ impl IntrinsicType {
         if let Some(bl) = self.bit_len {
             bl
         } else {
-            unreachable!("")
+            unreachable!("{:#?}", self)
         }
     }
 
@@ -154,6 +156,7 @@ impl IntrinsicType {
     pub fn c_scalar_type(&self) -> String {
         match self.kind() {
             TypeKind::Char(_) => String::from("char"),
+            TypeKind::Vector => String::from("int32_t"),
             _ => format!(
                 "{prefix}{bits}_t",
                 prefix = self.kind().c_prefix(),
@@ -162,14 +165,6 @@ impl IntrinsicType {
         }
     }
 
-    pub fn rust_scalar_type(&self) -> String {
-        format!(
-            "{prefix}{bits}",
-            prefix = self.kind().rust_prefix(),
-            bits = self.inner_size()
-        )
-    }
-
     pub fn c_promotion(&self) -> &str {
         match *self {
             IntrinsicType {
@@ -222,7 +217,8 @@ impl IntrinsicType {
         match self {
             IntrinsicType {
                 bit_len: Some(bit_len @ (8 | 16 | 32 | 64)),
-                kind: kind @ (TypeKind::Int(_) | TypeKind::Poly | TypeKind::Char(_)),
+                kind:
+                    kind @ (TypeKind::Int(_) | TypeKind::Poly | TypeKind::Char(_) | TypeKind::Mask),
                 simd_len,
                 vec_len,
                 ..
@@ -283,6 +279,29 @@ impl IntrinsicType {
                         )))
                 )
             }
+            IntrinsicType {
+                kind: TypeKind::Vector,
+                bit_len: Some(bit_len @ (128 | 256 | 512)),
+                simd_len,
+                ..
+            } => {
+                let (prefix, suffix) = match language {
+                    Language::Rust => ("[", "]"),
+                    Language::C => ("{", "}"),
+                };
+                let body_indentation = indentation.nested();
+                let effective_bit_len = 32;
+                let effective_vec_len = bit_len / effective_bit_len;
+                format!(
+                    "{prefix}\n{body}\n{indentation}{suffix}",
+                    body = (0..(simd_len.unwrap_or(1) * effective_vec_len + loads - 1))
+                        .format_with(",\n", |i, fmt| {
+                            let src = value_for_array(effective_bit_len, i);
+                            assert!(src == 0 || src.ilog2() < *bit_len);
+                            fmt(&format_args!("{body_indentation}{src:#x}"))
+                        })
+                )
+            }
             _ => unimplemented!("populate random: {:#?}", self),
         }
     }
@@ -298,7 +317,7 @@ impl IntrinsicType {
                 kind: TypeKind::Int(_) | TypeKind::Poly,
                 ..
             } => true,
-            _ => unimplemented!(),
+            _ => true,
         }
     }
 
@@ -330,4 +349,13 @@ pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
     /// 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.
     fn print_result_c(&self, indentation: Indentation, additional: &str) -> String;
+
+    /// To enable architecture-specific logic
+    fn rust_scalar_type(&self) -> String {
+        format!(
+            "{prefix}{bits}",
+            prefix = self.kind().rust_prefix(),
+            bits = self.inner_size()
+        )
+    }
 }

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

@@ -1,4 +1,5 @@
 use std::fs::File;
+use std::io::{self, Write};
 
 use rayon::prelude::*;
 
@@ -76,6 +77,14 @@ pub trait SupportedArchitectureTest {
                 if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
                     let output = cpp_compiler
                         .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
+                    if !output.status.success() {
+                        io::stdout()
+                            .write_all(&output.stdout)
+                            .expect("Failed to write to stdout!");
+                        io::stderr()
+                            .write_all(&output.stderr)
+                            .expect("Failed to write to stderr!");
+                    }
                     assert!(output.status.success(), "{output:?}");
                 }
 
@@ -88,6 +97,7 @@ pub trait SupportedArchitectureTest {
         write_main_cpp(
             &mut file,
             Self::PLATFORM_C_DEFINITIONS,
+            Self::PLATFORM_C_HEADERS,
             self.intrinsics().iter().map(|i| i.name.as_str()),
         )
         .unwrap();

crates/intrinsic-test/src/main.rs

@@ -3,10 +3,12 @@ extern crate log;
 
 mod arm;
 mod common;
+mod x86;
 
 use arm::ArmArchitectureTest;
 use common::SupportedArchitectureTest;
 use common::cli::{Cli, ProcessedCli};
+use x86::X86ArchitectureTest;
 
 fn main() {
     pretty_env_logger::init();
@@ -18,6 +20,7 @@ fn main() {
         | "armv7-unknown-linux-gnueabihf"
         | "aarch64_be-unknown-linux-gnu" => run(ArmArchitectureTest::create(processed_cli_options)),
 
+        "x86_64-unknown-linux-gnu" => run(X86ArchitectureTest::create(processed_cli_options)),
         _ => std::process::exit(0),
     }
 }