a hopeless attempt

Author: folkertdev

ci/docker/aarch64_be-unknown-linux-gnu/Dockerfile

@@ -24,7 +24,7 @@ RUN mkdir /toolchains && mv "./${TOOLCHAIN}" /toolchains
 ENV AARCH64_BE_TOOLCHAIN="/toolchains/${TOOLCHAIN}"
 ENV AARCH64_BE_LIBC="${AARCH64_BE_TOOLCHAIN}/aarch64_be-none-linux-gnu/libc"
 
-ENV CARGO_TARGET_AARCH64_BE_UNKNOWN_LINUX_GNU_LINKER="${AARCH64_BE_TOOLCHAIN}/bin/aarch64_be-none-linux-gnu-gcc"
+ENV CARGO_TARGET_AARCH64_BE_UNKNOWN_LINUX_GNU_LINKER="${AARCH64_BE_TOOLCHAIN}/bin/aarch64_be-none-linux-gnu-g++"
 ENV CARGO_TARGET_AARCH64_BE_UNKNOWN_LINUX_GNU_RUNNER="qemu-aarch64_be -cpu max -L ${AARCH64_BE_LIBC}"
 ENV OBJDUMP="${AARCH64_BE_TOOLCHAIN}/bin/aarch64_be-none-linux-gnu-objdump"
 ENV STDARCH_TEST_SKIP_FEATURE=tme

ci/run.sh

@@ -82,7 +82,7 @@ STD_DETECT="--manifest-path=crates/std_detect/Cargo.toml"
 STDARCH_EXAMPLES="--manifest-path=examples/Cargo.toml"
 INTRINSIC_TEST="--manifest-path=crates/intrinsic-test/Cargo.toml"
 
-cargo_test "${CORE_ARCH} ${PROFILE}"
+# cargo_test "${CORE_ARCH} ${PROFILE}"
 
 if [ "$NOSTD" != "1" ]; then
     cargo_test "${STD_DETECT} ${PROFILE}"

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

@@ -1,4 +1,4 @@
-use crate::common::compile_c::CompilationCommandBuilder;
+use crate::common::compile_c::{CompilationCommand, CompilationCommandBuilder};
 
 pub fn compile_c_arm(
     compiler: &str,
@@ -67,12 +67,14 @@ pub fn compile_c_arm(
             command.command_mut().arg("-c");
         }
         command.command_mut().args(["-o", output]);
+
+        if let CompilationCommand::CustomLinker { linker, .. } = &mut command {
+            linker.arg(format!("c_programs/{output}"));
+        }
     } else {
         trace!("running {compiler}");
     }
 
-    trace!("running {compiler}\n{:?}", &command);
-
     if log::log_enabled!(log::Level::Trace) {
         command.command_mut().stdout(std::process::Stdio::inherit());
         command.command_mut().stderr(std::process::Stdio::inherit());

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

@@ -96,18 +96,51 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         )
         .unwrap();
 
-        let mut inputs = vec![format!("main.cpp")];
-        for i in 0..Ord::min(available_parallelism, self.intrinsics.len()) {
-            inputs.push(format!("mod_{i}.o"));
+        if let Some(linker) = &self.cli_options.linker {
+            compile_c_arm(
+                compiler,
+                target,
+                cxx_toolchain_dir,
+                &["main.cpp".to_string()],
+                Some("intrinsic-test-programs.o"),
+            );
+
+            let mut cmd = std::process::Command::new(linker);
+            cmd.current_dir("c_programs");
+
+            let mut inputs = vec![];
+            for i in 0..Ord::min(available_parallelism, self.intrinsics.len()) {
+                inputs.push(format!("mod_{i}.o"));
+            }
+            cmd.args(inputs);
+
+            cmd.arg("intrinsic-test-programs.o");
+
+            cmd.arg("-o");
+            cmd.arg("intrinsic-test-programs");
+
+            if log::log_enabled!(log::Level::Trace) {
+                cmd.stdout(std::process::Stdio::inherit());
+                cmd.stderr(std::process::Stdio::inherit());
+            }
+
+            assert!(cmd.output().unwrap().status.success());
+        } else {
+            let mut inputs = vec![format!("main.cpp")];
+            for i in 0..Ord::min(available_parallelism, self.intrinsics.len()) {
+                inputs.push(format!("mod_{i}.o"));
+            }
+
+            compile_c_arm(
+                compiler,
+                target,
+                cxx_toolchain_dir,
+                &inputs,
+                Some("intrinsic-test-programs"),
+            );
         }
 
-        compile_c_arm(
-            compiler,
-            target,
-            cxx_toolchain_dir,
-            &inputs,
-            Some("intrinsic-test-programs"),
-        )
+        true
     }
 
     fn build_rust_file(&self) -> bool {
@@ -153,8 +186,6 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             .map(|(i, chunk)| {
                 use std::io::Write;
 
-                dbg!(chunk_size, chunk.len());
-
                 let rust_filename = format!("rust_programs/src/mod_{i}.rs");
                 trace!("generating `{rust_filename}`");
                 let mut file = File::create(rust_filename).unwrap();

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

@@ -1,5 +1,3 @@
-use std::path::PathBuf;
-
 #[derive(Clone)]
 pub struct CompilationCommandBuilder {
     compiler: String,
@@ -9,7 +7,6 @@ pub struct CompilationCommandBuilder {
     optimization: String,
     include_paths: Vec<String>,
     project_root: Option<String>,
-    output: String,
     linker: Option<String>,
     extra_flags: Vec<String>,
 }
@@ -24,7 +21,6 @@ impl CompilationCommandBuilder {
             optimization: "2".to_string(),
             include_paths: Vec::new(),
             project_root: None,
-            output: String::new(),
             linker: None,
             extra_flags: Vec::new(),
         }
@@ -91,10 +87,10 @@ impl CompilationCommandBuilder {
 #[allow(clippy::large_enum_variant)]
 pub enum CompilationCommand {
     Simple(std::process::Command),
+    #[allow(unused)]
     CustomLinker {
         cmd: std::process::Command,
         linker: std::process::Command,
-        cleanup: PathBuf,
     },
 }
 
@@ -112,12 +108,9 @@ impl CompilationCommand {
             CompilationCommand::CustomLinker {
                 mut cmd,
                 mut linker,
-                cleanup,
             } => {
                 let output = cmd.output()?;
 
-                linker.current_dir("c_programs");
-
                 if log::log_enabled!(log::Level::Trace) {
                     linker.stdout(std::process::Stdio::inherit());
                     linker.stderr(std::process::Stdio::inherit());
@@ -129,9 +122,9 @@ impl CompilationCommand {
                         linker.get_program(),
                     );
                 }
-                if cleanup.exists() {
-                    std::fs::remove_file(cleanup)?;
-                }
+                //                if cleanup.exists() {
+                //                    std::fs::remove_file(cleanup)?;
+                //                }
 
                 Ok(output)
             }
@@ -141,8 +134,8 @@ impl CompilationCommand {
 
 impl CompilationCommandBuilder {
     pub fn into_command(self) -> CompilationCommand {
-        let project_root = self.project_root.unwrap_or_default();
-        let project_root_str = project_root.as_str();
+        // let project_root = self.project_root.unwrap_or_default();
+        // let project_root_str = project_root.as_str();
 
         let mut cmd = std::process::Command::new(self.compiler);
 
@@ -159,28 +152,27 @@ impl CompilationCommandBuilder {
             cmd.arg(format!("--target={target}"));
         }
 
-        if let (Some(linker), Some(cxx_toolchain_dir)) = (&self.linker, &self.cxx_toolchain_dir) {
+        if let (Some(_linker), Some(cxx_toolchain_dir)) = (&self.linker, &self.cxx_toolchain_dir) {
             cmd.arg("-c");
             cmd.args(
                 self.include_paths
                     .iter()
                     .map(|path| "--include-directory=".to_string() + cxx_toolchain_dir + path),
             );
 
-            let output = "dummy_value";
-            let mut linker_cmd = std::process::Command::new(linker);
-            linker_cmd.arg(format!("{project_root_str}/{output}"));
+            // let linker_cmd = std::process::Command::new(linker);
+            // linker_cmd.arg(format!("{project_root_str}/{output}"));
 
-            linker_cmd.arg("-o");
-            linker_cmd.arg(format!("{project_root_str}/{}", self.output));
+            // let remove_path = PathBuf::new();
+            // PathBuf::from(format!("{project_root_str}/{output}"));
 
-            let remove_path = PathBuf::from(format!("{project_root_str}/{output}"));
+            //            CompilationCommand::CustomLinker {
+            //                cmd,
+            //                linker: linker_cmd,
+            //                // cleanup: remove_path,
+            //            }
 
-            CompilationCommand::CustomLinker {
-                cmd,
-                linker: linker_cmd,
-                cleanup: remove_path,
-            }
+            CompilationCommand::Simple(cmd)
         } else {
             CompilationCommand::Simple(cmd)
         }

crates/intrinsic-test/src/main.rs

@@ -36,14 +36,14 @@ fn main() {
 
     let test_environment = test_environment_result.unwrap();
 
-    warn!("building Rust binaries");
-    if !test_environment.build_rust_file() {
-        std::process::exit(3);
-    }
     warn!("building C binaries");
     if !test_environment.build_c_file() {
         std::process::exit(2);
     }
+    warn!("building Rust binaries");
+    if !test_environment.build_rust_file() {
+        std::process::exit(3);
+    }
     warn!("comparing outputs");
     if !test_environment.compare_outputs() {
         std::process::exit(1);