intrinsic-test: add SVE-specific constraints

Author: davidtwco

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

@@ -3,7 +3,7 @@ use crate::arm::types::parse_intrinsic_type;
 use crate::common::argument::{Argument, ArgumentList};
 use crate::common::constraint::Constraint;
 use crate::common::intrinsic::Intrinsic;
-use crate::common::intrinsic_helpers::IntrinsicType;
+use crate::common::intrinsic_helpers::{IntrinsicType, TypeKind};
 use serde::Deserialize;
 use serde_json::Value;
 use std::collections::HashMap;
@@ -90,18 +90,37 @@ fn json_to_intrinsic(
         .enumerate()
         .map(|(i, arg)| {
             let (type_name, arg_name) = Argument::<ArmIntrinsicType>::type_and_name_from_c(&arg);
+
+            let arg_ty = parse_intrinsic_type(type_name)
+                .unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
+
             let metadata = intr.args_prep.as_mut();
             let metadata = metadata.and_then(|a| a.remove(arg_name));
             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 arg_ty = ArmIntrinsicType(
-                parse_intrinsic_type(type_name)
-                    .unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'")),
+            let constraint: Option<Constraint> =
+                arg_prep.and_then(|a| a.try_into().ok()).or_else(|| {
+                    if arg_ty.kind() == TypeKind::SvPattern {
+                        Some(Constraint::SvPattern)
+                    } else if arg_ty.kind() == TypeKind::SvPrefetchOp {
+                        Some(Constraint::SvPrefetchOp)
+                    } else if arg_name == "imm_rotation" {
+                        if name.starts_with("svcadd_") || name.starts_with("svqcadd_") {
+                            Some(Constraint::SvImmRotationAdd)
+                        } else {
+                            Some(Constraint::SvImmRotation)
+                        }
+                    } else {
+                        None
+                    }
+                });
+
+            let mut arg = Argument::<ArmIntrinsicType>::new(
+                i,
+                String::from(arg_name),
+                ArmIntrinsicType(arg_ty),
+                constraint,
             );
 
-            let mut arg =
-                Argument::<ArmIntrinsicType>::new(i, String::from(arg_name), arg_ty, constraint);
-
             // The JSON doesn't list immediates as const
             let IntrinsicType {
                 ref mut constant, ..

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

@@ -10,15 +10,34 @@ pub enum Constraint {
     Range(Range<i64>),
     /// Test discrete values, e.g. `vec![1, 2, 4, 8]`.
     Set(Vec<i64>),
+    /// Values of `core::arch::aarch64::svpattern`
+    SvPattern,
+    /// Values of `core::arch::aarch64::svprfop`
+    SvPrefetchOp,
+    // Values of the `imm_rotation` argument in SVE intrinsics where arguments contain complex
+    // pairs and `imm_rotation` corresponds to the rotation.
+    SvImmRotation,
+    // Values of the `imm_rotation` argument in SVE intrinsics where arguments contain complex
+    // pairs and `imm_rotation` corresponds to the rotation (this variant is specifically for
+    // `svcadd` and `svqcadd` where only 90 and 270 are valid arguments).
+    SvImmRotationAdd,
 }
 
 impl Constraint {
     /// Iterate over the values of this constraint.
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = i64> + 'a {
+    pub fn iter(&self) -> Box<dyn Iterator<Item = i64> + '_> {
         match self {
-            Constraint::Equal(i) => std::slice::Iter::default().copied().chain(*i..*i + 1),
-            Constraint::Range(range) => std::slice::Iter::default().copied().chain(range.clone()),
-            Constraint::Set(items) => items.iter().copied().chain(std::ops::Range::default()),
+            Constraint::Equal(i) => Box::new(std::iter::once(*i)),
+            Constraint::Range(range) => Box::new(range.clone()),
+            Constraint::Set(items) => Box::new(items.iter().copied().chain(Range::default())),
+            // These values are discriminants of the `svpattern` enum
+            Constraint::SvPattern => Box::new((0..=13).chain(29..=31)),
+            // These values are discriminants of the `svprfop` enum
+            Constraint::SvPrefetchOp => Box::new((0..=5).chain(8..=14)),
+            // Valid rotations for intrinsics operating on complex pairs: 0, 90, 180, 270
+            Constraint::SvImmRotation => Box::new((0..=270).step_by(90)),
+            // Valid rotations for `svcadd` and `svqcadd`: 0, 270
+            Constraint::SvImmRotationAdd => Box::new((90..=270).step_by(180)),
         }
     }
 }