intrinsic-test: move/rename rust_vals_array_name

Move this function to the `values` module alongside the other functions
related to generation of the test value arrays and rename with a similar
name.

Author: davidtwco

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

@@ -1,7 +1,7 @@
 use itertools::Itertools;
 
 use crate::common::intrinsic_helpers::TypeKind;
-use crate::common::values::{test_values_array, test_values_array_length};
+use crate::common::values::{test_values_array, test_values_array_length, test_values_array_name};
 
 use super::constraint::Constraint;
 use super::gen_rust::PASSES;
@@ -53,17 +53,6 @@ where
         self.constraint.is_some()
     }
 
-    /// Returns a string with the name of the static variable containing test values for intrinsic
-    /// arguments of this type.
-    pub(crate) fn rust_vals_array_name(&self) -> impl std::fmt::Display {
-        let loads = crate::common::gen_rust::PASSES;
-        format!(
-            "{ty}_{load_size}",
-            ty = self.ty.rust_scalar_type().to_uppercase(),
-            load_size = test_values_array_length(&self.ty, loads),
-        )
-    }
-
     /// Should this argument be passed by reference in C wrapper function declarations?
     ///
     /// SIMD types and `f16` are currently passed by reference.
@@ -184,7 +173,7 @@ where
         writeln!(
             w,
             "static {name}: [{ty}; {load_size}] = {values};\n",
-            name = arg.rust_vals_array_name(),
+            name = test_values_array_name(&arg.ty, loads),
             ty = arg.ty.rust_scalar_type(),
             load_size = test_values_array_length(&arg.ty, loads),
             values = test_values_array(&arg.ty, loads)
@@ -208,7 +197,7 @@ where
     ///
     /// Each subsequent argument's first window is started one element further into the array
     /// then the previous.
-    pub fn load_values_rust(&self) -> String {
+    pub fn load_values_rust(&self, loads: u32) -> String {
         self.iter()
             .filter(|&arg| !arg.has_constraint())
             .enumerate()
@@ -217,14 +206,14 @@ where
                     format!(
                         "let {name} = {load}({vals_name}.as_ptr().add((i+{idx}) % {PASSES}) as _);\n",
                         name = arg.generate_name(),
-                        vals_name = arg.rust_vals_array_name(),
+                        vals_name = test_values_array_name(&arg.ty, loads),
                         load = arg.ty.get_load_function(),
                     )
                 } else {
                     format!(
                         "let {name} = {vals_name}[(i+{idx}) % {PASSES}];\n",
                         name = arg.generate_name(),
-                        vals_name = arg.rust_vals_array_name(),
+                        vals_name = test_values_array_name(&arg.ty, loads),
                     )
                 }
             })

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

@@ -7,6 +7,7 @@ use crate::common::argument::ArgumentList;
 use crate::common::cli::{CcArgStyle, ProcessedCli};
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
+use crate::common::values::test_values_array_name;
 
 // The number of times each intrinsic will be called - influences the generation of the
 // test arrays to minimise repeated testing of the same test values.
@@ -135,7 +136,7 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
     for intrinsic in intrinsics {
         for arg in &intrinsic.arguments.args {
             if !arg.has_constraint() {
-                let name = arg.rust_vals_array_name().to_string();
+                let name = test_values_array_name(&arg.ty, PASSES);
 
                 if seen.insert(name) {
                     ArgumentList::gen_arg_rust(arg, w, PASSES)?;
@@ -244,7 +245,7 @@ fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
             "        }}",
             "    }}",
         ),
-        loaded_args = intrinsic.arguments.load_values_rust(),
+        loaded_args = intrinsic.arguments.load_values_rust(passes),
         rust_args = intrinsic.arguments.as_call_param_rust(),
         c_args = intrinsic.arguments.as_c_call_param_rust(),
         passes = passes,

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

@@ -1,10 +1,22 @@
 use itertools::Itertools as _;
 
-use crate::common::intrinsic_helpers::{IntrinsicType, Sign, SimdLen, TypeKind};
+use crate::common::intrinsic_helpers::{
+    IntrinsicType, IntrinsicTypeDefinition, Sign, SimdLen, TypeKind,
+};
 
 /// Maximum size of a SVE vector
 pub const MAX_SVE_BITS: u32 = 2048;
 
+/// Returns a string with the name of the static variable containing test values for intrinsic
+/// arguments of this type.
+pub fn test_values_array_name<T: IntrinsicTypeDefinition>(ty: &T, num_loads: u32) -> String {
+    format!(
+        "{ty}_{load_size}",
+        ty = ty.rust_scalar_type().to_uppercase(),
+        load_size = test_values_array_length(&ty, num_loads),
+    )
+}
+
 /// Returns the elements used in the test value arrays in `gen_arg_rust`. Uses the
 /// `test_values_array_length` fn to determine the number of values that
 /// `ArgumentList::gen_arg_rust` expects and `ArgumentList::load_values_rust` needs.