feat: demote "target" to a 2nd class variable, since it is only rarely

necessary.

Further notes:
1. IntrinsicType.target -> IntrinsicType.metadata
2. Maintaining a HashMap to support arbitrary data storage for other
arch

Author: madhav-madhusoodanan

crates/intrinsic-test/src/arm/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, IntrinsicTypeDefinition, TypeKind};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct ArmIntrinsicType(pub IntrinsicType);
@@ -15,6 +15,12 @@ impl Deref for ArmIntrinsicType {
     }
 }
 
+impl DerefMut for ArmIntrinsicType {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
     fn arguments(&self) -> ArgumentList<ArmIntrinsicType> {
         self.arguments.clone()

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

@@ -79,8 +79,8 @@ fn json_to_intrinsic(
 ) -> Result<Intrinsic<ArmIntrinsicType>, Box<dyn std::error::Error>> {
     let name = intr.name.replace(['[', ']'], "");
 
-    let results = ArmIntrinsicType::from_c(&intr.return_type.value, &target.to_string())?;
-
+    let mut results = ArmIntrinsicType::from_c(&intr.return_type.value)?;
+    results.set_metadata("target".to_string(), target.to_string());
     let args = intr
         .arguments
         .into_iter()
@@ -92,7 +92,9 @@ fn json_to_intrinsic(
             let arg_prep: Option<ArgPrep> = metadata.and_then(|a| a.try_into().ok());
             let constraint: Option<Constraint> = arg_prep.and_then(|a| a.try_into().ok());
 
-            let mut arg = Argument::<ArmIntrinsicType>::from_c(i, &arg, target, constraint);
+            let mut arg = Argument::<ArmIntrinsicType>::from_c(i, &arg, constraint);
+            arg.ty
+                .set_metadata("target".to_string(), target.to_string());
 
             // The JSON doesn't list immediates as const
             let IntrinsicType {

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

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use super::intrinsic::ArmIntrinsicType;
 use crate::common::cli::Language;
 use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, TypeKind};
@@ -59,7 +61,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             bit_len: Some(bl),
             simd_len,
             vec_len,
-            target,
+            metadata,
             ..
         } = &self.0
         {
@@ -69,7 +71,11 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                 ""
             };
 
-            let choose_workaround = language == Language::C && target.contains("v7");
+            let choose_workaround = language == Language::C
+                && metadata
+                    .get("target")
+                    .filter(|value| value.contains("v7"))
+                    .is_some();
             format!(
                 "vld{len}{quad}_{type}{size}",
                 type = match k {
@@ -121,18 +127,18 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
         }
     }
 
-    fn from_c(s: &str, target: &String) -> Result<Self, String> {
+    fn from_c(s: &str) -> Result<Self, String> {
         const CONST_STR: &str = "const";
         if let Some(s) = s.strip_suffix('*') {
             let (s, constant) = match s.trim().strip_suffix(CONST_STR) {
                 Some(stripped) => (stripped, true),
                 None => (s, false),
             };
             let s = s.trim_end();
-            let temp_return = ArmIntrinsicType::from_c(s, target);
+            let temp_return = ArmIntrinsicType::from_c(s);
             temp_return.and_then(|mut op| {
-                op.0.ptr = true;
-                op.0.ptr_constant = constant;
+                op.ptr = true;
+                op.ptr_constant = constant;
                 Ok(op)
             })
         } else {
@@ -170,7 +176,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     bit_len: Some(bit_len),
                     simd_len,
                     vec_len,
-                    target: target.to_string(),
+                    metadata: HashMap::new(),
                 }))
             } else {
                 let kind = start.parse::<TypeKind>()?;
@@ -186,7 +192,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     bit_len,
                     simd_len: None,
                     vec_len: None,
-                    target: target.to_string(),
+                    metadata: HashMap::new(),
                 }))
             }
         }

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

@@ -71,16 +71,10 @@ where
         }
     }
 
-    pub fn from_c(
-        pos: usize,
-        arg: &str,
-        target: &str,
-        constraint: Option<Constraint>,
-    ) -> Argument<T> {
+    pub fn from_c(pos: usize, arg: &str, constraint: Option<Constraint>) -> Argument<T> {
         let (ty, var_name) = Self::type_and_name_from_c(arg);
 
-        let ty = T::from_c(ty, &target.to_string())
-            .unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
+        let ty = T::from_c(ty).unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
 
         Argument {
             pos,

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

@@ -105,7 +105,6 @@ pub fn generate_c_test_loop<T: IntrinsicTypeDefinition + Sized>(
     indentation: Indentation,
     additional: &str,
     passes: u32,
-    _target: &str,
 ) -> String {
     let body_indentation = indentation.nested();
     format!(
@@ -157,7 +156,7 @@ pub fn generate_c_constraint_blocks<T: IntrinsicTypeDefinition>(
             })
             .join("\n")
     } else {
-        generate_c_test_loop(intrinsic, indentation, &name, PASSES, target)
+        generate_c_test_loop(intrinsic, indentation, &name, PASSES)
     }
 }
 

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

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::fmt;
 use std::ops::Deref;
 use std::str::FromStr;
@@ -18,21 +19,22 @@ pub enum TypeKind {
     Char(bool),
     Poly,
     Void,
+    Mask,
 }
 
 impl FromStr for TypeKind {
     type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "bfloat" => Ok(Self::BFloat),
-            "float" => Ok(Self::Float),
-            "double" => Ok(Self::Float),
-            "int" | "long" | "short" => Ok(Self::Int(true)),
+            "bfloat" | "BF16" => Ok(Self::BFloat),
+            "float" | "double" | "FP16" | "FP32" | "FP64" => Ok(Self::Float),
+            "int" | "long" | "short" | "SI8" | "SI16" | "SI32" | "SI64" => Ok(Self::Int(true)),
             "poly" => Ok(Self::Poly),
             "char" => Ok(Self::Char(true)),
-            "uint" | "unsigned" => Ok(Self::Int(false)),
+            "uint" | "unsigned" | "UI8" | "UI16" | "UI32" | "UI64" => Ok(Self::Int(false)),
             "void" => Ok(Self::Void),
+            "MASK" => Ok(Self::Mask),
             _ => Err(format!("Impossible to parse argument kind {s}")),
         }
     }
@@ -52,6 +54,7 @@ impl fmt::Display for TypeKind {
                 Self::Void => "void",
                 Self::Char(true) => "char",
                 Self::Char(false) => "unsigned char",
+                Self::Mask => "mask",
             }
         )
     }
@@ -107,7 +110,8 @@ pub struct IntrinsicType {
     /// A value of `None` can be assumed to be 1 though.
     pub vec_len: Option<u32>,
 
-    pub target: String,
+    // pub target: String,
+    pub metadata: HashMap<String, String>,
 }
 
 impl IntrinsicType {
@@ -151,6 +155,10 @@ impl IntrinsicType {
         self.vec_len = value;
     }
 
+    pub fn set_metadata(&mut self, key: String, value: String) {
+        self.metadata.insert(key, value);
+    }
+
     pub fn c_scalar_type(&self) -> String {
         match self {
             IntrinsicType {
@@ -322,7 +330,7 @@ pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
     fn get_lane_function(&self) -> String;
 
     /// can be implemented in an `impl` block
-    fn from_c(_s: &str, _target: &String) -> Result<Self, String>
+    fn from_c(_s: &str) -> Result<Self, String>
     where
         Self: Sized;
 

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

@@ -16,7 +16,6 @@ impl Deref for X86IntrinsicType {
 }
 
 impl DerefMut for X86IntrinsicType {
-    // type Target = IntrinsicType;
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }

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

@@ -19,8 +19,8 @@ pub struct X86ArchitectureTest {
 
 impl SupportedArchitectureTest for X86ArchitectureTest {
     fn create(cli_options: ProcessedCli) -> Box<Self> {
-        let mut intrinsics = get_xml_intrinsics(&cli_options.filename, &cli_options.target)
-            .expect("Error parsing input file");
+        let mut intrinsics =
+            get_xml_intrinsics(&cli_options.filename).expect("Error parsing input file");
 
         intrinsics.sort_by(|a, b| a.name.cmp(&b.name));
         let intrinsics = intrinsics

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

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::str::FromStr;
 
 use super::intrinsic::X86IntrinsicType;
@@ -36,7 +37,7 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
         todo!("get_lane_function for X86IntrinsicType needs to be implemented!");
     }
 
-    fn from_c(s: &str, target: &String) -> Result<Self, String> {
+    fn from_c(s: &str) -> Result<Self, String> {
         let mut s_copy = s.to_string();
         s_copy = s_copy
             .replace("*", "")
@@ -88,7 +89,7 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
             bit_len: None,
             simd_len: None,
             vec_len: None,
-            target: target.to_string(),
+            metadata: HashMap::new(),
         }))
     }
 }

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

@@ -73,7 +73,6 @@ struct Instruction {
 
 pub fn get_xml_intrinsics(
     filename: &Path,
-    target: &String,
 ) -> Result<Vec<Intrinsic<X86IntrinsicType>>, Box<dyn std::error::Error>> {
     let file = std::fs::File::open(filename)?;
     let reader = std::io::BufReader::new(file);
@@ -85,15 +84,15 @@ pub fn get_xml_intrinsics(
         .into_iter()
         .filter_map(|intr| {
             // Some(xml_to_intrinsic(intr, target).expect("Couldn't parse XML properly!"))
-            xml_to_intrinsic(intr, target).ok()
+            xml_to_intrinsic(intr).ok()
         })
         .collect();
 
     Ok(parsed_intrinsics)
 }
 
-fn parse_observable(param: &Parameter, target: &String) -> Result<X86IntrinsicType, String> {
-    let ty = X86IntrinsicType::from_c(param.type_data.as_str(), target);
+fn parse_observable(param: &Parameter) -> Result<X86IntrinsicType, String> {
+    let ty = X86IntrinsicType::from_c(param.type_data.as_str());
 
     if let Err(_) = ty {
         return ty;
@@ -118,12 +117,11 @@ fn parse_observable(param: &Parameter, target: &String) -> Result<X86IntrinsicTy
 
 fn xml_to_intrinsic(
     intr: XMLIntrinsic,
-    target: &String,
 ) -> Result<Intrinsic<X86IntrinsicType>, Box<dyn std::error::Error>> {
     let name = intr.name;
-    let result = parse_observable(&intr.return_data, target);
+    let result = parse_observable(&intr.return_data);
     let args_check = intr.parameters.into_iter().enumerate().map(|(i, param)| {
-        let ty = parse_observable(&param, target);
+        let ty = parse_observable(&param);
         if let Err(_) = ty {
             return None;
         }