intrinsic-test: Support testing LoongArch64 SIMD intrinsics

.github/workflows/main.yml

@@ -279,6 +279,7 @@ jobs:
           - aarch64-unknown-linux-gnu
           - aarch64_be-unknown-linux-gnu
           - armv7-unknown-linux-gnueabihf
+          - loongarch64-unknown-linux-gnu
           - x86_64-unknown-linux-gnu
         profile: [dev, release]
         cc: [clang, gcc]

ci/docker/loongarch64-unknown-linux-gnu/Dockerfile

@@ -3,8 +3,15 @@ FROM ubuntu:25.10
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
     gcc libc6-dev qemu-user ca-certificates \
-    gcc-loongarch64-linux-gnu libc6-dev-loong64-cross
+    gcc-loongarch64-linux-gnu libc6-dev-loong64-cross \
+    wget
 
+RUN wget https://ci-mirrors.rust-lang.org/llvm/llvm-22.1.4-x86_64.tar.gz -O llvm.tar.xz
+RUN mkdir llvm
+RUN tar -xvf llvm.tar.xz --strip-components=1 -C llvm
+
+ENV CLANG_PATH="/llvm/bin/clang"
+ENV GCC_PATH=loongarch64-linux-gnu-gcc
 
 ENV CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNU_LINKER=loongarch64-linux-gnu-gcc \
     CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNU_RUNNER="qemu-loongarch64 -cpu max -L /usr/loongarch64-linux-gnu" \

ci/intrinsic-test.sh

@@ -65,6 +65,12 @@ case ${TARGET} in
         ARCH=x86
         RUNTIME_RUSTFLAGS=
         ;;
+
+    loongarch64*)
+        export CFLAGS="-I/usr/loongarch64-linux-gnu/include/"
+        ARCH=loongarch64
+        RUNTIME_RUSTFLAGS=-Ctarget-feature=+lsx,+lasx,+frecipe
+        ;;
     *)
         ;;
 
@@ -80,6 +86,14 @@ case "${TARGET}" in
             --target "${TARGET}" \
             --cc-arg-style "${CC_ARG_STYLE}"
         ;;
+    loongarch64*)
+        cargo run "${INTRINSIC_TEST}" --release \
+            --bin intrinsic-test -- crates/stdarch-gen-loongarch \
+            --skip "crates/intrinsic-test/missing_${ARCH}_common.txt" \
+            --skip "crates/intrinsic-test/missing_${ARCH}_${CC_KIND}.txt" \
+            --target "${TARGET}" \
+            --cc-arg-style "${CC_ARG_STYLE}"
+        ;;
     *)
         cargo run "${INTRINSIC_TEST}" --release \
             --bin intrinsic-test -- intrinsics_data/arm_intrinsics.json \

crates/intrinsic-test/missing_loongarch64_common.txt

@@ -0,0 +1,31 @@
+# Missing in old c compiler
+lasx_concat_128
+lasx_concat_128_d
+lasx_concat_128_s
+lasx_extract_128_hi
+lasx_extract_128_lo
+lasx_extract_128_hi_d
+lasx_extract_128_lo_d
+lasx_extract_128_hi_s
+lasx_extract_128_lo_s
+lasx_insert_128_hi
+lasx_insert_128_lo
+lasx_insert_128_hi_d
+lasx_insert_128_lo_d
+lasx_insert_128_hi_s
+lasx_insert_128_lo_s
+
+# Missing in old qemu
+lasx_xvfrecipe_d
+lasx_xvfrecipe_s
+lasx_xvfrsqrte_d
+lasx_xvfrsqrte_s
+lsx_vfrecipe_d
+lsx_vfrecipe_s
+lsx_vfrsqrte_d
+lsx_vfrsqrte_s
+
+# Top bits are undefined, unclear how to test these
+lasx_cast_128
+lasx_cast_128_d
+lasx_cast_128_s

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

@@ -37,6 +37,8 @@ impl SupportedArchitecture for Arm {
 "#;
     const RUST_PRELUDE: &str = RUST_PRELUDE;
 
+    const C_NAME_PREFIX: &str = "";
+
     fn c_compiler_flags(&self, cli_options: &ProcessedCli) -> Vec<&str> {
         // GCC uses an extra `-` in the arch name
         let big_endian = cli_options.target.starts_with("aarch64_be");

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

@@ -1,5 +1,6 @@
 use itertools::Itertools;
 
+use crate::common::imm_value_to_ident;
 use crate::common::{SupportedArchitecture, intrinsic::Intrinsic};
 
 use super::intrinsic_helpers::TypeDefinition;
@@ -37,13 +38,18 @@ pub fn write_wrapper_c<A: SupportedArchitecture>(
                     fmt(&format_args!(
                         "
 void {name}_wrapper{imm_arglist}({return_ty}* __dst{arglist}) {{
-    *__dst = {name}({params});
+    *__dst = {prefix}{name}({params});
 }}",
                         return_ty = intrinsic.results.c_type(),
+                        prefix = A::C_NAME_PREFIX,
                         name = intrinsic.name,
-                        imm_arglist = imm_values
-                            .iter()
-                            .format_with("", |i, fmt| fmt(&format_args!("_{i}"))),
+                        imm_arglist =
+                            imm_values
+                                .iter()
+                                .format_with("", |i, fmt| fmt(&format_args!(
+                                    "_{}",
+                                    imm_value_to_ident(i)
+                                ))),
                         arglist = intrinsic.arguments.as_non_imm_arglist_c(),
                         params = intrinsic.arguments.as_call_params_c(&imm_values)
                     ))

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

@@ -4,6 +4,7 @@ use itertools::Itertools;
 
 use super::intrinsic_helpers::TypeDefinition;
 use crate::common::cli::{CcArgStyle, ProcessedCli};
+use crate::common::imm_value_to_ident;
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::values::{test_values_array_name, test_values_array_static};
@@ -276,7 +277,7 @@ for (id, rust, c) in specializations {{
                                 }
                             })
                             .join(","),
-                        c_const_args = imm_values.iter().join("_"),
+                        c_const_args = imm_values.iter().map(imm_value_to_ident).join("_"),
                     ))
                 }
             }),
@@ -343,9 +344,13 @@ unsafe extern "C" {{
                         "fn {name}_wrapper{imm_arglist}(__dst: *mut {return_ty}{arglist});",
                         return_ty = intrinsic.results.rust_type(),
                         name = intrinsic.name,
-                        imm_arglist = imm_values
-                            .iter()
-                            .format_with("", |i, fmt| fmt(&format_args!("_{i}"))),
+                        imm_arglist =
+                            imm_values
+                                .iter()
+                                .format_with("", |i, fmt| fmt(&format_args!(
+                                    "_{}",
+                                    imm_value_to_ident(i)
+                                ))),
                         arglist = intrinsic.arguments.as_non_imm_arglist_rust(),
                     ))
                 }))

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

@@ -49,6 +49,10 @@ pub trait SupportedArchitecture: Sized {
     const C_PRELUDE: &str;
     const RUST_PRELUDE: &str;
 
+    /// Per-architecture prefix used to convert a Rust intrinsic name to the
+    /// corresponding C intrinsic name by prepending it to the Rust name.
+    const C_NAME_PREFIX: &str;
+
     fn c_compiler_flags(&self, cli_options: &ProcessedCli) -> Vec<&str>;
 
     fn generate_c_file(&self) {
@@ -138,3 +142,8 @@ pub fn manual_chunk(intrinsic_count: usize) -> (usize, usize) {
     let number_of_chunks = intrinsic_count.div_ceil(max_intrinsics_per_chunk);
     (max_intrinsics_per_chunk, number_of_chunks)
 }
+
+pub fn imm_value_to_ident(value: impl std::fmt::Display) -> String {
+    let value = value.to_string();
+    value.replace('-', "neg")
+}

crates/intrinsic-test/src/loongarch/intrinsic.rs

@@ -0,0 +1,19 @@
+use crate::common::intrinsic_helpers::IntrinsicType;
+use std::ops::{Deref, DerefMut};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct LoongArchType(pub IntrinsicType);
+
+impl Deref for LoongArchType {
+    type Target = IntrinsicType;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for LoongArchType {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

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

@@ -0,0 +1,139 @@
+mod intrinsic;
+mod parser;
+mod types;
+
+use std::path::Path;
+
+use crate::common::SupportedArchitecture;
+use crate::common::cli::ProcessedCli;
+use crate::common::intrinsic::Intrinsic;
+use crate::common::intrinsic_helpers::TypeKind;
+use intrinsic::LoongArchType;
+use parser::get_intrinsics;
+
+#[derive(PartialEq)]
+pub struct LoongArch {
+    intrinsics: Vec<Intrinsic<LoongArch>>,
+}
+
+impl SupportedArchitecture for LoongArch {
+    type Type = LoongArchType;
+
+    fn intrinsics(&self) -> &[Intrinsic<Self>] {
+        &self.intrinsics
+    }
+
+    const NOTICE: &str = r#"
+// This is a transient test file, not intended for distribution. Some aspects of the
+// test are derived from LoongArch specification files, published under the same license as the
+// `intrinsic-test` crate.
+"#;
+
+    const C_PRELUDE: &str = r#"
+#include <lsxintrin.h>
+#include <lasxintrin.h>
+"#;
+    const RUST_PRELUDE: &str = RUST_PRELUDE;
+
+    const C_NAME_PREFIX: &str = "__";
+
+    fn c_compiler_flags(&self, _cli_options: &ProcessedCli) -> Vec<&str> {
+        let mut flags = vec!["-mlsx"];
+        if self
+            .intrinsics
+            .iter()
+            .any(|intrinsic| intrinsic.extension == "LASX")
+        {
+            flags.push("-mlasx");
+        }
+        if self.intrinsics.iter().any(|intrinsic| {
+            intrinsic.name.contains("frecipe") || intrinsic.name.contains("frsqrte")
+        }) {
+            flags.push("-mfrecipe");
+        }
+        flags
+    }
+
+    fn create(cli_options: &ProcessedCli) -> Self {
+        let mut intrinsics =
+            load_intrinsics(&cli_options.filename).expect("Error parsing input file");
+
+        intrinsics.sort_by(|a, b| a.name.cmp(&b.name));
+        intrinsics.dedup_by(|a, b| {
+            a.name == b.name && a.results == b.results && a.arguments == b.arguments
+        });
+
+        let intrinsics = intrinsics
+            .into_iter()
+            // Skip intrinsics that don't return a value.
+            .filter(|intrinsic| intrinsic.results.kind() != TypeKind::Void)
+            .filter(|intrinsic| !intrinsic.arguments.args.is_empty())
+            // Skip pointers for now, we would probably need to look at the return
+            // type to work out how many elements we need to point to.
+            .filter(|intrinsic| !intrinsic.arguments.iter().any(|arg| arg.is_ptr()))
+            // Skip intrinsics from `--skip`
+            .filter(|intrinsic| !cli_options.skip.contains(&intrinsic.name))
+            .collect::<Vec<_>>();
+
+        let sample_percentage: usize = cli_options.sample_percentage as usize;
+        let sample_size = (intrinsics.len() * sample_percentage) / 100;
+        let intrinsics = intrinsics.into_iter().take(sample_size).collect();
+
+        Self { intrinsics }
+    }
+
+    fn predicate_function(_: u32) -> String {
+        unimplemented!("no scalable vectors on LoongArch")
+    }
+}
+
+fn load_intrinsics(path: &Path) -> Result<Vec<Intrinsic<LoongArch>>, Box<dyn std::error::Error>> {
+    if path.is_dir() {
+        let mut intrinsics = Vec::new();
+        for spec in ["lsx.spec", "lasx.spec"] {
+            let spec_path = path.join(spec);
+            if spec_path.exists() {
+                intrinsics.extend(get_intrinsics(&spec_path)?);
+            }
+        }
+        return Ok(intrinsics);
+    }
+
+    get_intrinsics(path)
+}
+
+const RUST_PRELUDE: &str = r#"
+#![feature(stdarch_loongarch)]
+
+use core_arch::arch::loongarch64::*;
+
+#[inline]
+unsafe fn lsx_vld_to_m128i(mem_addr: *const i8) -> m128i {
+    lsx_vld::<0>(mem_addr)
+}
+
+#[inline]
+unsafe fn lsx_vld_to_m128(mem_addr: *const i8) -> m128 {
+    core::mem::transmute(lsx_vld::<0>(mem_addr))
+}
+
+#[inline]
+unsafe fn lsx_vld_to_m128d(mem_addr: *const i8) -> m128d {
+    core::mem::transmute(lsx_vld::<0>(mem_addr))
+}
+
+#[inline]
+unsafe fn lasx_xvld_to_m256i(mem_addr: *const i8) -> m256i {
+    lasx_xvld::<0>(mem_addr)
+}
+
+#[inline]
+unsafe fn lasx_xvld_to_m256(mem_addr: *const i8) -> m256 {
+    core::mem::transmute(lasx_xvld::<0>(mem_addr))
+}
+
+#[inline]
+unsafe fn lasx_xvld_to_m256d(mem_addr: *const i8) -> m256d {
+    core::mem::transmute(lasx_xvld::<0>(mem_addr))
+}
+"#;