introduced generic types and code refactor

Author: madhav-madhusoodanan

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

@@ -0,0 +1,60 @@
+use super::json_parser::ArgPrep;
+
+use crate::common::argument::MetadataDefinition;
+use serde::Deserialize;
+use serde_json::Value;
+use std::ops::Range;
+
+#[derive(Debug, PartialEq, Clone, Deserialize)]
+pub enum Constraint {
+    Equal(i64),
+    Range(Range<i64>),
+}
+
+impl Constraint {
+    pub fn to_range(&self) -> Range<i64> {
+        match self {
+            Constraint::Equal(eq) => *eq..*eq + 1,
+            Constraint::Range(range) => range.clone(),
+        }
+    }
+}
+
+impl MetadataDefinition for Constraint {
+    fn from_metadata(metadata: Option<Value>) -> Vec<Box<Self>> {
+        let arg_prep: Option<ArgPrep> = metadata.and_then(|a| {
+            if let Value::Object(_) = a {
+                a.try_into().ok()
+            } else {
+                None
+            }
+        });
+        let constraint: Option<Constraint> = arg_prep.and_then(|a| a.try_into().ok());
+        vec![constraint]
+            .into_iter()
+            .filter_map(|a| a)
+            .map(|a| Box::new(a))
+            .collect()
+    }
+}
+
+/// ARM-specific
+impl TryFrom<ArgPrep> for Constraint {
+    type Error = ();
+
+    fn try_from(prep: ArgPrep) -> Result<Self, Self::Error> {
+        let parsed_ints = match prep {
+            ArgPrep::Immediate { min, max } => Ok((min, max)),
+            _ => Err(()),
+        };
+        if let Ok((min, max)) = parsed_ints {
+            if min == max {
+                Ok(Constraint::Equal(min))
+            } else {
+                Ok(Constraint::Range(min..max + 1))
+            }
+        } else {
+            Err(())
+        }
+    }
+}

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

@@ -1,9 +1,12 @@
-use super::argument::Argument;
 use super::config::{AARCH_CONFIGURATIONS, POLY128_OSTREAM_DEF, build_notices};
-use super::format::Indentation;
-use super::intrinsic::Intrinsic;
+use super::intrinsic::ArmIntrinsicType;
+use crate::arm::constraint::Constraint;
+use crate::common::argument::Argument;
+use crate::common::format::Indentation;
 use crate::common::gen_c::{compile_c, create_c_filenames, generate_c_program};
 use crate::common::gen_rust::{compile_rust, create_rust_filenames, generate_rust_program};
+use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
+use crate::common::intrinsic_types::IntrinsicTypeDefinition;
 use crate::common::write_file;
 use itertools::Itertools;
 use rayon::prelude::*;
@@ -14,14 +17,14 @@ const PASSES: u32 = 20;
 
 fn gen_code_c(
     indentation: Indentation,
-    intrinsic: &Intrinsic,
-    constraints: &[&Argument],
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    constraints: &[&Argument<ArmIntrinsicType, Constraint>],
     name: String,
     target: &str,
 ) -> String {
     if let Some((current, constraints)) = constraints.split_last() {
         let range = current
-            .constraints
+            .metadata
             .iter()
             .map(|c| c.to_range())
             .flat_map(|r| r.into_iter());
@@ -52,11 +55,15 @@ fn gen_code_c(
     }
 }
 
-fn generate_c_program_arm(header_files: &[&str], intrinsic: &Intrinsic, target: &str) -> String {
+fn generate_c_program_arm(
+    header_files: &[&str],
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    target: &str,
+) -> String {
     let constraints = intrinsic
         .arguments
         .iter()
-        .filter(|i| i.has_constraint())
+        .filter(|&i| i.has_constraint())
         .collect_vec();
 
     let indentation = Indentation::default();
@@ -82,13 +89,13 @@ fn generate_c_program_arm(header_files: &[&str], intrinsic: &Intrinsic, target:
 
 fn gen_code_rust(
     indentation: Indentation,
-    intrinsic: &Intrinsic,
-    constraints: &[&Argument],
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    constraints: &[&Argument<ArmIntrinsicType, Constraint>],
     name: String,
 ) -> String {
     if let Some((current, constraints)) = constraints.split_last() {
         let range = current
-            .constraints
+            .metadata
             .iter()
             .map(|c| c.to_range())
             .flat_map(|r| r.into_iter());
@@ -118,7 +125,10 @@ fn gen_code_rust(
     }
 }
 
-fn generate_rust_program_arm(intrinsic: &Intrinsic, target: &str) -> String {
+fn generate_rust_program_arm(
+    intrinsic: &Intrinsic<ArmIntrinsicType, Constraint>,
+    target: &str,
+) -> String {
     let constraints = intrinsic
         .arguments
         .iter()
@@ -220,7 +230,7 @@ fn compile_c_arm(
 }
 
 pub fn build_c(
-    intrinsics: &Vec<Intrinsic>,
+    intrinsics: &Vec<Intrinsic<ArmIntrinsicType, Constraint>>,
     compiler: Option<&str>,
     target: &str,
     cxx_toolchain_dir: Option<&str>,
@@ -252,7 +262,7 @@ pub fn build_c(
 }
 
 pub fn build_rust(
-    intrinsics: &[Intrinsic],
+    intrinsics: &[Intrinsic<ArmIntrinsicType, Constraint>],
     toolchain: Option<&str>,
     target: &str,
     linker: Option<&str>,

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

@@ -1,40 +1,83 @@
-use super::argument::ArgumentList;
-use super::format::Indentation;
-use super::types::{IntrinsicType, TypeKind};
+use super::constraint::Constraint;
+use crate::common::argument::ArgumentList;
+use crate::common::format::Indentation;
+use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
+use crate::common::intrinsic_types::{
+    BaseIntrinsicTypeDefinition, IntrinsicType, IntrinsicTypeDefinition, TypeKind,
+};
+use crate::common::types::Language;
 
-/// An intrinsic
-#[derive(Debug, PartialEq, Clone)]
-pub struct Intrinsic {
-    /// The function name of this intrinsic.
-    pub name: String,
+#[derive(Debug, Clone, PartialEq)]
+pub struct ArmIntrinsicType(pub IntrinsicType);
 
-    /// Any arguments for this intrinsic.
-    pub arguments: ArgumentList,
+impl BaseIntrinsicTypeDefinition for ArmIntrinsicType {
+    fn kind(&self) -> TypeKind {
+        self.0.kind()
+    }
+    fn inner_size(&self) -> u32 {
+        self.0.inner_size()
+    }
+    fn num_lanes(&self) -> u32 {
+        self.0.num_lanes()
+    }
+    fn num_vectors(&self) -> u32 {
+        self.0.num_vectors()
+    }
+    fn is_simd(&self) -> bool {
+        self.0.is_simd()
+    }
+    fn is_ptr(&self) -> bool {
+        self.0.is_ptr()
+    }
+    fn c_scalar_type(&self) -> String {
+        self.0.c_scalar_type()
+    }
+    fn rust_scalar_type(&self) -> String {
+        self.0.rust_scalar_type()
+    }
+    fn c_promotion(&self) -> &str {
+        self.0.c_promotion()
+    }
+    fn populate_random(&self, indentation: Indentation, loads: u32, language: &Language) -> String {
+        self.0.populate_random(indentation, loads, language)
+    }
+    fn is_rust_vals_array_const(&self) -> bool {
+        self.0.is_rust_vals_array_const()
+    }
+    fn as_call_param_c(&self, name: &String) -> String {
+        self.0.as_call_param_c(name)
+    }
+}
 
-    /// The return type of this intrinsic.
-    pub results: IntrinsicType,
+impl IntrinsicDefinition<ArmIntrinsicType, Constraint> for Intrinsic<ArmIntrinsicType, Constraint> {
+    fn arguments(&self) -> ArgumentList<ArmIntrinsicType, Constraint> {
+        self.arguments.clone()
+    }
 
-    /// Whether this intrinsic is only available on A64.
-    pub a64_only: bool,
-}
+    fn results(&self) -> ArmIntrinsicType {
+        self.results.clone()
+    }
+
+    fn name(&self) -> String {
+        self.name.clone()
+    }
 
-impl Intrinsic {
     /// Generates a std::cout for the intrinsics results that will match the
     /// rust debug output format for the return type. The generated line assumes
     /// there is an int i in scope which is the current pass number.
-    pub fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
-        let lanes = if self.results.num_vectors() > 1 {
-            (0..self.results.num_vectors())
+    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
+        let lanes = if self.results().num_vectors() > 1 {
+            (0..self.results().num_vectors())
                 .map(|vector| {
                     format!(
                         r#""{ty}(" << {lanes} << ")""#,
-                        ty = self.results.c_single_vector_type(),
-                        lanes = (0..self.results.num_lanes())
+                        ty = self.results().c_single_vector_type(),
+                        lanes = (0..self.results().num_lanes())
                             .map(move |idx| -> std::string::String {
                                 format!(
                                     "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
-                                    cast = self.results.c_promotion(),
-                                    lane_fn = self.results.get_lane_function(),
+                                    cast = self.results().c_promotion(),
+                                    lane_fn = self.results().get_lane_function(),
                                     lane = idx,
                                     vector = vector,
                                 )
@@ -45,13 +88,13 @@ impl Intrinsic {
                 })
                 .collect::<Vec<_>>()
                 .join(r#" << ", " << "#)
-        } else if self.results.num_lanes() > 1 {
-            (0..self.results.num_lanes())
+        } else if self.results().num_lanes() > 1 {
+            (0..self.results().num_lanes())
                 .map(|idx| -> std::string::String {
                     format!(
                         "{cast}{lane_fn}(__return_value, {lane})",
-                        cast = self.results.c_promotion(),
-                        lane_fn = self.results.get_lane_function(),
+                        cast = self.results().c_promotion(),
+                        lane_fn = self.results().get_lane_function(),
                         lane = idx
                     )
                 })
@@ -61,22 +104,22 @@ impl Intrinsic {
             format!(
                 "{promote}cast<{cast}>(__return_value)",
                 cast = match self.results.kind() {
-                    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::Poly => format!("poly{}_t", self.results.inner_size()),
+                    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::Poly => format!("poly{}_t", self.results().inner_size()),
                     ty => todo!("print_result_c - Unknown type: {:#?}", ty),
                 },
-                promote = self.results.c_promotion(),
+                promote = self.results().c_promotion(),
             )
         };
 
         format!(
             r#"{indentation}std::cout << "Result {additional}-" << i+1 << ": {ty}" << std::fixed << std::setprecision(150) <<  {lanes} << "{close}" << std::endl;"#,
-            ty = if self.results.is_simd() {
-                format!("{}(", self.results.c_type())
+            ty = if self.results().is_simd() {
+                format!("{}(", self.results().c_type())
             } else {
                 String::from("")
             },

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

@@ -1,6 +1,8 @@
-use super::argument::{Argument, ArgumentList};
-use super::intrinsic::Intrinsic;
-use super::types::IntrinsicType;
+use super::constraint::Constraint;
+use super::intrinsic::ArmIntrinsicType;
+use crate::common::argument::{Argument, ArgumentList};
+use crate::common::intrinsic::Intrinsic;
+use crate::common::intrinsic_types::{IntrinsicType, IntrinsicTypeDefinition};
 use serde::Deserialize;
 use serde_json::Value;
 use std::collections::HashMap;
@@ -53,7 +55,7 @@ struct JsonIntrinsic {
 pub fn get_neon_intrinsics(
     filename: &Path,
     target: &String,
-) -> Result<Vec<Intrinsic>, Box<dyn std::error::Error>> {
+) -> Result<Vec<Intrinsic<ArmIntrinsicType, Constraint>>, Box<dyn std::error::Error>> {
     let file = std::fs::File::open(filename)?;
     let reader = std::io::BufReader::new(file);
     let json: Vec<JsonIntrinsic> = serde_json::from_reader(reader).expect("Couldn't parse JSON");
@@ -74,37 +76,39 @@ pub fn get_neon_intrinsics(
 fn json_to_intrinsic(
     mut intr: JsonIntrinsic,
     target: &String,
-) -> Result<Intrinsic, Box<dyn std::error::Error>> {
+) -> Result<Intrinsic<ArmIntrinsicType, Constraint>, Box<dyn std::error::Error>> {
     let name = intr.name.replace(['[', ']'], "");
 
-    let results = IntrinsicType::from_c(&intr.return_type.value, target)?;
+    let results = ArmIntrinsicType::from_c(&intr.return_type.value, target)?;
 
     let args = intr
         .arguments
         .into_iter()
         .enumerate()
         .map(|(i, arg)| {
-            // let arg_name = Argument::type_and_name_from_c(&arg).1;
-            let mut arg = Argument::from_c(i, &arg, target, intr.args_prep.as_mut());
+            let arg_name = Argument::<ArmIntrinsicType, Constraint>::type_and_name_from_c(&arg).1;
+            let metadata = intr.args_prep.as_mut();
+            let metadata = metadata.and_then(|a| a.remove(arg_name));
+            let mut arg =
+                Argument::<ArmIntrinsicType, Constraint>::from_c(i, &arg, target, metadata);
+
             // The JSON doesn't list immediates as const
-            if let IntrinsicType::Type {
+            let IntrinsicType {
                 ref mut constant, ..
-            } = arg.ty
-            {
-                if arg.name.starts_with("imm") {
-                    *constant = true
-                }
+            } = arg.ty.0;
+            if arg.name.starts_with("imm") {
+                *constant = true
             }
             arg
         })
         .collect();
 
-    let arguments = ArgumentList { args };
+    let arguments = ArgumentList::<ArmIntrinsicType, Constraint> { args };
 
     Ok(Intrinsic {
         name,
         arguments,
-        results,
+        results: *results,
         a64_only: intr.architectures == vec!["A64".to_string()],
     })
 }