feat: added X86IntrinsicType parsing from string.

Author: madhav-madhusoodanan

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

@@ -29,7 +29,9 @@ impl FromStr for TypeKind {
         match s {
             "bfloat" => Ok(Self::BFloat),
             "float" => Ok(Self::Float),
-            "int" => Ok(Self::Int(true)),
+            "double" => Ok(Self::Double),
+            "int" | "long" => Ok(Self::Int(true)),
+            "short" => Ok(Self::Short(true)),
             "poly" => Ok(Self::Poly),
             "char" => Ok(Self::Char(true)),
             "uint" | "unsigned" => Ok(Self::Int(false)),
@@ -69,6 +71,7 @@ impl TypeKind {
             Self::Int(true) => "int",
             Self::Int(false) => "uint",
             Self::Poly => "poly",
+            Self::Char(true) => "char",
             _ => unreachable!("Not used: {:#?}", self),
         }
     }
@@ -141,6 +144,18 @@ impl IntrinsicType {
     pub fn is_ptr(&self) -> bool {
         self.ptr
     }
+    
+    pub fn set_bit_len(&mut self, value: Option<u32>) {
+        self.bit_len = value;
+    }
+    
+    pub fn set_simd_len(&mut self, value: Option<u32>) {
+        self.simd_len = value;
+    }
+    
+    pub fn set_vec_len(&mut self, value: Option<u32>) {
+        self.vec_len = value;
+    }
 
     pub fn c_scalar_type(&self) -> String {
         format!(
@@ -195,7 +210,7 @@ impl IntrinsicType {
         match self {
             IntrinsicType {
                 bit_len: Some(bit_len @ (8 | 16 | 32 | 64)),
-                kind: kind @ (TypeKind::Int(_) | TypeKind::Poly),
+                kind: kind @ (TypeKind::Int(_) | TypeKind::Poly | TypeKind::Char(_)),
                 simd_len,
                 vec_len,
                 ..

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

@@ -2,7 +2,7 @@ use crate::common::argument::ArgumentList;
 use crate::common::indentation::Indentation;
 use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
 use crate::common::intrinsic_helpers::IntrinsicType;
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct X86IntrinsicType(pub IntrinsicType);
@@ -15,6 +15,13 @@ impl Deref for X86IntrinsicType {
     }
 }
 
+impl DerefMut for X86IntrinsicType {
+    // type Target = IntrinsicType;
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 impl IntrinsicDefinition<X86IntrinsicType> for Intrinsic<X86IntrinsicType> {
     fn arguments(&self) -> ArgumentList<X86IntrinsicType> {
         self.arguments.clone()

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

@@ -1,12 +1,15 @@
 mod intrinsic;
 mod types;
 mod xml_parser;
+mod config;
 
 use crate::common::SupportedArchitectureTest;
 use crate::common::cli::ProcessedCli;
-use crate::common::intrinsic::Intrinsic;
+use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
+use crate::common::write_file::{write_c_testfiles, write_rust_testfiles};
 use intrinsic::X86IntrinsicType;
 use xml_parser::get_xml_intrinsics;
+use config::build_notices;
 
 pub struct X86ArchitectureTest {
     intrinsics: Vec<Intrinsic<X86IntrinsicType>>,
@@ -25,7 +28,25 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
     }
 
     fn build_c_file(&self) -> bool {
-        todo!("build_c_file in X86ArchitectureTest is not implemented")
+        let compiler = self.cli_options.cpp_compiler.as_deref();
+        let target = &self.cli_options.target;
+        let cxx_toolchain_dir = self.cli_options.cxx_toolchain_dir.as_deref();
+        let c_target = "x86_64";
+
+        let intrinsics_name_list = write_c_testfiles(
+            &self
+                .intrinsics
+                .iter()
+                .map(|i| i as &dyn IntrinsicDefinition<_>)
+                .collect::<Vec<_>>(),
+            target,
+            c_target,
+            &["immintrin.h"],
+            &build_notices("// "),
+            &[],
+        );
+
+        true
     }
 
     fn build_rust_file(&self) -> bool {

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

@@ -1,6 +1,8 @@
+use std::str::FromStr;
+
 use super::intrinsic::X86IntrinsicType;
 use crate::common::cli::Language;
-use crate::common::intrinsic_helpers::IntrinsicTypeDefinition;
+use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, TypeKind};
 
 impl IntrinsicTypeDefinition for X86IntrinsicType {
     /// Gets a string containing the typename for this type in C format.
@@ -27,6 +29,50 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
     }
 
     fn from_c(s: &str, target: &String) -> Result<Self, String> {
-        todo!("from_c for X86IntrinsicType needs to be implemented!");
+        let mut s_copy = s.to_string();
+        s_copy = s_copy
+            .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();
+        
+        // TODO: add more intrinsics by modifying 
+        // functionality below this line.
+        // Currently all the intrinsics that have an "_"
+        // is ignored.
+        if let Some(_) = s.matches("_").next() {
+            return Err(String::from("This functionality needs to be implemented"));
+        };
+        
+        // TODO: make the unwrapping safe
+        let kind = TypeKind::from_str(s_split.unwrap()).expect("Unable to parse type!");
+        let mut ptr_constant = false;
+        let mut constant = false;
+        let mut ptr = false;
+        
+        if let Some(_) = s.matches("const*").next() {
+            ptr_constant = true;
+        };
+        if let Some(_) = s.matches("const").next() {
+            constant = true;
+        };
+        if let Some(_) = s.matches("*").next() {
+            ptr = true;
+        };
+        
+        Ok(X86IntrinsicType(IntrinsicType {
+            ptr,
+            ptr_constant,
+            constant,
+            kind,
+            bit_len: None,
+            simd_len: None,
+            vec_len: None,
+            target: target.to_string(),
+        }))
     }
 }

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

@@ -91,7 +91,8 @@ pub fn get_xml_intrinsics(
         .intrinsics
         .into_iter()
         .filter_map(|intr| {
-            Some(xml_to_intrinsic(intr, target).expect("Couldn't parse XML properly!"))
+            // Some(xml_to_intrinsic(intr, target).expect("Couldn't parse XML properly!"))
+            xml_to_intrinsic(intr, target).ok()
         })
         .collect();
 
@@ -105,26 +106,37 @@ fn xml_to_intrinsic(
     let name = intr.name;
     let results = X86IntrinsicType::from_c(&intr.return_data.type_data, target)?;
 
-    let args: Vec<_> = intr
+    let args_check = intr
         .parameters
         .into_iter()
         .enumerate()
         .map(|(i, param)| {
             let constraint = None;
-            let ty = X86IntrinsicType::from_c(param.type_data.as_str(), target)
-                .unwrap_or_else(|_| panic!("Failed to parse argument '{i}'"));
-
+            let ty = X86IntrinsicType::from_c(param.type_data.as_str(), target);
+            
+            if let Err(_) = ty {
+                return None;
+            }
+            let mut ty_bit_len = param.etype.clone();
+            ty_bit_len.retain(|c| c.is_numeric());
+            let ty_bit_len = str::parse::<u32>(ty_bit_len.as_str()).ok();
+            let mut ty = ty.unwrap();
+            ty.set_bit_len(ty_bit_len);
             let mut arg = Argument::<X86IntrinsicType>::new(i, param.var_name, ty, constraint);
             let IntrinsicType {
                 ref mut constant, ..
             } = arg.ty.0;
             if param.etype == "IMM" {
                 *constant = true
             }
-            arg
-        })
-        .collect();
+            Some(arg)
+        });
 
+    let args = args_check.collect::<Vec<_>>();
+    if args.iter().any(|elem| elem.is_none()) {
+        return Err(Box::from("intrinsic isn't fully supported in this test!"));
+    }
+    let args = args.into_iter().map(|e|e.unwrap()).collect::<Vec<_>>();
     let arguments = ArgumentList::<X86IntrinsicType> { args };
 
     Ok(Intrinsic {