feat: correcting errors with generated C artifacts

Author: madhav-madhusoodanan

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/mod.rs

@@ -97,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/x86/compile.rs

@@ -6,21 +6,7 @@ pub fn build_cpp_compilation(config: &ProcessedCli) -> Option<CppCompilation> {
 
     // -ffp-contract=off emulates Rust's approach of not fusing separate mul-add operations
     let mut command = CompilationCommandBuilder::new()
-        .add_arch_flags([
-            "avx",
-            "avx2",
-            "avx512f",
-            "avx512cd",
-            "avx512dq",
-            "avx512vl",
-            "avx512bw",
-            "avx512bf16",
-            "avx512bitalg",
-            "lzcnt",
-            "popcnt",
-            "adx",
-            "aes",
-        ])
+        .add_arch_flags(["icelake-client"])
         .set_compiler(cpp_compiler)
         .set_target(&config.target)
         .set_opt_level("2")

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

@@ -10,62 +10,41 @@ struct Hex<T>(T);
  "#;
 
 pub const LANE_FUNCTION_HELPERS: &str = r#"
-int mm512_extract(__m512i m, int vec_len, int bit_len, int index) {
-    int lane_len = 128;
-    int max_major_index = vec_len / lane_len;
-    int max_minor_index = lane_len / bit_len;
+typedef float float16_t;
+typedef float float32_t;
+typedef double float64_t;
 
-    int major_index = index / max_major_index;
-    int minor_index = index % max_minor_index;
+#define __int64 long long
 
-    __m128i lane = _mm512_extracti64x2_epi64(m, major_index);
+#define mm512_extract_intrinsic_test_epi8(m, lane) \
+    _mm_extract_epi8(_mm512_extracti64x2_epi64((m), (lane) / 16), (lane) % 16)
 
-    switch(bit_len){
-        case 8:
-            return _mm_extract_epi8(lane, minor_index);
-        case 16:
-            return _mm_extract_epi16(lane, minor_index);
-        case 32:
-            return _mm_extract_epi32(lane, minor_index);
-        case 64:
-            return _mm_extract_epi64(lane, minor_index);
-    }
-}
+#define mm512_extract_intrinsic_test_epi16(m, lane) \
+    _mm_extract_epi16(_mm512_extracti64x2_epi64((m), (lane) / 8), (lane) % 8)
 
-int _mm512_extract_intrinsic_test_epi8(__m512i m, int lane) {
-    return mm512_extract(m, 512, 8, lane)
-}
+#define mm512_extract_intrinsic_test_epi32(m, lane) \
+    _mm_extract_epi32(_mm512_extracti64x2_epi64((m), (lane) / 4), (lane) % 4)
 
-int _mm512_extract_intrinsic_test_epi16(__m512i m, int lane) {
-    return mm512_extract(m, 512, 16, lane)
-}
+#define mm512_extract_intrinsic_test_epi64(m, lane) \
+    _mm_extract_epi64(_mm512_extracti64x2_epi64((m), (lane) / 2), (lane) % 2)
 
-int mm512_extract_intrinsic_test_epi16(__m512i m, int lane) {
-    return mm512_extract(m, 512, 16, lane)
-}
+#define mm64_extract_intrinsic_test_epi8(m, lane) \
+    ((_mm_extract_pi16((m), (lane) / 2) >> (((lane) % 2) * 8)) & 0xFF)
 
-int mm512_extract_intrinsic_test_epi64(__m512i m, int lane) {
-    return mm512_extract(m, 512, 64, lane)
-}
-
-int mm64_extract_intrinsic_test_epi8(__m64 m, int lane) {
-    int real_lane_shift = lane / 2;
-    int real_bit_shift = (lane % 2) * 8;
-    int result = _mm_extract_pi16(m, lane / 2);
-    return (result >> real_bit_shift);
-}
-
-int mm64_extract_intrinsic_test_epi32(__m64 m, int lane) {
-    int bit_shift_amount = lane * 32;
-    return _m_to_int(m >> bit_shift_amount);
-}
+#define mm64_extract_intrinsic_test_epi32(m, lane) \
+    _mm_cvtsi64_si32(_mm_srli_si64(m, (lane) * 32))
 "#;
 
 pub const X86_CONFIGURATIONS: &str = r#"
+#![cfg_attr(target_arch = "x86", feature(avx))]
+#![cfg_attr(target_arch = "x86", feature(sse))]
+#![cfg_attr(target_arch = "x86", feature(sse2))]
 #![cfg_attr(target_arch = "x86", feature(stdarch_x86_avx512_bf16))]
 #![cfg_attr(target_arch = "x86", feature(stdarch_x86_avx512_f16))]
 #![cfg_attr(target_arch = "x86", feature(stdarch_x86_rtm))]
 #![cfg_attr(target_arch = "x86", feature(stdarch_x86_rtm))]
+#![cfg_attr(target_arch = "x86_64", feature(sse))]
+#![cfg_attr(target_arch = "x86_64", feature(sse2))]
 #![cfg_attr(target_arch = "x86_64", feature(x86_amx_intrinsics))]
 #![cfg_attr(target_arch = "x86_64", feature(stdarch_x86_avx512_f16))]
 #![feature(fmt_helpers_for_derive)]

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

@@ -35,9 +35,17 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
 
     const NOTICE: &str = config::NOTICE;
 
-    const PLATFORM_C_HEADERS: &[&str] = &["immintrin.h"];
+    const PLATFORM_C_HEADERS: &[&str] = &[
+        "immintrin.h",
+        "iostream",
+        "cstring",
+        "iomanip",
+        "sstream",
+        "cstddef",
+        "cstdint",
+    ];
     const PLATFORM_C_DEFINITIONS: &str = config::LANE_FUNCTION_HELPERS;
-    const PLATFORM_C_FORWARD_DECLARATIONS: &str = "";
+    const PLATFORM_C_FORWARD_DECLARATIONS: &str = config::LANE_FUNCTION_HELPERS;
 
     const PLATFORM_RUST_DEFINITIONS: &str = config::F16_FORMATTING_DEF;
     const PLATFORM_RUST_CFGS: &str = config::X86_CONFIGURATIONS;

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

@@ -110,7 +110,17 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
                 .filter(|c| c.is_numeric())
                 .join("")
                 .replace("128", "");
-            format!("_mm{type_val_filtered}_set1_epi64")
+            {
+                if type_value.ends_with("d") {
+                    format!("_mm{type_val_filtered}_loadu_pd")
+                } else if type_value.ends_with("h") {
+                    format!("_mm{type_val_filtered}_loadu_ph")
+                } else if type_value.ends_with("i") {
+                    format!("_mm{type_val_filtered}_loadu_epi16")
+                } else {
+                    format!("_mm{type_val_filtered}_loadu_ps")
+                }
+            }
         } else {
             // if it is a pointer, then rely on type conversion
             // If it is not any of the above type (__int<num>, __bfloat16, unsigned short, etc)