fix: more support for Mask types

Author: madhav-madhusoodanan

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

@@ -131,7 +131,7 @@ impl IntrinsicType {
         if let Some(bl) = self.bit_len {
             bl
         } else {
-            unreachable!("")
+            unreachable!("{:#?}", self)
         }
     }
 
@@ -222,7 +222,8 @@ impl IntrinsicType {
         match self {
             IntrinsicType {
                 bit_len: Some(bit_len @ (8 | 16 | 32 | 64)),
-                kind: kind @ (TypeKind::Int(_) | TypeKind::Poly | TypeKind::Char(_)),
+                kind:
+                    kind @ (TypeKind::Int(_) | TypeKind::Poly | TypeKind::Char(_) | TypeKind::Mask),
                 simd_len,
                 vec_len,
                 ..

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

@@ -5,6 +5,7 @@ use itertools::Itertools;
 use regex::Regex;
 
 use super::intrinsic::X86IntrinsicType;
+use crate::common::argument::Argument;
 use crate::common::cli::Language;
 use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, Sign, TypeKind};
 use crate::x86::xml_parser::Parameter;
@@ -18,7 +19,7 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
 
     fn c_single_vector_type(&self) -> String {
         // matches __m128, __m256 and similar types
-        let re = Regex::new(r"\__m\d+\").unwrap();
+        let re = Regex::new(r"__m\d+").unwrap();
         if re.is_match(self.param.type_data.as_str()) {
             self.param.type_data.clone()
         } else {
@@ -129,8 +130,6 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
 impl X86IntrinsicType {
     fn from_c(s: &str) -> Result<IntrinsicType, 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("_", "")
@@ -196,6 +195,9 @@ impl X86IntrinsicType {
                 let mut etype_processed = param.etype.clone();
                 etype_processed.retain(|c| c.is_numeric());
 
+                let mut type_processed = param.type_data.clone();
+                type_processed.retain(|c| c.is_numeric());
+
                 match str::parse::<u32>(etype_processed.as_str()) {
                     Ok(value) => data.bit_len = Some(value),
                     Err(_) => {
@@ -209,14 +211,16 @@ impl X86IntrinsicType {
                     }
                 }
 
+                if param.type_data.matches("__mmask").next().is_some() {
+                    data.bit_len = str::parse::<u32>(type_processed.as_str()).ok();
+                }
+
                 // 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());
                     data.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).
@@ -235,7 +239,6 @@ impl X86IntrinsicType {
                 // if param.etype == IMM, then it is a constant.
                 // else it stays unchanged.
                 data.constant |= param.etype == "IMM";
-
                 Ok(X86IntrinsicType {
                     data,
                     param: param.clone(),

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

@@ -3,6 +3,7 @@ use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::x86::constraint::map_constraints;
 
+use regex::Regex;
 use serde::{Deserialize, Deserializer};
 use std::path::Path;
 
@@ -96,11 +97,24 @@ fn xml_to_intrinsic(
     if args.iter().any(|elem| elem.is_none()) {
         return Err(Box::from("intrinsic isn't fully supported in this test!"));
     }
-    let args = args
+    let mut args = args
         .into_iter()
         .map(|e| e.unwrap())
         .filter(|arg| arg.ty.ptr || arg.ty.kind != TypeKind::Void)
         .collect::<Vec<_>>();
+
+    let mut args_test = args.iter();
+
+    // if one of the args has etype="MASK" and type="__m<int>d",
+    // then set the bit_len and vec_len accordingly
+    let re = Regex::new(r"__m\d+").unwrap();
+    let is_mask = |arg: &Argument<X86IntrinsicType>| arg.ty.param.etype.as_str() == "MASK";
+    let is_vector = |arg: &Argument<X86IntrinsicType>| re.is_match(arg.ty.param.type_data.as_str());
+    let pos = args_test.position(|arg| is_mask(arg) && is_vector(arg));
+    if let Some(index) = pos {
+        args[index].ty.bit_len = args[0].ty.bit_len;
+    }
+
     let arguments = ArgumentList::<X86IntrinsicType> { args };
 
     if let Err(message) = result {