feat: add C testfile compilation mechanism to loongarch

Author: madhav-madhusoodanan

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

@@ -0,0 +1,29 @@
+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()?;
+
+    // -ffp-contract=off emulates Rust's approach of not fusing separate mul-add operations
+    let mut command = CompilationCommandBuilder::new()
+        .set_compiler(cpp_compiler)
+        .set_target(&config.target)
+        .set_opt_level("2")
+        .set_cxx_toolchain_dir(config.cxx_toolchain_dir.as_deref())
+        .set_project_root("c_programs")
+        .add_extra_flags(vec![
+            "-ffp-contract=off",
+            "-Wno-narrowing",
+            "-mlasx",
+            "-mlsx",
+            "-mfrecipe",
+        ]);
+
+    if !cpp_compiler.contains("clang") {
+        command = command.add_extra_flag("-flax-vector-conversions");
+    }
+
+    let cpp_compiler = command.into_cpp_compilation();
+
+    Some(cpp_compiler)
+}

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

@@ -0,0 +1,9 @@
+pub fn build_notices(line_prefix: &str) -> String {
+    format!(
+        "\
+{line_prefix}This is a transient test file, not intended for distribution. Some aspects of the
+{line_prefix}test are derived from `stdarch-gen-loongarch/lsx.spec` and `stdarch-gen-loongarch/lasx.spec`, 
+{line_prefix}published under the same license as the `intrinsic-test` crate.\n
+"
+    )
+}

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

@@ -1,3 +1,5 @@
+mod compile;
+mod config;
 mod intrinsic;
 mod parser;
 mod types;
@@ -6,12 +8,14 @@ use std::fs::{self, File};
 
 use rayon::prelude::*;
 
-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::intrinsic_helpers::TypeKind;
+use crate::common::{SupportedArchitectureTest, chunk_info};
 
 use crate::common::intrinsic::Intrinsic;
+use crate::loongarch::config::build_notices;
 use crate::loongarch::parser::get_loongson_intrinsics;
 use intrinsic::LoongArchIntrinsicType;
 
@@ -42,7 +46,68 @@ impl SupportedArchitectureTest for LoongArchArchitectureTest {
     }
 
     fn build_c_file(&self) -> bool {
-        unimplemented!("build_c_file of LoongArchIntrinsicType is not defined!")
+        let c_target = "loongarch";
+        let platform_headers = &["lasxintrin.h", "lsxintrin.h"];
+
+        let (chunk_size, chunk_count) = chunk_info(self.intrinsics.len());
+
+        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()
+            .map(|(i, chunk)| {
+                let c_filename = format!("c_programs/mod_{i}.cpp");
+                let mut file = 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.
+                //
+                // 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() {
+                    let output = cpp_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 = File::create("c_programs/main.cpp").unwrap();
+        write_main_cpp(
+            &mut file,
+            c_target,
+            "\n",
+            self.intrinsics.iter().map(|i| i.name.as_str()),
+        )
+        .unwrap();
+
+        // 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
+            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();
+            assert!(output.status.success(), "{output:?}");
+        }
+
+        true
     }
 
     fn build_rust_file(&self) -> bool {