get rid of custom linker setup

Author: folkertdev

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

@@ -18,15 +18,12 @@ pub fn build_cpp_compilation(config: &ProcessedCli) -> Option<CppCompilation> {
         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 !cpp_compiler.contains("clang") {
+        command = command.add_extra_flag("-flax-vector-conversions");
+    }
+
+    let mut cpp_compiler = command.into_cpp_compilation();
+
     if config.target.contains("aarch64_be") {
         let Some(ref cxx_toolchain_dir) = config.cxx_toolchain_dir else {
             panic!(
@@ -35,27 +32,20 @@ pub fn build_cpp_compilation(config: &ProcessedCli) -> Option<CppCompilation> {
             )
         };
 
-        let linker = if let Some(ref linker) = config.linker {
-            linker.to_owned()
-        } else {
-            format!("{cxx_toolchain_dir}/bin/aarch64_be-none-linux-gnu-g++")
-        };
-
-        trace!("using linker: {linker}");
-
-        command = command.set_linker(linker).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",
+        cpp_compiler.command_mut().args([
+            &format!("--sysroot={cxx_toolchain_dir}/aarch64_be-none-linux-gnu/libc"),
+            "--include-directory",
+            &format!("{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/include/c++/14.2.1"),
+            "--include-directory",
+            &format!("{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/include/c++/14.2.1/aarch64_be-none-linux-gnu"),
+            "-L",
+            &format!("{cxx_toolchain_dir}/lib/gcc/aarch64_be-none-linux-gnu/14.2.1"),
+            "-L",
+            &format!("{cxx_toolchain_dir}/aarch64_be-none-linux-gnu/libc/usr/lib"),
+            "-B",
+            &format!("{cxx_toolchain_dir}/lib/gcc/aarch64_be-none-linux-gnu/14.2.1"),
         ]);
     }
 
-    if !cpp_compiler.contains("clang") {
-        command = command.add_extra_flag("-flax-vector-conversions");
-    }
-
-    Some(command.into_cpp_compilation())
+    Some(cpp_compiler)
 }

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

@@ -5,9 +5,7 @@ pub struct CompilationCommandBuilder {
     cxx_toolchain_dir: Option<String>,
     arch_flags: Vec<String>,
     optimization: String,
-    include_paths: Vec<String>,
     project_root: Option<String>,
-    linker: Option<String>,
     extra_flags: Vec<String>,
 }
 
@@ -19,9 +17,7 @@ impl CompilationCommandBuilder {
             cxx_toolchain_dir: None,
             arch_flags: Vec::new(),
             optimization: "2".to_string(),
-            include_paths: Vec::new(),
             project_root: None,
-            linker: None,
             extra_flags: Vec::new(),
         }
     }
@@ -53,25 +49,12 @@ impl CompilationCommandBuilder {
         self
     }
 
-    /// Sets a list of include paths for compilation.
-    /// The paths that are passed must be relative to the
-    /// "cxx_toolchain_dir" directory path.
-    pub fn set_include_paths(mut self, paths: Vec<&str>) -> Self {
-        self.include_paths = paths.into_iter().map(|path| path.to_string()).collect();
-        self
-    }
-
     /// Sets the root path of all the generated test files.
     pub fn set_project_root(mut self, path: &str) -> Self {
         self.project_root = Some(path.to_string());
         self
     }
 
-    pub fn set_linker(mut self, linker: String) -> Self {
-        self.linker = Some(linker);
-        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);
@@ -104,30 +87,11 @@ impl CompilationCommandBuilder {
             cpp_compiler.arg(format!("--target={target}"));
         }
 
-        if let (Some(linker), Some(cxx_toolchain_dir)) = (&self.linker, &self.cxx_toolchain_dir) {
-            cpp_compiler.args(
-                self.include_paths
-                    .iter()
-                    .map(|path| "--include-directory=".to_string() + cxx_toolchain_dir + path),
-            );
-
-            CppCompilation::CustomLinker {
-                cpp_compiler,
-                linker: linker.to_owned(),
-            }
-        } else {
-            CppCompilation::Simple(cpp_compiler)
-        }
+        CppCompilation(cpp_compiler)
     }
 }
 
-pub enum CppCompilation {
-    Simple(std::process::Command),
-    CustomLinker {
-        cpp_compiler: std::process::Command,
-        linker: String,
-    },
-}
+pub struct CppCompilation(std::process::Command);
 
 fn clone_command(command: &std::process::Command) -> std::process::Command {
     let mut cmd = std::process::Command::new(command.get_program());
@@ -144,62 +108,15 @@ fn clone_command(command: &std::process::Command) -> std::process::Command {
 }
 
 impl CppCompilation {
+    pub fn command_mut(&mut self) -> &mut std::process::Command {
+        &mut self.0
+    }
+
     pub fn run(&self, inputs: &[String], output: &str) -> std::io::Result<std::process::Output> {
-        match self {
-            CppCompilation::Simple(command) => {
-                let mut cmd = clone_command(command);
-                cmd.args(inputs);
-                cmd.args(["-o", output]);
-
-                cmd.output()
-            }
-            CppCompilation::CustomLinker {
-                cpp_compiler,
-                linker,
-            } => {
-                let object_file = &format!("{output}.o");
-
-                // Build an object file using the cpp compiler.
-                let mut cmd = clone_command(cpp_compiler);
-                cmd.args(inputs);
-                cmd.args(["-c", "-o", object_file]);
-
-                let cpp_output = cmd.output()?;
-                if !cpp_output.status.success() {
-                    error!("c++ compilaton failed");
-                    return Ok(cpp_output);
-                }
-
-                trace!("using custom linker");
-
-                // Use the custom linker to turn the object file into an executable.
-                let mut cmd = std::process::Command::new(linker);
-                cmd.args([object_file, "-o", output]);
-
-                if let Some(current_dir) = cpp_compiler.get_current_dir() {
-                    cmd.current_dir(current_dir);
-                }
-
-                for (key, val) in cpp_compiler.get_envs() {
-                    cmd.env(key, val.unwrap_or_default());
-                }
-
-                let linker_output = cmd.output()?;
-                if !linker_output.status.success() {
-                    error!("custom linker failed");
-                    return Ok(linker_output);
-                }
-
-                trace!("removing {object_file}");
-                let object_file_path = match cpp_compiler.get_current_dir() {
-                    Some(current_dir) => &format!("{}/{object_file}", current_dir.display()),
-                    None => object_file,
-                };
-
-                std::fs::remove_file(object_file_path)?;
-
-                Ok(cpp_output)
-            }
-        }
+        let mut cmd = clone_command(&self.0);
+        cmd.args(inputs);
+        cmd.args(["-o", output]);
+
+        cmd.output()
     }
 }