feat: implemented get_lane_function for x86

Author: madhav-madhusoodanan

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

@@ -14,6 +14,46 @@ pub const F16_FORMATTING_DEF: &str = r#"
 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;
+
+    int major_index = index / max_major_index;
+    int minor_index = index % max_minor_index;
+
+    __m128i lane = _mm512_extracti64x2_epi64(m, major_index);
+
+    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);
+    }
+}
+
+int _mm512_extract_intrinsic_test_epi8(__m512i m, int lane) {
+    return mm512_extract(m, 512, 8, lane)
+}
+
+int _mm512_extract_intrinsic_test_epi16(__m512i m, int lane) {
+    return mm512_extract(m, 512, 16, lane)
+}
+
+int mm512_extract_intrinsic_test_epi16(__m512i m, int lane) {
+    return mm512_extract(m, 512, 16, lane)
+}
+
+int mm512_extract_intrinsic_test_epi64(__m512i m, int lane) {
+    return mm512_extract(m, 512, 64, lane)
+}
+"#;
+
 pub const X86_CONFIGURATIONS: &str = r#"
 #![cfg_attr(target_arch = "x86", feature(stdarch_x86_avx512_bf16))]
 #![cfg_attr(target_arch = "x86", feature(stdarch_x86_avx512_f16))]

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

@@ -17,7 +17,7 @@ use crate::common::gen_rust::{
 use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::{SupportedArchitectureTest, chunk_info};
-use crate::x86::config::{F16_FORMATTING_DEF, X86_CONFIGURATIONS};
+use crate::x86::config::{F16_FORMATTING_DEF, LANE_FUNCTION_HELPERS, X86_CONFIGURATIONS};
 use config::build_notices;
 use intrinsic::X86IntrinsicType;
 use xml_parser::get_xml_intrinsics;
@@ -137,7 +137,7 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
             &mut main_rs,
             chunk_count,
             X86_CONFIGURATIONS,
-            "",
+            LANE_FUNCTION_HELPERS,
             self.intrinsics.iter().map(|i| i.name.as_str()),
         )
         .unwrap();

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

@@ -121,7 +121,29 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
 
     /// Determines the get lane function for this type.
     fn get_lane_function(&self) -> String {
-        todo!("get_lane_function for X86IntrinsicType needs to be implemented!");
+        let total_vector_bits: Option<u32> = self
+            .vec_len
+            .zip(self.bit_len)
+            .and_then(|(vec_len, bit_len)| Some(vec_len * bit_len));
+
+        match (self.bit_len, total_vector_bits) {
+            (Some(8), Some(128)) => String::from("_mm_extract_epi8"),
+            (Some(16), Some(128)) => String::from("_mm_extract_epi16"),
+            (Some(32), Some(128)) => String::from("_mm_extract_epi32"),
+            (Some(64), Some(128)) => String::from("_mm_extract_epi64"),
+            (Some(8), Some(256)) => String::from("_mm256_extract_epi8"),
+            (Some(16), Some(256)) => String::from("_mm256_extract_epi16"),
+            (Some(32), Some(256)) => String::from("_mm256_extract_epi32"),
+            (Some(64), Some(256)) => String::from("_mm256_extract_epi64"),
+            (Some(8), Some(512)) => String::from("_mm512_extract_intrinsic_test_epi8"),
+            (Some(16), Some(512)) => String::from("_mm512_extract_intrinsic_test_epi16"),
+            (Some(32), Some(512)) => String::from("_mm512_extract_intrinsic_test_epi32"),
+            (Some(64), Some(512)) => String::from("_mm512_extract_intrinsic_test_epi64"),
+            _ => unreachable!(
+                "invalid length for vector argument: {:?}, {:?}",
+                self.bit_len, self.vec_len
+            ),
+        }
     }
 }