fix: code cleanup

Author: madhav-madhusoodanan

crates/intrinsic-test/src/main.rs

@@ -22,7 +22,7 @@ fn main() {
             | "aarch64_be-unknown-linux-gnu" => {
                 Some(ArmArchitectureTest::create(processed_cli_options))
             }
-            
+
             "x86_64-unknown-linux-gnu" => Some(X86ArchitectureTest::create(processed_cli_options)),
 
             _ => None,

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

@@ -22,4 +22,4 @@ pub const X86_CONFIGURATIONS: &str = r#"
 #![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/constraint.rs

@@ -17,4 +17,4 @@ pub fn map_constraints(imm_type: &String) -> Option<Constraint> {
         "_CMP_" => Some(Constraint::Range(0..32)),
         _ => None,
     }
-}
+}

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

@@ -40,4 +40,4 @@ impl IntrinsicDefinition<X86IntrinsicType> for Intrinsic<X86IntrinsicType> {
     fn print_result_c(&self, _indentation: Indentation, _additional: &str) -> String {
         todo!("print_result_c in Intrinsic<X86IntrinsicType> needs to be implemented!");
     }
-}
+}

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

@@ -5,17 +5,17 @@ mod intrinsic;
 mod types;
 mod xml_parser;
 
-use std::fs::{self, File};
 use rayon::prelude::*;
+use std::fs::{self, File};
 
 use crate::common::cli::ProcessedCli;
+use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
 use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::{SupportedArchitectureTest, chunk_info};
-use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
+use config::build_notices;
 use intrinsic::X86IntrinsicType;
 use xml_parser::get_xml_intrinsics;
-use config::build_notices;
 
 pub struct X86ArchitectureTest {
     intrinsics: Vec<Intrinsic<X86IntrinsicType>>,
@@ -120,4 +120,4 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
     fn compare_outputs(&self) -> bool {
         todo!("compare_outputs in X86ArchitectureTest is not implemented")
     }
-}
+}

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

@@ -1,37 +1,251 @@
+use std::collections::HashMap;
+use std::str::FromStr;
+
+use itertools::Itertools;
+use regex::Regex;
+
 use super::intrinsic::X86IntrinsicType;
 use crate::common::cli::Language;
-use crate::common::intrinsic_helpers::IntrinsicTypeDefinition;
+use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, Sign, TypeKind};
 use crate::x86::xml_parser::Parameter;
 
 impl IntrinsicTypeDefinition for X86IntrinsicType {
     /// Gets a string containing the type in C format.
     /// This function assumes that this value is present in the metadata hashmap.
     fn c_type(&self) -> String {
-        todo!("c_type from IntrinsicTypeDefinition is not defined!")
+        self.metadata
+            .get("type")
+            .expect("Failed to extract the C typename in X86!")
+            .to_string()
     }
 
     fn c_single_vector_type(&self) -> String {
         // matches __m128, __m256 and similar types
-        todo!("c_type from IntrinsicTypeDefinition is not defined!")
+        let re = Regex::new(r"\__m\d+\").unwrap();
+        match self.metadata.get("type") {
+            Some(type_data) if re.is_match(type_data) => type_data.to_string(),
+            _ => unreachable!("Shouldn't be called on this type"),
+        }
     }
 
+    // fn rust_type(&self) -> String {
+    //     // handling edge cases first
+    //     // the general handling is implemented below
+    //     if let Some(val) = self.metadata.get("type") {
+    //         match val.as_str() {
+    //             "__m128 const *" => {
+    //                 return "&__m128".to_string();
+    //             }
+    //             "__m128d const *" => {
+    //                 return "&__m128d".to_string();
+    //             }
+    //             "const void*" => {
+    //                 return "&__m128d".to_string();
+    //             }
+    //             _ => {}
+    //         }
+    //     }
+
+    //     if self.kind() == TypeKind::Void && self.ptr {
+    //         // this has been handled by default settings in
+    //         // the from_param function of X86IntrinsicType
+    //         unreachable!()
+    //     }
+
+    //     // general handling cases
+    //     let core_part = if self.kind() == TypeKind::Mask {
+    //         // all types of __mmask<int> are handled here
+    //         format!("__mask{}", self.bit_len.unwrap())
+    //     } else if self.simd_len.is_some() {
+    //         // all types of __m<int> vector types are handled here
+    //         let re = Regex::new(r"\__m\d+[a-z]*").unwrap();
+    //         let rust_type = self
+    //             .metadata
+    //             .get("type")
+    //             .map(|val| re.find(val).unwrap().as_str());
+    //         rust_type.unwrap().to_string()
+    //     } else {
+    //         format!(
+    //             "{}{}",
+    //             self.kind.rust_prefix().to_string(),
+    //             self.bit_len.unwrap()
+    //         )
+    //     };
+
+    //     // extracting "memsize" so that even vector types can be involved
+    //     let memwidth = self
+    //         .metadata
+    //         .get("memwidth")
+    //         .map(|n| str::parse::<u32>(n).unwrap());
+    //     let prefix_part = if self.ptr && self.constant && self.bit_len.eq(&memwidth) {
+    //         "&"
+    //     } else if self.ptr && self.bit_len.eq(&memwidth) {
+    //         "&mut "
+    //     } else if self.ptr && self.constant {
+    //         "*const "
+    //     } else if self.ptr {
+    //         "*mut "
+    //     } else {
+    //         ""
+    //     };
+
+    //     return prefix_part.to_string() + core_part.as_str();
+    // }
+
     /// Determines the load function for this type.
     fn get_load_function(&self, _language: Language) -> String {
-        todo!("get_load_function from IntrinsicTypeDefinition is not defined!")
+        if let Some(type_value) = self.metadata.get("type") {
+            if type_value.starts_with("__mmask") {
+                // no need of loads, since they work directly
+                // with hex constants
+                String::from("*")
+            } else if type_value.starts_with("__m") {
+                // the structure is like the follows:
+                // if "type" starts with __m<num>{h/i/<null>},
+                // then use either _mm_set1_epi64,
+                // _mm256_set1_epi64 or _mm512_set1_epi64
+                let type_val_filtered = type_value
+                    .chars()
+                    .filter(|c| c.is_numeric())
+                    .join("")
+                    .replace("128", "");
+                format!("_mm{type_val_filtered}_set1_epi64")
+            } 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)
+                // then typecast it.
+                format!("({type_value})")
+            }
+            // Look for edge cases (constexpr, literal, etc)
+        } else {
+            unimplemented!("the value for key 'type' is not present!");
+        }
     }
 
     /// Determines the get lane function for this type.
     fn get_lane_function(&self) -> String {
         todo!("get_lane_function for X86IntrinsicType needs to be implemented!");
     }
 
-    fn from_c(s: &str, target: &str) -> Result<Self, String> {
-        todo!("from_c from IntrinsicTypeDefinition is not defined!")
+    fn from_c(s: &str) -> Result<Self, String> {
+        let mut s_copy = s.to_string();
+        let mut metadata: HashMap<String, String> = HashMap::new();
+        metadata.insert("type".to_string(), s.to_string());
+        s_copy = s_copy
+            .replace("*", "")
+            .replace("_", "")
+            .replace("constexpr", "")
+            .replace("const", "")
+            .replace("literal", "");
+
+        let s_split = s_copy
+            .split(" ")
+            .filter_map(|s| if s.len() == 0 { None } else { Some(s) })
+            .last();
+
+        let s_split = s_split.map(|s| s.chars().filter(|c| !c.is_numeric()).join(""));
+
+        // TODO: make the unwrapping safe
+        let kind = TypeKind::from_str(s_split.unwrap().trim()).unwrap_or(TypeKind::Void);
+
+        let kind = if s.find("unsigned").is_some() {
+            match kind {
+                TypeKind::Int(_) => TypeKind::Int(Sign::Unsigned),
+                TypeKind::Char(_) => TypeKind::Char(Sign::Unsigned),
+                a => a,
+            }
+        } else {
+            kind
+        };
+
+        let ptr_constant = false;
+        let constant = s.matches("const").next().is_some();
+        let ptr = s.matches("*").next().is_some();
+
+        Ok(X86IntrinsicType(IntrinsicType {
+            ptr,
+            ptr_constant,
+            constant,
+            kind,
+            bit_len: None,
+            simd_len: None,
+            vec_len: None,
+            metadata,
+        }))
     }
 }
 
 impl X86IntrinsicType {
     pub fn from_param(param: &Parameter) -> Result<Self, String> {
-        todo!("from_param from X86IntrinsicType is not defined!")
+        match Self::from_c(param.type_data.as_str()) {
+            Err(message) => Err(message),
+            Ok(mut ret) => {
+                // First correct the type of the parameter using param.etype.
+                // The assumption is that the parameter of type void may have param.type
+                // as "__m128i", "__mmask8" and the like.
+                ret.set_metadata("etype".to_string(), param.etype.clone());
+                ret.set_metadata("memwidth".to_string(), param.memwidth.to_string());
+                if !param.etype.is_empty() {
+                    match TypeKind::from_str(param.etype.as_str()) {
+                        Ok(value) => {
+                            ret.kind = value;
+                        }
+                        Err(_) => {}
+                    };
+                }
+
+                // check for param.etype.
+                // extract the numeric part and set as bit-len
+                // If param.etype is not present, guess the default bit-len
+
+                let mut etype_processed = param.etype.clone();
+                etype_processed.retain(|c| c.is_numeric());
+
+                match str::parse::<u32>(etype_processed.as_str()) {
+                    Ok(value) => ret.bit_len = Some(value),
+                    Err(_) => {
+                        ret.bit_len = match ret.kind() {
+                            TypeKind::Char(_) => Some(8),
+                            TypeKind::BFloat => Some(16),
+                            TypeKind::Int(_) => Some(32),
+                            TypeKind::Float => Some(32),
+                            _ => None,
+                        };
+                    }
+                }
+
+                // then check the param.type and extract numeric part if there are double
+                // underscores. divide this number with bit-len and set this as simd-len.
+                // Only __m<int> types can have a simd-len.
+                if param.type_data.matches("__m").next().is_some()
+                    && param.type_data.matches("__mmask").next().is_none()
+                {
+                    let mut type_processed = param.type_data.clone();
+                    type_processed.retain(|c| c.is_numeric());
+                    ret.vec_len = match str::parse::<u32>(type_processed.as_str()) {
+                        // If bit_len is None, vec_len will be None.
+                        // Else vec_len will be (num_bits / bit_len).
+                        Ok(num_bits) => ret.bit_len.and(Some(num_bits / ret.bit_len.unwrap())),
+                        Err(_) => None,
+                    };
+                }
+
+                // default settings for "void *" parameters
+                // often used by intrinsics to denote memory address or so.
+                if ret.kind == TypeKind::Void && ret.ptr {
+                    ret.kind = TypeKind::Int(Sign::Unsigned);
+                    ret.bit_len = Some(8);
+                }
+
+                // if param.etype == IMM, then it is a constant.
+                // else it stays unchanged.
+                ret.constant |= param.etype == "IMM";
+
+                Ok(ret)
+            }
+        }
+        // Tile types won't currently reach here, since the intrinsic that involve them
+        // often return "null" type. Such intrinsics are not tested in `intrinsic-test`
+        // currently and are filtered out at `mod.rs`.
     }
-}
+}

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

@@ -112,4 +112,4 @@ fn xml_to_intrinsic(
         results: result.unwrap(),
         arch_tags: intr.cpuid,
     })
-}
+}