Remove code for compiling and comparing C and Rust files, made the C files wrappers

Author: sayantn

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

@@ -3,51 +3,6 @@ pub const NOTICE: &str = "\
 // test are derived from a JSON specification, published under the same license as the
 // `intrinsic-test` crate.\n";
 
-pub const PLATFORM_C_FORWARD_DECLARATIONS: &str = r#"
-#ifdef __aarch64__
-std::ostream& operator<<(std::ostream& os, poly128_t value);
-#endif
-
-std::ostream& operator<<(std::ostream& os, float16_t value);
-std::ostream& operator<<(std::ostream& os, uint8_t value);
-
-// T1 is the `To` type, T2 is the `From` type
-template<typename T1, typename T2> T1 cast(T2 x) {
-  static_assert(sizeof(T1) == sizeof(T2), "sizeof T1 and T2 must be the same");
-  T1 ret{};
-  memcpy(&ret, &x, sizeof(T1));
-  return ret;
-}
-"#;
-
-pub const PLATFORM_C_DEFINITIONS: &str = r#"
-#ifdef __aarch64__
-std::ostream& operator<<(std::ostream& os, poly128_t value) {
-    std::stringstream temp;
-    do {
-      int n = value % 10;
-      value /= 10;
-      temp << n;
-    } while (value != 0);
-    std::string tempstr(temp.str());
-    std::string res(tempstr.rbegin(), tempstr.rend());
-    os << res;
-    return os;
-}
-
-#endif
-
-std::ostream& operator<<(std::ostream& os, float16_t value) {
-    os << static_cast<float>(value);
-    return os;
-}
-
-std::ostream& operator<<(std::ostream& os, uint8_t value) {
-    os << (unsigned int) value;
-    return os;
-}
-"#;
-
 pub const PLATFORM_RUST_DEFINITIONS: &str = "";
 
 pub const PLATFORM_RUST_CFGS: &str = r#"

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

@@ -1,13 +1,11 @@
 mod argument;
-mod compile;
 mod config;
 mod intrinsic;
 mod json_parser;
 mod types;
 
 use crate::common::SupportedArchitectureTest;
 use crate::common::cli::ProcessedCli;
-use crate::common::compile_c::CppCompilation;
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
 use intrinsic::ArmIntrinsicType;
@@ -32,18 +30,12 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
     const NOTICE: &str = config::NOTICE;
 
     const PLATFORM_C_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
-    const PLATFORM_C_DEFINITIONS: &str = config::PLATFORM_C_DEFINITIONS;
-    const PLATFORM_C_FORWARD_DECLARATIONS: &str = config::PLATFORM_C_FORWARD_DECLARATIONS;
 
     const PLATFORM_RUST_DEFINITIONS: &str = config::PLATFORM_RUST_DEFINITIONS;
     const PLATFORM_RUST_CFGS: &str = config::PLATFORM_RUST_CFGS;
 
-    fn cpp_compilation(&self) -> Option<CppCompilation> {
-        compile::build_cpp_compilation(&self.cli_options)
-    }
-
     fn create(cli_options: ProcessedCli) -> Self {
-        let a32 = cli_options.target.contains("v7");
+        let a32 = cli_options.target.starts_with("armv7");
         let mut intrinsics = get_neon_intrinsics(&cli_options.filename, &cli_options.target)
             .expect("Error parsing input file");
 

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

@@ -1,6 +1,4 @@
 use super::intrinsic::ArmIntrinsicType;
-use crate::common::cli::Language;
-use crate::common::indentation::Indentation;
 use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, Sign, TypeKind};
 
 impl IntrinsicTypeDefinition for ArmIntrinsicType {
@@ -20,19 +18,8 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
         }
     }
 
-    fn c_single_vector_type(&self) -> String {
-        if let (Some(bit_len), Some(simd_len)) = (self.bit_len, self.simd_len) {
-            format!(
-                "{prefix}{bit_len}x{simd_len}_t",
-                prefix = self.kind.c_prefix()
-            )
-        } else {
-            unreachable!("Shouldn't be called on this type")
-        }
-    }
-
     /// Determines the load function for this type.
-    fn get_load_function(&self, language: Language) -> String {
+    fn get_load_function(&self) -> String {
         if let IntrinsicType {
             kind: k,
             bit_len: Some(bl),
@@ -47,16 +34,13 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                 ""
             };
 
-            let choose_workaround = language == Language::C && self.target.contains("v7");
             format!(
                 "vld{len}{quad}_{type}{size}",
                 type = match k {
                     TypeKind::Int(Sign::Unsigned) => "u",
                     TypeKind::Int(Sign::Signed) => "s",
                     TypeKind::Float => "f",
-                    // The ACLE doesn't support 64-bit polynomial loads on Armv7
-                    // if armv7 and bl == 64, use "s", else "p"
-                    TypeKind::Poly => if choose_workaround && *bl == 64 {"s"} else {"p"},
+                    TypeKind::Poly => "p",
                     x => todo!("get_load_function TypeKind: {x:#?}"),
                 },
                 size = bl,
@@ -67,97 +51,6 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             todo!("get_load_function IntrinsicType: {self:#?}")
         }
     }
-
-    /// Determines the get lane function for this type.
-    fn get_lane_function(&self) -> String {
-        if let IntrinsicType {
-            kind: k,
-            bit_len: Some(bl),
-            simd_len,
-            ..
-        } = &self.data
-        {
-            let quad = if (simd_len.unwrap_or(1) * bl) > 64 {
-                "q"
-            } else {
-                ""
-            };
-            format!(
-                "vget{quad}_lane_{type}{size}",
-                type = match k {
-                    TypeKind::Int(Sign::Unsigned) => "u",
-                    TypeKind::Int(Sign::Signed) => "s",
-                    TypeKind::Float => "f",
-                    TypeKind::Poly => "p",
-                    x => todo!("get_load_function TypeKind: {x:#?}"),
-                },
-                size = bl,
-                quad = quad,
-            )
-        } else {
-            todo!("get_lane_function IntrinsicType: {self:#?}")
-        }
-    }
-
-    /// 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.
-    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
-        let lanes = if self.num_vectors() > 1 {
-            (0..self.num_vectors())
-                .map(|vector| {
-                    format!(
-                        r#""{ty}(" << {lanes} << ")""#,
-                        ty = self.c_single_vector_type(),
-                        lanes = (0..self.num_lanes())
-                            .map(move |idx| -> std::string::String {
-                                let lane_fn = self.get_lane_function();
-                                let final_cast = self.generate_final_type_cast();
-                                format!(
-                                    "{final_cast}{lane_fn}(__return_value.val[{vector}], {idx})"
-                                )
-                            })
-                            .collect::<Vec<_>>()
-                            .join(r#" << ", " << "#)
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join(r#" << ", " << "#)
-        } else if self.num_lanes() > 1 {
-            (0..self.num_lanes())
-                .map(|idx| -> std::string::String {
-                    let lane_fn = self.get_lane_function();
-                    let final_cast = self.generate_final_type_cast();
-                    format!("{final_cast}{lane_fn}(__return_value, {idx})")
-                })
-                .collect::<Vec<_>>()
-                .join(r#" << ", " << "#)
-        } else {
-            format!(
-                "{promote}cast<{cast}>(__return_value)",
-                cast = match self.kind() {
-                    TypeKind::Float if self.inner_size() == 16 => "float16_t".to_string(),
-                    TypeKind::Float if self.inner_size() == 32 => "float".to_string(),
-                    TypeKind::Float if self.inner_size() == 64 => "double".to_string(),
-                    TypeKind::Int(Sign::Signed) => format!("int{}_t", self.inner_size()),
-                    TypeKind::Int(Sign::Unsigned) => format!("uint{}_t", self.inner_size()),
-                    TypeKind::Poly => format!("poly{}_t", self.inner_size()),
-                    ty => todo!("print_result_c - Unknown type: {ty:#?}"),
-                },
-                promote = self.generate_final_type_cast(),
-            )
-        };
-
-        format!(
-            r#"{indentation}std::cout << "Result {additional}-" << i+1 << ": {ty}" << std::fixed << std::setprecision(150) <<  {lanes} << "{close}" << std::endl;"#,
-            ty = if self.is_simd() {
-                format!("{}(", self.c_type())
-            } else {
-                String::from("")
-            },
-            close = if self.is_simd() { ")" } else { "" },
-        )
-    }
 }
 
 impl ArmIntrinsicType {