moved the C compilation commands into a struct for easier handling

Author: madhav-madhusoodanan

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

@@ -2,6 +2,7 @@ use super::config::{AARCH_CONFIGURATIONS, POLY128_OSTREAM_DEF, build_notices};
 use super::intrinsic::ArmIntrinsicType;
 use crate::arm::constraint::Constraint;
 use crate::common::argument::Argument;
+use crate::common::compile_c::CompilationCommandBuilder;
 use crate::common::format::Indentation;
 use crate::common::gen_c::{compile_c, create_c_filenames, generate_c_program};
 use crate::common::gen_rust::{compile_rust, create_rust_filenames, generate_rust_program};
@@ -161,70 +162,50 @@ fn generate_rust_program_arm(
 
 fn compile_c_arm(
     intrinsics_name_list: &Vec<String>,
-    filename_mapping: BTreeMap<&String, String>,
+    _filename_mapping: BTreeMap<&String, String>,
     compiler: &str,
     target: &str,
     cxx_toolchain_dir: Option<&str>,
 ) -> bool {
     let compiler_commands = intrinsics_name_list.iter().map(|intrinsic_name| {
-        let c_filename = filename_mapping.get(intrinsic_name).unwrap();
-        let flags = std::env::var("CPPFLAGS").unwrap_or("".into());
-        let arch_flags = if target.contains("v7") {
-            "-march=armv8.6-a+crypto+crc+dotprod+fp16"
+        let mut command = CompilationCommandBuilder::new();
+        if target.contains("v7") {
+            command.set_arch_flags(vec!["armv8.6-a", "crypto", "crc", "dotprod", "fp16"])
         } else {
-            "-march=armv8.6-a+crypto+sha3+crc+dotprod+fp16+faminmax+lut"
+            command.set_arch_flags(vec!["armv8.6-a", "crypto", "crc", "dotprod", "fp16", "sha3", "faminmax", "lut"])
         };
 
-        let compiler_command = if target == "aarch64_be-unknown-linux-gnu" {
-            let Some(cxx_toolchain_dir) = cxx_toolchain_dir else {
-                panic!(
-                    "When setting `--target aarch64_be-unknown-linux-gnu` the C++ compilers toolchain directory must be set with `--cxx-toolchain-dir <dest>`"
-                );
-            };
+        command = command
+            .set_compiler(compiler)
+            .set_output_name(intrinsic_name)
+            .set_target(target)
+            .set_opt_level("2")
+            .set_cxx_toolchain_dir(cxx_toolchain_dir)
+            .set_project_root("c_programs")
+            .set_input_name(intrinsic_name)
+            .add_extra_flags(vec!["-ffp-contract=off", "-Wno-narrowing"]);
 
-            /* 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... */
-            format!(
-                "{compiler} {flags} {arch_flags} \
-                -ffp-contract=off \
-                -Wno-narrowing \
-                -O2 \
-                --target=aarch64_be-unknown-linux-gnu \
-                -I{cxx_toolchain_dir}/include \
-                -I{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/include \
-                -I{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/include/c++/14.2.1 \
-                -I{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/include/c++/14.2.1/aarch64_be-none-linux-gnu \
-                -I{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/include/c++/14.2.1/backward \
-                -I{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/libc/usr/include \
-                -c {c_filename} \
-                -o c_programs/{intrinsic_name}.o && \
-                {cxx_toolchain_dir}/bin/aarch64_be-none-linux-gnu-g++ c_programs/{intrinsic_name}.o -o c_programs/{intrinsic_name} && \
-                rm c_programs/{intrinsic_name}.o",
-            )
+        command = if target == "aarch64_be-unknown-linux-gnu" {
+            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"
+                ])
         } else {
-            // -ffp-contract=off emulates Rust's approach of not fusing separate mul-add operations
-            let base_compiler_command = format!(
-                "{compiler} {flags} {arch_flags} -o c_programs/{intrinsic_name} {c_filename} -ffp-contract=off -Wno-narrowing -O2"
-            );
-
-            /* `-target` can be passed to some c++ compilers, however if we want to
-             *   use a c++ compiler does not support this flag we do not want to pass
-             *   the flag. */
             if compiler.contains("clang") {
-                format!("{base_compiler_command} -target {target}")
+                command.add_extra_flag(format!("-target {target}").as_str())
             } else {
-                format!("{base_compiler_command} -flax-vector-conversions")
+                command.add_extra_flag("-flax-vector-conversions")
             }
         };
 
-        compiler_command
-    })
-    .collect::<Vec<_>>();
+        command.as_str()
+    }).collect::<Vec<_>>();
 
     compile_c(&compiler_commands)
 }

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

@@ -0,0 +1,136 @@
+pub struct CompilationCommandBuilder {
+    compiler: String,
+    target: Option<String>,
+    cxx_toolchain_dir: Option<String>,
+    arch_flags: Vec<String>,
+    optimization: String,
+    include_paths: Vec<String>,
+    project_root: Option<String>,
+    output: String,
+    input: String,
+    linker: Option<String>,
+    extra_flags: Vec<String>,
+}
+
+impl CompilationCommandBuilder {
+    pub fn new() -> Self {
+        Self {
+            compiler: String::new(),
+            target: None,
+            cxx_toolchain_dir: None,
+            arch_flags: Vec::new(),
+            optimization: "2".to_string(),
+            include_paths: Vec::new(),
+            project_root: None,
+            output: String::new(),
+            input: String::new(),
+            linker: None,
+            extra_flags: Vec::new(),
+        }
+    }
+
+    pub fn set_compiler(mut self, compiler: &str) -> Self {
+        self.compiler = compiler.to_string();
+        self
+    }
+
+    pub fn set_target(mut self, target: &str) -> Self {
+        self.target = Some(target.to_string());
+        self
+    }
+
+    pub fn set_cxx_toolchain_dir(mut self, path: Option<&str>) -> Self {
+        self.cxx_toolchain_dir = path.map(|p| p.to_string());
+        self
+    }
+
+    pub fn set_arch_flags(&mut self, flags: Vec<&str>) {
+        self.arch_flags = flags.iter().map(|v| v.to_string()).collect();
+    }
+
+    pub fn set_opt_level(mut self, optimization: &str) -> Self {
+        self.optimization = optimization.to_string();
+        self
+    }
+
+    pub fn set_include_paths(mut self, paths: Vec<&str>) -> Self {
+        self.include_paths = paths
+            .into_iter()
+            .map(|path| path.to_string())
+            .collect();
+        self
+    }
+
+    pub fn set_project_root(mut self, path: &str) -> Self {
+        self.project_root = Some(path.to_string());
+        self
+    }
+
+    pub fn set_output_name(mut self, path: &str) -> Self {
+        self.output = path.to_string();
+        self
+    }
+
+    pub fn set_input_name(mut self, path: &str) -> Self {
+        self.input = path.to_string();
+        self
+    }
+
+    pub fn set_linker(mut self, linker: String) -> Self {
+        self.linker = Some(linker);
+        self.output += ".o";
+        self 
+    }
+
+    pub fn add_extra_flags(mut self, flags: Vec<&str>) -> Self {
+        let mut flags: Vec<String> = flags.into_iter().map(|f| f.to_string()).collect();
+        self.extra_flags.append(&mut flags);
+        self
+    }
+
+    pub fn add_extra_flag(self, flag: &str) -> Self {
+        self.add_extra_flags(vec![flag])
+    }
+}
+
+impl CompilationCommandBuilder {
+    pub fn as_str(self) -> String {
+        let arch_flags = self.arch_flags.join("+");
+        let flags = std::env::var("CPPFLAGS").unwrap_or("".into());
+        let project_root = self.project_root.unwrap_or(String::new());
+        let project_root_str = project_root.as_str();
+        let mut command = format!(
+            "{} {flags} -march={arch_flags} \
+            -O{} \
+            -o {project_root}/{} \
+            {project_root}/{}.cpp",
+            self.compiler,
+            self.optimization,
+            self.output,
+            self.input,
+        );
+
+        command = command
+            + " " + self.extra_flags.join(" ").as_str();
+        
+        if let (Some(linker), Some(cxx_toolchain_dir)) = (&self.linker, &self.cxx_toolchain_dir) {
+            if let Some(target) = &self.target {
+                command = command + " --target=" + target;
+            }
+
+            let include_args = self.include_paths
+                .iter()
+                .map(|path| "--include-directory=".to_string() + cxx_toolchain_dir + path)
+                .collect::<Vec<_>>()
+                .join(" ");
+
+            command = command + " -c "
+                + " " + include_args.as_str()
+                + "&& " + linker + project_root_str + "/" + self.output.as_str()
+                + " -o " + project_root_str + "/" + self.output.strip_suffix(".o").unwrap()
+                + " && " + "rm " + project_root_str + "/" + self.output.as_str();
+        }
+
+        command
+    }
+}

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

@@ -4,6 +4,7 @@ use std::io::Write;
 
 pub mod argument;
 pub mod compare;
+pub mod compile_c;
 pub mod format;
 pub mod gen_c;
 pub mod gen_rust;