Fixed merge conflicts with master

Author: madhav-madhusoodanan

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

@@ -10,14 +10,14 @@ use std::fs;
 use rayon::prelude::*;
 
 use crate::arm::config::POLY128_OSTREAM_DEF;
-use crate::common::SupportedArchitectureTest;
 use crate::common::cli::ProcessedCli;
 use crate::common::compare::compare_outputs;
 use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
 use crate::common::gen_rust::compile_rust_programs;
 use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::write_file::write_rust_testfiles;
+use crate::common::{SupportedArchitectureTest, chunk_info};
 use config::{AARCH_CONFIGURATIONS, F16_FORMATTING_DEF, build_notices};
 use intrinsic::ArmIntrinsicType;
 use json_parser::get_neon_intrinsics;
@@ -27,13 +27,6 @@ pub struct ArmArchitectureTest {
     cli_options: ProcessedCli,
 }
 
-fn chunk_info(intrinsic_count: usize) -> (usize, usize) {
-    let available_parallelism = std::thread::available_parallelism().unwrap().get();
-    let chunk_size = intrinsic_count.div_ceil(Ord::min(available_parallelism, intrinsic_count));
-
-    (chunk_size, intrinsic_count.div_ceil(chunk_size))
-}
-
 impl SupportedArchitectureTest for ArmArchitectureTest {
     fn create(cli_options: ProcessedCli) -> Box<Self> {
         let a32 = cli_options.target.contains("v7");
@@ -102,6 +95,7 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             &mut file,
             c_target,
             POLY128_OSTREAM_DEF,
+            Vec::from(platform_headers),
             self.intrinsics.iter().map(|i| i.name.as_str()),
         )
         .unwrap();

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

@@ -121,7 +121,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
         }
     }
 
-    fn from_c(s: &str, target: &str) -> Result<Self, String> {
+    fn from_c(s: &str) -> Result<Self, String> {
         const CONST_STR: &str = "const";
         let mut metadata: HashMap<String, String> = HashMap::new();
         metadata.insert("type".to_string(), s.to_string());
@@ -131,7 +131,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                 None => (s, false),
             };
             let s = s.trim_end();
-            let temp_return = ArmIntrinsicType::from_c(s, target);
+            let temp_return = ArmIntrinsicType::from_c(s);
             temp_return.map(|mut op| {
                 op.ptr = true;
                 op.ptr_constant = constant;
@@ -172,7 +172,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     bit_len: Some(bit_len),
                     simd_len,
                     vec_len,
-                    target: target.to_string(),
+                    metadata,
                 }))
             } else {
                 let kind = start.parse::<TypeKind>()?;
@@ -188,7 +188,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     bit_len,
                     simd_len: None,
                     vec_len: None,
-                    target: target.to_string(),
+                    metadata,
                 }))
             }
         }

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

@@ -63,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_c.rs

@@ -40,7 +40,7 @@ pub fn generate_c_constraint_blocks<'a, T: IntrinsicTypeDefinition + 'a>(
     };
 
     let body_indentation = indentation.nested();
-    for i in current.constraint.iter().flat_map(|c| c.to_range()) {
+    for i in current.constraint.iter().flat_map(|c| c.to_vector()) {
         let ty = current.ty.c_type();
 
         writeln!(w, "{indentation}{{")?;
@@ -140,12 +140,13 @@ pub fn write_main_cpp<'a>(
     w: &mut impl std::io::Write,
     architecture: &str,
     arch_specific_definitions: &str,
+    headers: Vec<&str>,
     intrinsics: impl Iterator<Item = &'a str> + Clone,
 ) -> std::io::Result<()> {
     writeln!(w, "#include <iostream>")?;
     writeln!(w, "#include <string>")?;
 
-    for header in ["arm_neon.h", "arm_acle.h", "arm_fp16.h"] {
+    for header in headers.iter() {
         writeln!(w, "#include <{header}>")?;
     }
 

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

@@ -332,7 +332,7 @@ pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
     fn get_lane_function(&self) -> String;
 
     /// can be implemented in an `impl` block
-    fn from_c(_s: &str, _target: &str) -> Result<Self, String>
+    fn from_c(_s: &str) -> Result<Self, String>
     where
         Self: Sized;
 

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

@@ -23,3 +23,10 @@ pub trait SupportedArchitectureTest {
     fn build_rust_file(&self) -> bool;
     fn compare_outputs(&self) -> bool;
 }
+
+pub fn chunk_info(intrinsic_count: usize) -> (usize, usize) {
+    let available_parallelism = std::thread::available_parallelism().unwrap().get();
+    let chunk_size = intrinsic_count.div_ceil(Ord::min(available_parallelism, intrinsic_count));
+
+    (chunk_size, intrinsic_count.div_ceil(chunk_size))
+}

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

@@ -1,12 +1,9 @@
-use crate::common::compile_c::CompilationCommandBuilder;
-use crate::common::gen_c::compile_c_programs;
+use crate::common::cli::ProcessedCli;
+use crate::common::compile_c::{CompilationCommandBuilder, CppCompilation};
+
+pub fn build_cpp_compilation(config: &ProcessedCli) -> Option<CppCompilation> {
+    let cpp_compiler = config.cpp_compiler.as_ref()?;
 
-pub fn compile_c_x86(
-    intrinsics_name_list: &[String],
-    compiler: &str,
-    target: &str,
-    cxx_toolchain_dir: Option<&str>,
-) -> bool {
     // -ffp-contract=off emulates Rust's approach of not fusing separate mul-add operations
     let mut command = CompilationCommandBuilder::new()
         .add_arch_flags(vec![
@@ -24,55 +21,27 @@ pub fn compile_c_x86(
             "adx",
             "aes",
         ])
-        .set_compiler(compiler)
-        .set_target(target)
+        .set_compiler(cpp_compiler)
+        .set_target(&config.target)
         .set_opt_level("2")
-        .set_cxx_toolchain_dir(cxx_toolchain_dir)
+        .set_cxx_toolchain_dir(config.cxx_toolchain_dir.as_deref())
         .set_project_root("c_programs")
         .add_extra_flags(vec!["-ffp-contract=off", "-Wno-narrowing"]);
 
-    // if !target.contains("64") {
-    //     command = command.add_arch_flags(vec!["faminmax", "lut", "sha3"]);
-    // }
-
-    /*
-     * clang++ cannot link an aarch64_be object file, so we invoke
-     * aarch64_be-unknown-linux-gnu's C++ linker. This ensures that we
-     * are testing the intrinsics against LLVM.
-     *
-     * Note: setting `--sysroot=<...>` which is the obvious thing to do
-     * does not work as it gets caught up with `#include_next <stdlib.h>`
-     * not existing...
-     */
-    // if target.contains("aarch64_be") {
-    //     command = command
-    //         .set_linker(
-    //             cxx_toolchain_dir.unwrap_or("").to_string() + "/bin/aarch64_be-none-linux-gnu-g++",
-    //         )
-    //         .set_include_paths(vec![
-    //             "/include",
-    //             "/aarch64_be-none-linux-gnu/include",
-    //             "/aarch64_be-none-linux-gnu/include/c++/14.2.1",
-    //             "/aarch64_be-none-linux-gnu/include/c++/14.2.1/aarch64_be-none-linux-gnu",
-    //             "/aarch64_be-none-linux-gnu/include/c++/14.2.1/backward",
-    //             "/aarch64_be-none-linux-gnu/libc/usr/include",
-    //         ]);
-    // }
-
-    if !compiler.contains("clang") {
+    if !cpp_compiler.contains("clang") {
         command = command.add_extra_flag("-flax-vector-conversions");
     }
 
-    let compiler_commands = intrinsics_name_list
-        .iter()
-        .map(|intrinsic_name| {
-            command
-                .clone()
-                .set_input_name(intrinsic_name)
-                .set_output_name(intrinsic_name)
-                .make_string()
-        })
-        .collect::<Vec<_>>();
+    let cpp_compiler = command.into_cpp_compilation();
+
+    // if config.target.contains("aarch64_be") {
+    //     let Some(ref cxx_toolchain_dir) = config.cxx_toolchain_dir else {
+    //         panic!(
+    //             "target `{}` must specify `cxx_toolchain_dir`",
+    //             config.target
+    //         )
+    //     };
+    // }
 
-    compile_c_programs(&compiler_commands)
+    Some(cpp_compiler)
 }

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

@@ -5,14 +5,17 @@ mod intrinsic;
 mod types;
 mod xml_parser;
 
-use crate::common::SupportedArchitectureTest;
+use rayon::prelude::*;
+use std::fs;
+
 use crate::common::cli::ProcessedCli;
 use crate::common::compare::compare_outputs;
+use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
 use crate::common::gen_rust::compile_rust_programs;
 use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
 use crate::common::intrinsic_helpers::TypeKind;
-use crate::common::write_file::{write_c_testfiles, write_rust_testfiles};
-use crate::x86::compile::compile_c_x86;
+use crate::common::write_file::write_rust_testfiles;
+use crate::common::{SupportedArchitectureTest, chunk_info};
 use crate::x86::config::{F16_FORMATTING_DEF, X86_CONFIGURATIONS};
 use config::build_notices;
 use intrinsic::X86IntrinsicType;
@@ -54,26 +57,66 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
         let target = &self.cli_options.target;
         let cxx_toolchain_dir = self.cli_options.cxx_toolchain_dir.as_deref();
         let c_target = "x86_64";
+        let (chunk_size, chunk_count) = chunk_info(self.intrinsics.len());
+        let notice = &build_notices("// ");
+        let platform_headers = &["immintrin.h"];
 
-        let intrinsics_name_list = write_c_testfiles(
-            &self
-                .intrinsics
-                .iter()
-                .map(|i| i as &dyn IntrinsicDefinition<_>)
-                .collect::<Vec<_>>(),
-            target,
+        let cpp_compiler = compile::build_cpp_compilation(&self.cli_options);
+
+        match fs::exists("c_programs") {
+            Ok(false) => fs::create_dir("c_programs").unwrap(),
+            Ok(true) => {}
+            _ => return false,
+        }
+
+        self.intrinsics
+            .par_chunks(chunk_size)
+            .enumerate()
+            .map(|(i, chunk)| {
+                let c_filename = format!("c_programs/mod_{i}.cpp");
+                let mut file = fs::File::create(&c_filename).unwrap();
+                write_mod_cpp(&mut file, notice, c_target, platform_headers, chunk).unwrap();
+
+                // compile this cpp file into a .o file
+                if let Some(compiler) = cpp_compiler.as_ref() {
+                    let output = compiler
+                        .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
+                    assert!(output.status.success(), "{output:?}");
+                }
+                Ok(())
+            })
+            .collect::<Result<(), std::io::Error>>()
+            .unwrap();
+
+        let mut file = fs::File::create("c_programs/main.cpp").unwrap();
+        write_main_cpp(
+            &mut file,
             c_target,
-            &["immintrin.h"],
-            &build_notices("// "),
-            &[],
-        );
+            "",
+            Vec::from(platform_headers),
+            self.intrinsics.iter().map(|i| i.name.as_str()),
+        )
+        .unwrap();
 
-        match compiler {
-            None => true,
-            Some(compiler) => {
-                compile_c_x86(&intrinsics_name_list, compiler, target, cxx_toolchain_dir)
-            }
+        // compile this cpp file into a .o file
+        if let Some(compiler) = cpp_compiler.as_ref() {
+            info!("compiling main.cpp");
+            let output = 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 = compiler
+                .link_executable(object_files, "intrinsic-test-programs")
+                .unwrap();
+            assert!(output.status.success(), "{output:?}");
         }
+
+        true
     }
 
     fn build_rust_file(&self) -> bool {
@@ -102,7 +145,7 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
     }
 
     fn compare_outputs(&self) -> bool {
-        if let Some(ref toolchain) = self.cli_options.toolchain {
+        if self.cli_options.toolchain.is_some() {
             let intrinsics_name_list = self
                 .intrinsics
                 .iter()
@@ -111,8 +154,7 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
 
             compare_outputs(
                 &intrinsics_name_list,
-                toolchain,
-                &self.cli_options.c_runner,
+                &self.cli_options.runner,
                 &self.cli_options.target,
             )
         } else {