feat: add formatting for __m128i, __m256i, __m512i types that is similar

to C++ version of the same.

Author: madhav-madhusoodanan

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

@@ -4,7 +4,6 @@ use std::process::Command;
 use crate::common::intrinsic::Intrinsic;
 
 use super::indentation::Indentation;
-use super::intrinsic::format_f16_return_value;
 use super::intrinsic_helpers::IntrinsicTypeDefinition;
 
 // The number of times each intrinsic will be called.
@@ -233,7 +232,6 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
         }
     }
 
-    let return_value = format_f16_return_value(intrinsic);
     let indentation2 = indentation.nested();
     let indentation3 = indentation2.nested();
     writeln!(
@@ -250,6 +248,7 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
             }}",
         loaded_args = intrinsic.arguments.load_values_rust(indentation3),
         args = intrinsic.arguments.as_call_param_rust(),
+        return_value = intrinsic.results.print_result_rust(),
     )
 }
 

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

@@ -1,5 +1,5 @@
 use super::argument::ArgumentList;
-use super::intrinsic_helpers::{IntrinsicTypeDefinition, TypeKind};
+use super::intrinsic_helpers::IntrinsicTypeDefinition;
 
 /// An intrinsic
 #[derive(Debug, PartialEq, Clone)]
@@ -16,17 +16,3 @@ pub struct Intrinsic<T: IntrinsicTypeDefinition> {
     /// Any architecture-specific tags.
     pub arch_tags: Vec<String>,
 }
-
-pub fn format_f16_return_value<T: IntrinsicTypeDefinition>(intrinsic: &Intrinsic<T>) -> String {
-    // the `intrinsic-test` crate compares the output of C and Rust intrinsics. Currently, It uses
-    // a string representation of the output value to compare. In C, f16 values are currently printed
-    // as hexadecimal integers. Since https://github.com/rust-lang/rust/pull/127013, rust does print
-    // them as decimal floating point values. To keep the intrinsics tests working, for now, format
-    // vectors containing f16 values like C prints them.
-    let return_value = match intrinsic.results.kind() {
-        TypeKind::Float if intrinsic.results.inner_size() == 16 => "debug_f16(__return_value)",
-        _ => "format_args!(\"{__return_value:.150?}\")",
-    };
-
-    String::from(return_value)
-}

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

@@ -365,6 +365,24 @@ pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
     /// there is an int i in scope which is the current pass number.
     fn print_result_c(&self, indentation: Indentation, additional: &str) -> String;
 
+    /// 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.
+    ///
+    /// The `intrinsic-test` crate compares the output of C and Rust intrinsics. Currently, It uses
+    /// a string representation of the output value to compare. In C, f16 values are currently printed
+    /// as hexadecimal integers. Since https://github.com/rust-lang/rust/pull/127013, rust does print
+    /// them as decimal floating point values. To keep the intrinsics tests working, for now, format
+    /// vectors containing f16 values like C prints them.
+    fn print_result_rust(&self) -> String {
+        let return_value = match self.kind() {
+            TypeKind::Float if self.inner_size() == 16 => "debug_f16(__return_value)",
+            _ => "format_args!(\"{__return_value:.150?}\")",
+        };
+
+        String::from(return_value)
+    }
+
     /// To enable architecture-specific logic
     fn rust_scalar_type(&self) -> String {
         format!(

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

@@ -206,7 +206,49 @@ impl DebugHexF16 for __m512i {
         debug_simd_finish(f, "__m512i", &array)
     }
 }
- "#;
+
+trait DebugI16 {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result;
+}
+
+impl DebugI16 for i16 {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl DebugI16 for __m128i {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let array = unsafe { core::mem::transmute::<_, [i16; 8]>(*self) };
+        debug_simd_finish(f, "__m128i", &array)
+    }
+}
+
+impl DebugI16 for __m256i {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let array = unsafe { core::mem::transmute::<_, [i16; 16]>(*self) };
+        debug_simd_finish(f, "__m256i", &array)
+    }
+}
+
+impl DebugI16 for __m512i {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let array = unsafe { core::mem::transmute::<_, [i16; 32]>(*self) };
+        debug_simd_finish(f, "__m512i", &array)
+    }
+}
+
+fn debug_i16<T: DebugI16>(x: T) -> impl core::fmt::Debug {
+    struct DebugWrapper<T>(T);
+    impl<T: DebugI16> core::fmt::Debug for DebugWrapper<T> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+    DebugWrapper(x)
+}
+
+"#;
 
 pub const PLATFORM_C_FORWARD_DECLARATIONS: &str = r#"
 #ifndef X86_DECLARATIONS

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

@@ -292,6 +292,18 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
         };
         format!("{prefix}{bits}")
     }
+
+    fn print_result_rust(&self) -> String {
+        let return_value = match self.kind() {
+            TypeKind::Float if self.inner_size() == 16 => "debug_f16(__return_value)",
+            _ if ["__m128i", "__m256i", "__m512i"].contains(&self.param.type_data.as_str()) => {
+                "debug_i16(__return_value)"
+            }
+            _ => "format_args!(\"{__return_value:.150?}\")",
+        };
+
+        String::from(return_value)
+    }
 }
 
 impl X86IntrinsicType {