cross compilation improvements

crates/cli/src/lib.rs

@@ -678,12 +678,12 @@ pub fn build(
     };
 
     let wasm_dev_backend = matches!(code_gen_backend, CodeGenBackend::Wasm);
+    let force_legacy_linker =
+        matches.get_one::<String>(FLAG_LINKER).map(|s| s.as_str()) == Some("legacy");
 
     let linking_strategy = if wasm_dev_backend {
         LinkingStrategy::Additive
-    } else if !roc_linker::supported(link_type, &triple)
-        || matches.get_one::<String>(FLAG_LINKER).map(|s| s.as_str()) == Some("legacy")
-    {
+    } else if !roc_linker::supported(link_type, &triple) || force_legacy_linker {
         LinkingStrategy::Legacy
     } else {
         LinkingStrategy::Surgical

crates/compiler/build/src/link.rs

@@ -464,12 +464,13 @@ pub fn rebuild_host(
         platform_main_roc.with_file_name(legacy_host_filename(target).unwrap())
     };
 
-    let env_path = env::var("PATH").unwrap_or_else(|_| "".to_string());
-    let env_home = env::var("HOME").unwrap_or_else(|_| "".to_string());
-    let env_cpath = env::var("CPATH").unwrap_or_else(|_| "".to_string());
+    let env_path = env::var("PATH").unwrap_or_default();
+    let env_home = env::var("HOME").unwrap_or_default();
+    let env_cpath = env::var("CPATH").unwrap_or_default();
 
-    let builtins_host_tempfile =
-        roc_bitcode::host_tempfile().expect("failed to write host builtins object to tempfile");
+    let builtins_host_tempfile = roc_bitcode::host_tempfile(target)
+        .as_ref()
+        .expect("failed to write host builtins object to tempfile");
 
     if zig_host_src.exists() {
         // Compile host.zig
@@ -1226,14 +1227,20 @@ fn link_windows(
 ) -> io::Result<(Child, PathBuf)> {
     match link_type {
         LinkType::Dylib => {
+            #[cfg(windows)]
+            let target = "-native";
+
+            #[cfg(not(windows))]
+            let target = "x86_64-windows-gnu";
+
             let child = zig()
                 .args(["build-lib"])
                 .args(input_paths)
                 .args([
                     "-lc",
                     &format!("-femit-bin={}", output_path.to_str().unwrap()),
                     "-target",
-                    "native",
+                    target,
                     "--pkg-begin",
                     "glue",
                     find_zig_glue_path().to_str().unwrap(),

crates/compiler/build/src/program.rs

@@ -1020,7 +1020,8 @@ fn build_loaded_file<'a>(
 
             std::fs::write(app_o_file, &*roc_app_bytes).unwrap();
 
-            let builtins_host_tempfile = roc_bitcode::host_tempfile()
+            let builtins_host_tempfile = roc_bitcode::host_tempfile(target)
+                .as_ref()
                 .expect("failed to write host builtins object to tempfile");
 
             let mut inputs = vec![app_o_file.to_str().unwrap()];

crates/compiler/builtins/bitcode/Cargo.toml

@@ -9,6 +9,7 @@ version.workspace = true
 
 [dependencies]
 tempfile.workspace = true
+target-lexicon.workspace = true
 
 [build-dependencies]
 roc_command_utils = { path = "../../../utils/command" }

crates/compiler/builtins/bitcode/src/lib.rs

@@ -3,9 +3,7 @@ use tempfile::NamedTempFile;
 const HOST_WASM: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/builtins-wasm32.o"));
 // TODO: in the future, we should use Zig's cross-compilation to generate and store these
 // for all targets, so that we can do cross-compilation!
-#[cfg(unix)]
 const HOST_UNIX: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/builtins-host.o"));
-#[cfg(windows)]
 const HOST_WINDOWS: &[u8] =
     include_bytes!(concat!(env!("OUT_DIR"), "/builtins-windows-x86_64.obj"));
 
@@ -21,45 +19,71 @@ pub fn host_wasm_tempfile() -> std::io::Result<NamedTempFile> {
     Ok(tempfile)
 }
 
-#[cfg(unix)]
-fn host_unix_tempfile() -> std::io::Result<NamedTempFile> {
-    let tempfile = tempfile::Builder::new()
-        .prefix("host_bitcode")
-        .suffix(".o")
-        .rand_bytes(8)
-        .tempfile()?;
+fn current_host_tempfile() -> &'static std::io::Result<NamedTempFile> {
+    use std::sync::OnceLock;
 
-    std::fs::write(tempfile.path(), HOST_UNIX)?;
+    static TMP: OnceLock<std::io::Result<NamedTempFile>> = OnceLock::new();
 
-    Ok(tempfile)
-}
+    fn helper() -> std::io::Result<NamedTempFile> {
+        let tempfile = tempfile::Builder::new()
+            .prefix("host_bitcode")
+            .suffix(".o")
+            .rand_bytes(8)
+            .tempfile()?;
 
-#[cfg(windows)]
-fn host_windows_tempfile() -> std::io::Result<NamedTempFile> {
-    let tempfile = tempfile::Builder::new()
-        .prefix("host_bitcode")
-        .suffix(".obj")
-        .rand_bytes(8)
-        .tempfile()?;
+        std::fs::write(tempfile.path(), HOST_UNIX)?;
 
-    std::fs::write(tempfile.path(), HOST_WINDOWS)?;
+        Ok(tempfile)
+    }
 
-    Ok(tempfile)
+    TMP.get_or_init(helper)
 }
 
-pub fn host_tempfile() -> std::io::Result<NamedTempFile> {
-    #[cfg(unix)]
-    {
-        host_unix_tempfile()
-    }
+fn host_windows_tempfile() -> &'static std::io::Result<NamedTempFile> {
+    use std::sync::OnceLock;
+
+    static TMP: OnceLock<std::io::Result<NamedTempFile>> = OnceLock::new();
 
-    #[cfg(windows)]
-    {
-        host_windows_tempfile()
+    fn helper() -> std::io::Result<NamedTempFile> {
+        let tempfile = tempfile::Builder::new()
+            .prefix("host_bitcode")
+            .suffix(".obj")
+            .rand_bytes(8)
+            .tempfile()?;
+
+        std::fs::write(tempfile.path(), HOST_WINDOWS)?;
+
+        Ok(tempfile)
     }
 
-    #[cfg(not(any(windows, unix)))]
-    {
-        unreachable!()
+    TMP.get_or_init(helper)
+}
+
+pub fn host_tempfile(target: &target_lexicon::Triple) -> &'static std::io::Result<NamedTempFile> {
+    use target_lexicon::Triple;
+
+    match target {
+        Triple {
+            // architecture: target_lexicon::Architecture::X86_64,
+            // operating_system: target_lexicon::OperatingSystem::Linux,
+            binary_format: target_lexicon::BinaryFormat::Elf,
+            ..
+        } => current_host_tempfile(),
+
+        // macho support is incomplete
+        Triple {
+            // operating_system: target_lexicon::OperatingSystem::Darwin,
+            binary_format: target_lexicon::BinaryFormat::Macho,
+            ..
+        } => current_host_tempfile(),
+
+        Triple {
+            architecture: target_lexicon::Architecture::X86_64,
+            operating_system: target_lexicon::OperatingSystem::Windows,
+            binary_format: target_lexicon::BinaryFormat::Coff,
+            ..
+        } => host_windows_tempfile(),
+
+        other => unimplemented!("no host for {other:?} architecture"),
     }
 }

crates/compiler/test_gen/src/helpers/dev.rs

@@ -212,8 +212,9 @@ pub fn helper(
         .expect("failed to build output object");
     std::fs::write(&app_o_file, module_out).expect("failed to write object to file");
 
-    let builtins_host_tempfile =
-        roc_bitcode::host_tempfile().expect("failed to write host builtins object to tempfile");
+    let builtins_host_tempfile = roc_bitcode::host_tempfile(&target)
+        .as_ref()
+        .expect("failed to write host builtins object to tempfile");
 
     // TODO make this an environment variable
     if false {

crates/linker/src/lib.rs

@@ -32,33 +32,35 @@ pub enum LinkType {
 }
 
 pub fn supported(link_type: LinkType, target: &Triple) -> bool {
-    if let LinkType::Executable = link_type {
-        match target {
-            Triple {
-                architecture: target_lexicon::Architecture::X86_64,
-                operating_system: target_lexicon::OperatingSystem::Linux,
-                binary_format: target_lexicon::BinaryFormat::Elf,
-                ..
-            } => true,
-
-            // macho support is incomplete
-            Triple {
-                operating_system: target_lexicon::OperatingSystem::Darwin,
-                binary_format: target_lexicon::BinaryFormat::Macho,
-                ..
-            } => false,
-
-            Triple {
-                architecture: target_lexicon::Architecture::X86_64,
-                operating_system: target_lexicon::OperatingSystem::Windows,
-                binary_format: target_lexicon::BinaryFormat::Coff,
-                ..
-            } => true,
-
-            _ => false,
+    match link_type {
+        LinkType::Executable => {
+            match target {
+                Triple {
+                    architecture: target_lexicon::Architecture::X86_64,
+                    operating_system: target_lexicon::OperatingSystem::Linux,
+                    binary_format: target_lexicon::BinaryFormat::Elf,
+                    ..
+                } => true,
+
+                // macho support is incomplete
+                Triple {
+                    operating_system: target_lexicon::OperatingSystem::Darwin,
+                    binary_format: target_lexicon::BinaryFormat::Macho,
+                    ..
+                } => false,
+
+                Triple {
+                    architecture: target_lexicon::Architecture::X86_64,
+                    operating_system: target_lexicon::OperatingSystem::Windows,
+                    binary_format: target_lexicon::BinaryFormat::Coff,
+                    ..
+                } => true,
+
+                _ => false,
+            }
         }
-    } else {
-        false
+        LinkType::Dylib => false,
+        LinkType::None => false,
     }
 }