feat: added the simple set of argument types for X86 intrinsics

Author: madhav-madhusoodanan

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

@@ -73,8 +73,8 @@ impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
                     TypeKind::Float if self.results().inner_size() == 16 => "float16_t".to_string(),
                     TypeKind::Float if self.results().inner_size() == 32 => "float".to_string(),
                     TypeKind::Float if self.results().inner_size() == 64 => "double".to_string(),
-                    TypeKind::Int => format!("int{}_t", self.results().inner_size()),
-                    TypeKind::UInt => format!("uint{}_t", self.results().inner_size()),
+                    TypeKind::Int(true) => format!("int{}_t", self.results().inner_size()),
+                    TypeKind::Int(false) => format!("uint{}_t", self.results().inner_size()),
                     TypeKind::Poly => format!("poly{}_t", self.results().inner_size()),
                     ty => todo!("print_result_c - Unknown type: {:#?}", ty),
                 },

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

@@ -73,8 +73,8 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             format!(
                 "vld{len}{quad}_{type}{size}",
                 type = match k {
-                    TypeKind::UInt => "u",
-                    TypeKind::Int => "s",
+                    TypeKind::Int(false) => "u",
+                    TypeKind::Int(true) => "s",
                     TypeKind::Float => "f",
                     // The ACLE doesn't support 64-bit polynomial loads on Armv7
                     // if armv7 and bl == 64, use "s", else "p"
@@ -107,8 +107,8 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             format!(
                 "vget{quad}_lane_{type}{size}",
                 type = match k {
-                    TypeKind::UInt => "u",
-                    TypeKind::Int => "s",
+                    TypeKind::Int(false) => "u",
+                    TypeKind::Int(true) => "s",
                     TypeKind::Float => "f",
                     TypeKind::Poly => "p",
                     x => todo!("get_load_function TypeKind: {:#?}", x),
@@ -175,7 +175,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             } else {
                 let kind = start.parse::<TypeKind>()?;
                 let bit_len = match kind {
-                    TypeKind::Int => Some(32),
+                    TypeKind::Int(_) => Some(32),
                     _ => None,
                 };
                 Ok(ArmIntrinsicType(IntrinsicType {

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

@@ -79,8 +79,8 @@ where
     ) -> Argument<T> {
         let (ty, var_name) = Self::type_and_name_from_c(arg);
 
-        let ty =
-            T::from_c(ty, target).unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
+        let ty = T::from_c(ty, &target.to_string())
+            .unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
 
         Argument {
             pos,

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

@@ -12,8 +12,12 @@ use super::values::value_for_array;
 pub enum TypeKind {
     BFloat,
     Float,
-    Int,
-    UInt,
+    Double,
+
+    // if signed, then the inner value is true
+    Int(bool),
+    Char(bool),
+    Short(bool),
     Poly,
     Void,
 }
@@ -25,9 +29,10 @@ impl FromStr for TypeKind {
         match s {
             "bfloat" => Ok(Self::BFloat),
             "float" => Ok(Self::Float),
-            "int" => Ok(Self::Int),
+            "int" => Ok(Self::Int(true)),
             "poly" => Ok(Self::Poly),
-            "uint" | "unsigned" => Ok(Self::UInt),
+            "char" => Ok(Self::Char(true)),
+            "uint" | "unsigned" => Ok(Self::Int(false)),
             "void" => Ok(Self::Void),
             _ => Err(format!("Impossible to parse argument kind {s}")),
         }
@@ -42,10 +47,15 @@ impl fmt::Display for TypeKind {
             match self {
                 Self::BFloat => "bfloat",
                 Self::Float => "float",
-                Self::Int => "int",
-                Self::UInt => "uint",
+                Self::Double => "double",
+                Self::Int(true) => "int",
+                Self::Int(false) => "uint",
                 Self::Poly => "poly",
                 Self::Void => "void",
+                Self::Char(true) => "char",
+                Self::Char(false) => "unsigned char",
+                Self::Short(true) => "short",
+                Self::Short(false) => "unsigned short",
             }
         )
     }
@@ -56,9 +66,11 @@ impl TypeKind {
     pub fn c_prefix(&self) -> &str {
         match self {
             Self::Float => "float",
-            Self::Int => "int",
-            Self::UInt => "uint",
+            Self::Int(true) => "int",
+            Self::Int(false) => "uint",
             Self::Poly => "poly",
+            Self::Char(true) => "char",
+            Self::Char(false) => "unsigned char",
             _ => unreachable!("Not used: {:#?}", self),
         }
     }
@@ -67,8 +79,8 @@ impl TypeKind {
     pub fn rust_prefix(&self) -> &str {
         match self {
             Self::Float => "f",
-            Self::Int => "i",
-            Self::UInt => "u",
+            Self::Int(true) => "i",
+            Self::Int(false) => "u",
             Self::Poly => "u",
             _ => unreachable!("Unused type kind: {:#?}", self),
         }
@@ -132,6 +144,18 @@ impl IntrinsicType {
         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!(
             "{prefix}{bits}_t",
@@ -155,8 +179,8 @@ impl IntrinsicType {
                 bit_len: Some(8),
                 ..
             } => match kind {
-                TypeKind::Int => "(int)",
-                TypeKind::UInt => "(unsigned int)",
+                TypeKind::Int(true) => "(int)",
+                TypeKind::Int(false) => "(unsigned int)",
                 TypeKind::Poly => "(unsigned int)(uint8_t)",
                 _ => "",
             },
@@ -185,7 +209,7 @@ impl IntrinsicType {
         match self {
             IntrinsicType {
                 bit_len: Some(bit_len @ (8 | 16 | 32 | 64)),
-                kind: kind @ (TypeKind::Int | TypeKind::UInt | TypeKind::Poly),
+                kind: kind @ (TypeKind::Int(_) | TypeKind::Poly),
                 simd_len,
                 vec_len,
                 ..
@@ -201,7 +225,7 @@ impl IntrinsicType {
                         .format_with(",\n", |i, fmt| {
                             let src = value_for_array(*bit_len, i);
                             assert!(src == 0 || src.ilog2() < *bit_len);
-                            if *kind == TypeKind::Int && (src >> (*bit_len - 1)) != 0 {
+                            if *kind == TypeKind::Int(true) && (src >> (*bit_len - 1)) != 0 {
                                 // `src` is a two's complement representation of a negative value.
                                 let mask = !0u64 >> (64 - *bit_len);
                                 let ones_compl = src ^ mask;
@@ -257,7 +281,7 @@ impl IntrinsicType {
                 ..
             } => false,
             IntrinsicType {
-                kind: TypeKind::Int | TypeKind::UInt | TypeKind::Poly,
+                kind: TypeKind::Int(_) | TypeKind::Poly,
                 ..
             } => true,
             _ => unimplemented!(),

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

@@ -105,26 +105,33 @@ fn xml_to_intrinsic(
     let name = intr.name;
     let results = X86IntrinsicType::from_c(&intr.return_data.type_data, target)?;
 
-    let args: Vec<_> = 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 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();
-
+    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);
+
+        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
+        }
+        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 {