feat: updated Argument<T> type for functional compatibility with other

architectures too

Author: madhav-madhusoodanan

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

@@ -0,0 +1,12 @@
+use crate::arm::intrinsic::ArmIntrinsicType;
+use crate::common::argument::Argument;
+
+impl Argument<ArmIntrinsicType> {
+    pub fn type_and_name_from_c(arg: &str) -> (&str, &str) {
+        let split_index = arg
+            .rfind([' ', '*'])
+            .expect("Couldn't split type and argname");
+
+        (arg[..split_index + 1].trim_end(), &arg[split_index + 1..])
+    }
+}

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

@@ -86,13 +86,16 @@ fn json_to_intrinsic(
         .into_iter()
         .enumerate()
         .map(|(i, arg)| {
-            let arg_name = Argument::<ArmIntrinsicType>::type_and_name_from_c(&arg).1;
+            let (type_name, arg_name) = Argument::<ArmIntrinsicType>::type_and_name_from_c(&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 ty = ArmIntrinsicType::from_c(type_name, target)
+                .unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
 
-            let mut arg = Argument::<ArmIntrinsicType>::from_c(i, &arg, target, constraint);
+            let mut arg =
+                Argument::<ArmIntrinsicType>::new(i, String::from(arg_name), ty, constraint);
 
             // The JSON doesn't list immediates as const
             let IntrinsicType {

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

@@ -1,10 +1,11 @@
+mod argument;
 mod compile;
 mod config;
 mod intrinsic;
 mod json_parser;
 mod types;
 
-use std::fs::File;
+use std::fs::{self, File};
 
 use rayon::prelude::*;
 
@@ -72,6 +73,7 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         let cpp_compiler_wrapped = compile::build_cpp_compilation(&self.cli_options);
 
         let notice = &build_notices("// ");
+        fs::create_dir_all("c_programs").unwrap();
         self.intrinsics
             .par_chunks(chunk_size)
             .enumerate()
@@ -81,7 +83,7 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
                 write_mod_cpp(&mut file, notice, c_target, platform_headers, chunk).unwrap();
 
                 // compile this cpp file into a .o file
-                if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {  
+                if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
                     let output = cpp_compiler
                         .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
                     assert!(output.status.success(), "{output:?}");
@@ -104,17 +106,17 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         // This is done because `cpp_compiler_wrapped` is None when
         // the --generate-only flag is passed
         if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
-        // compile this cpp file into a .o file
+            // compile this cpp file into a .o file
             info!("compiling main.cpp");
             let output = cpp_compiler
                 .compile_object_file("main.cpp", "intrinsic-test-programs.o")
                 .unwrap();
             assert!(output.status.success(), "{output:?}");
-    
+
             let object_files = (0..chunk_count)
                 .map(|i| format!("mod_{i}.o"))
                 .chain(["intrinsic-test-programs.o".to_owned()]);
-    
+
             let output = cpp_compiler
                 .link_executable(object_files, "intrinsic-test-programs")
                 .unwrap();

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

@@ -20,6 +20,15 @@ impl<T> Argument<T>
 where
     T: IntrinsicTypeDefinition,
 {
+    pub fn new(pos: usize, name: String, ty: T, constraint: Option<Constraint>) -> Self {
+        Argument {
+            pos,
+            name,
+            ty,
+            constraint,
+        }
+    }
+
     pub fn to_c_type(&self) -> String {
         self.ty.c_type()
     }
@@ -36,14 +45,6 @@ where
         self.constraint.is_some()
     }
 
-    pub fn type_and_name_from_c(arg: &str) -> (&str, &str) {
-        let split_index = arg
-            .rfind([' ', '*'])
-            .expect("Couldn't split type and argname");
-
-        (arg[..split_index + 1].trim_end(), &arg[split_index + 1..])
-    }
-
     /// The binding keyword (e.g. "const" or "let") for the array of possible test inputs.
     fn rust_vals_array_binding(&self) -> impl std::fmt::Display {
         if self.ty.is_rust_vals_array_const() {
@@ -62,25 +63,6 @@ where
         }
     }
 
-    pub fn from_c(
-        pos: usize,
-        arg: &str,
-        target: &str,
-        constraint: Option<Constraint>,
-    ) -> Argument<T> {
-        let (ty, var_name) = Self::type_and_name_from_c(arg);
-
-        let ty =
-            T::from_c(ty, target).unwrap_or_else(|_| panic!("Failed to parse argument '{arg}'"));
-
-        Argument {
-            pos,
-            name: String::from(var_name),
-            ty: ty,
-            constraint,
-        }
-    }
-
     fn as_call_param_c(&self) -> String {
         self.ty.as_call_param_c(&self.name)
     }

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

@@ -130,8 +130,8 @@ pub fn compile_rust_programs(toolchain: Option<&str>, target: &str, linker: Opti
     /* If there has been a linker explicitly set from the command line then
      * we want to set it via setting it in the RUSTFLAGS*/
 
-     // This is done because `toolchain` is None when
-     // the --generate-only flag is passed
+    // This is done because `toolchain` is None when
+    // the --generate-only flag is passed
     if toolchain.is_none() {
         return true;
     }