split up bitcode building to reduce dependency chains

crates/compiler/builtins/bitcode/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "roc_bitcode"
+description = "Compiles the zig bitcode to `.o` for builtins"
+
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+version.workspace = true
+
+[dependencies]
+tempfile.workspace = true
+
+[build-dependencies]
+# dunce can be removed once ziglang/zig#5109 is fixed
+dunce = "1.0.3"
+
+[target.'cfg(target_os = "macos")'.build-dependencies]
+tempfile.workspace = true

crates/compiler/builtins/bitcode/bc/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "roc_bitcode_bc"
+description = "Compiles the zig bitcode to `.bc` for llvm"
+
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+version.workspace = true
+
+[build-dependencies]
+# dunce can be removed once ziglang/zig#5109 is fixed
+dunce = "1.0.3"
+
+[target.'cfg(target_os = "macos")'.build-dependencies]
+tempfile.workspace = true

crates/compiler/builtins/bitcode/bc/build.rs

@@ -0,0 +1,217 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+use std::str;
+use std::{
+    env::{self, VarError},
+    path::PathBuf,
+    process::Command,
+};
+
+#[cfg(target_os = "macos")]
+use tempfile::tempdir;
+
+/// To debug the zig code with debug prints, we need to disable the wasm code gen
+const DEBUG: bool = false;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    // "." is relative to where "build.rs" is
+    // dunce can be removed once ziglang/zig#5109 is fixed
+    let bitcode_path = dunce::canonicalize(Path::new(".")).unwrap().join("..");
+
+    // workaround for github.com/ziglang/zig/issues/9711
+    #[cfg(target_os = "macos")]
+    let zig_cache_dir = tempdir().expect("Failed to create temp directory for zig cache");
+    #[cfg(target_os = "macos")]
+    std::env::set_var("ZIG_GLOBAL_CACHE_DIR", zig_cache_dir.path().as_os_str());
+
+    // LLVM .bc FILES
+
+    generate_bc_file(&bitcode_path, "ir", "builtins-host");
+
+    if !DEBUG {
+        generate_bc_file(&bitcode_path, "ir-wasm32", "builtins-wasm32");
+    }
+
+    generate_bc_file(&bitcode_path, "ir-i386", "builtins-i386");
+    generate_bc_file(&bitcode_path, "ir-x86_64", "builtins-x86_64");
+    generate_bc_file(
+        &bitcode_path,
+        "ir-windows-x86_64",
+        "builtins-windows-x86_64",
+    );
+
+    get_zig_files(bitcode_path.as_path(), &|path| {
+        let path: &Path = path;
+        println!(
+            "cargo:rerun-if-changed={}",
+            path.to_str().expect("Failed to convert path to str")
+        );
+    })
+    .unwrap();
+
+    #[cfg(target_os = "macos")]
+    zig_cache_dir
+        .close()
+        .expect("Failed to delete temp dir zig_cache_dir.");
+}
+
+fn generate_bc_file(bitcode_path: &Path, zig_object: &str, file_name: &str) {
+    let mut ll_path = bitcode_path.join(file_name);
+    ll_path.set_extension("ll");
+    let dest_ir_host = ll_path.to_str().expect("Invalid dest ir path");
+
+    println!("Compiling host ir to: {}", dest_ir_host);
+
+    let mut bc_path = bitcode_path.join(file_name);
+    bc_path.set_extension("bc");
+    let dest_bc_64bit = bc_path.to_str().expect("Invalid dest bc path");
+    println!("Compiling 64-bit bitcode to: {}", dest_bc_64bit);
+
+    // workaround for github.com/ziglang/zig/issues/9711
+    #[cfg(target_os = "macos")]
+    let _ = fs::remove_dir_all("./zig-cache");
+
+    let mut zig_cmd = zig();
+
+    zig_cmd
+        .current_dir(bitcode_path)
+        .args(["build", zig_object, "-Drelease=true"]);
+
+    run_command(zig_cmd, 0);
+}
+
+pub fn get_lib_dir() -> PathBuf {
+    // Currently we have the OUT_DIR variable which points to `/target/debug/build/roc_builtins-*/out/`.
+    // So we just need to add "/bitcode" to that.
+    let dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+
+    // create dir if it does not exist
+    fs::create_dir_all(&dir).expect("Failed to make $OUT_DIR/ dir.");
+
+    dir
+}
+
+fn run_command(mut command: Command, flaky_fail_counter: usize) {
+    let command_str = pretty_command_string(&command);
+    let command_str = command_str.to_string_lossy();
+
+    let output_result = command.output();
+
+    match output_result {
+        Ok(output) => match output.status.success() {
+            true => (),
+            false => {
+                let error_str = match str::from_utf8(&output.stderr) {
+                    Ok(stderr) => stderr.to_string(),
+                    Err(_) => format!("Failed to run \"{}\"", command_str),
+                };
+
+                // Flaky test errors that only occur sometimes on MacOS ci server.
+                if error_str.contains("FileNotFound")
+                    || error_str.contains("unable to save cached ZIR code")
+                    || error_str.contains("LLVM failed to emit asm")
+                {
+                    if flaky_fail_counter == 10 {
+                        panic!("{} failed 10 times in a row. The following error is unlikely to be a flaky error: {}", command_str, error_str);
+                    } else {
+                        run_command(command, flaky_fail_counter + 1)
+                    }
+                } else if error_str
+                    .contains("lld-link: error: failed to write the output file: Permission denied")
+                {
+                    panic!("{} failed with:\n\n  {}\n\nWorkaround:\n\n  Re-run the cargo command that triggered this build.\n\n", command_str, error_str);
+                } else {
+                    panic!("{} failed with:\n\n  {}\n", command_str, error_str);
+                }
+            }
+        },
+        Err(reason) => panic!("{} failed: {}", command_str, reason),
+    }
+}
+
+fn get_zig_files(dir: &Path, cb: &dyn Fn(&Path)) -> io::Result<()> {
+    if dir.is_dir() {
+        for entry in fs::read_dir(dir)? {
+            let entry = entry?;
+            let path_buf = entry.path();
+            if path_buf.is_dir() {
+                if !path_buf.ends_with("zig-cache") {
+                    get_zig_files(&path_buf, cb).unwrap();
+                }
+            } else {
+                let path = path_buf.as_path();
+
+                match path.extension() {
+                    Some(osstr) if osstr == "zig" => {
+                        cb(path);
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Gives a friendly error if zig is not installed.
+/// Also makes it easy to track where we use zig in the codebase.
+pub fn zig() -> Command {
+    let command_str = match std::env::var("ROC_ZIG") {
+        Ok(path) => path,
+        Err(_) => "zig".into(),
+    };
+
+    if check_command_available(&command_str) {
+        Command::new(command_str)
+    } else {
+        panic!("I could not find the zig command.\nPlease install zig, see instructions at https://ziglang.org/learn/getting-started/.",)
+    }
+}
+
+fn check_command_available(command_name: &str) -> bool {
+    if cfg!(target_family = "unix") {
+        let unparsed_path = match std::env::var("PATH") {
+            Ok(var) => var,
+            Err(VarError::NotPresent) => return false,
+            Err(VarError::NotUnicode(_)) => {
+                panic!("found PATH, but it included invalid unicode data!")
+            }
+        };
+
+        std::env::split_paths(&unparsed_path).any(|dir| dir.join(command_name).exists())
+    } else if cfg!(target = "windows") {
+        let mut cmd = Command::new("Get-Command");
+
+        cmd.args([command_name]);
+
+        let cmd_str = format!("{:?}", cmd);
+
+        let cmd_out = cmd.output().unwrap_or_else(|err| {
+            panic!(
+                "Failed to execute `{}` to check if {} is available:\n    {}",
+                cmd_str, command_name, err
+            )
+        });
+
+        cmd_out.status.success()
+    } else {
+        // We're in uncharted waters, best not to panic if
+        // things may end up working out down the line.
+        true
+    }
+}
+
+pub fn pretty_command_string(command: &Command) -> std::ffi::OsString {
+    let mut command_string = std::ffi::OsString::new();
+    command_string.push(command.get_program());
+
+    for arg in command.get_args() {
+        command_string.push(" ");
+        command_string.push(arg);
+    }
+
+    command_string
+}

crates/compiler/builtins/bitcode/build.rs

@@ -0,0 +1,273 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+use std::str;
+use std::{
+    env::{self, VarError},
+    path::PathBuf,
+    process::Command,
+};
+
+#[cfg(target_os = "macos")]
+use tempfile::tempdir;
+
+/// To debug the zig code with debug prints, we need to disable the wasm code gen
+const DEBUG: bool = false;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    // "." is relative to where "build.rs" is
+    // dunce can be removed once ziglang/zig#5109 is fixed
+    let bitcode_path = dunce::canonicalize(Path::new(".")).unwrap();
+
+    // workaround for github.com/ziglang/zig/issues/9711
+    #[cfg(target_os = "macos")]
+    let zig_cache_dir = tempdir().expect("Failed to create temp directory for zig cache");
+    #[cfg(target_os = "macos")]
+    std::env::set_var("ZIG_GLOBAL_CACHE_DIR", zig_cache_dir.path().as_os_str());
+
+    // OBJECT FILES
+    #[cfg(windows)]
+    const BUILTINS_HOST_FILE: &str = "builtins-host.obj";
+
+    #[cfg(not(windows))]
+    const BUILTINS_HOST_FILE: &str = "builtins-host.o";
+
+    generate_object_file(&bitcode_path, "object", BUILTINS_HOST_FILE);
+
+    generate_object_file(
+        &bitcode_path,
+        "windows-x86_64-object",
+        "builtins-windows-x86_64.obj",
+    );
+
+    generate_object_file(&bitcode_path, "wasm32-object", "builtins-wasm32.o");
+
+    copy_zig_builtins_to_target_dir(&bitcode_path);
+
+    get_zig_files(bitcode_path.as_path(), &|path| {
+        let path: &Path = path;
+        println!(
+            "cargo:rerun-if-changed={}",
+            path.to_str().expect("Failed to convert path to str")
+        );
+    })
+    .unwrap();
+
+    #[cfg(target_os = "macos")]
+    zig_cache_dir
+        .close()
+        .expect("Failed to delete temp dir zig_cache_dir.");
+}
+
+fn generate_object_file(bitcode_path: &Path, zig_object: &str, object_file_name: &str) {
+    let dest_obj_path = get_lib_dir().join(object_file_name);
+    let dest_obj = dest_obj_path.to_str().expect("Invalid dest object path");
+
+    let src_obj_path = bitcode_path.join(object_file_name);
+    let src_obj = src_obj_path.to_str().expect("Invalid src object path");
+
+    println!("Compiling zig object `{}` to: {}", zig_object, src_obj);
+
+    if !DEBUG {
+        let mut zig_cmd = zig();
+
+        zig_cmd
+            .current_dir(bitcode_path)
+            .args(["build", zig_object, "-Drelease=true"]);
+
+        run_command(zig_cmd, 0);
+
+        println!("Moving zig object `{}` to: {}", zig_object, dest_obj);
+
+        // we store this .o file in rust's `target` folder (for wasm we need to leave a copy here too)
+        fs::copy(src_obj, dest_obj).unwrap_or_else(|err| {
+            panic!(
+                "Failed to copy object file {} to {}: {:?}",
+                src_obj, dest_obj, err
+            );
+        });
+    }
+}
+
+pub fn get_lib_dir() -> PathBuf {
+    // Currently we have the OUT_DIR variable which points to `/target/debug/build/roc_builtins-*/out/`.
+    // So we just need to add "/bitcode" to that.
+    let dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+
+    // create dir if it does not exist
+    fs::create_dir_all(&dir).expect("Failed to make $OUT_DIR/ dir.");
+
+    dir
+}
+
+fn copy_zig_builtins_to_target_dir(bitcode_path: &Path) {
+    // To enable roc to find the zig builtins, we want them to be moved to a folder next to the roc executable.
+    // So if <roc_folder>/roc is the executable. The zig files will be in <roc_folder>/lib/*.zig
+    let target_profile_dir = get_lib_dir();
+
+    let zig_src_dir = bitcode_path.join("src");
+
+    cp_unless_zig_cache(&zig_src_dir, &target_profile_dir).unwrap_or_else(|err| {
+        panic!(
+            "Failed to copy zig bitcode files {:?} to {:?}: {:?}",
+            zig_src_dir, target_profile_dir, err
+        );
+    });
+}
+
+// recursively copy all the .zig files from this directory, but do *not* recurse into zig-cache/
+fn cp_unless_zig_cache(src_dir: &Path, target_dir: &Path) -> io::Result<()> {
+    // Make sure the destination directory exists before we try to copy anything into it.
+    std::fs::create_dir_all(target_dir).unwrap_or_else(|err| {
+        panic!(
+            "Failed to create output library directory for zig bitcode {:?}: {:?}",
+            target_dir, err
+        );
+    });
+
+    for entry in fs::read_dir(src_dir)? {
+        let src_path = entry?.path();
+        let src_filename = src_path.file_name().unwrap();
+
+        // Only copy individual files if they have the .zig extension
+        if src_path.extension().unwrap_or_default() == "zig" {
+            let dest = target_dir.join(src_filename);
+
+            fs::copy(&src_path, &dest).unwrap_or_else(|err| {
+                panic!(
+                    "Failed to copy zig bitcode file {:?} to {:?}: {:?}",
+                    src_path, dest, err
+                );
+            });
+        } else if src_path.is_dir() && src_filename != "zig-cache" {
+            // Recursively copy all directories except zig-cache
+            cp_unless_zig_cache(&src_path, &target_dir.join(src_filename))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn run_command(mut command: Command, flaky_fail_counter: usize) {
+    let command_str = pretty_command_string(&command);
+    let command_str = command_str.to_string_lossy();
+
+    let output_result = command.output();
+
+    match output_result {
+        Ok(output) => match output.status.success() {
+            true => (),
+            false => {
+                let error_str = match str::from_utf8(&output.stderr) {
+                    Ok(stderr) => stderr.to_string(),
+                    Err(_) => format!("Failed to run \"{}\"", command_str),
+                };
+
+                // Flaky test errors that only occur sometimes on MacOS ci server.
+                if error_str.contains("FileNotFound")
+                    || error_str.contains("unable to save cached ZIR code")
+                    || error_str.contains("LLVM failed to emit asm")
+                {
+                    if flaky_fail_counter == 10 {
+                        panic!("{} failed 10 times in a row. The following error is unlikely to be a flaky error: {}", command_str, error_str);
+                    } else {
+                        run_command(command, flaky_fail_counter + 1)
+                    }
+                } else if error_str
+                    .contains("lld-link: error: failed to write the output file: Permission denied")
+                {
+                    panic!("{} failed with:\n\n  {}\n\nWorkaround:\n\n  Re-run the cargo command that triggered this build.\n\n", command_str, error_str);
+                } else {
+                    panic!("{} failed with:\n\n  {}\n", command_str, error_str);
+                }
+            }
+        },
+        Err(reason) => panic!("{} failed: {}", command_str, reason),
+    }
+}
+
+fn get_zig_files(dir: &Path, cb: &dyn Fn(&Path)) -> io::Result<()> {
+    if dir.is_dir() {
+        for entry in fs::read_dir(dir)? {
+            let entry = entry?;
+            let path_buf = entry.path();
+            if path_buf.is_dir() {
+                if !path_buf.ends_with("zig-cache") {
+                    get_zig_files(&path_buf, cb).unwrap();
+                }
+            } else {
+                let path = path_buf.as_path();
+
+                match path.extension() {
+                    Some(osstr) if osstr == "zig" => {
+                        cb(path);
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Gives a friendly error if zig is not installed.
+/// Also makes it easy to track where we use zig in the codebase.
+pub fn zig() -> Command {
+    let command_str = match std::env::var("ROC_ZIG") {
+        Ok(path) => path,
+        Err(_) => "zig".into(),
+    };
+
+    if check_command_available(&command_str) {
+        Command::new(command_str)
+    } else {
+        panic!("I could not find the zig command.\nPlease install zig, see instructions at https://ziglang.org/learn/getting-started/.",)
+    }
+}
+
+fn check_command_available(command_name: &str) -> bool {
+    if cfg!(target_family = "unix") {
+        let unparsed_path = match std::env::var("PATH") {
+            Ok(var) => var,
+            Err(VarError::NotPresent) => return false,
+            Err(VarError::NotUnicode(_)) => {
+                panic!("found PATH, but it included invalid unicode data!")
+            }
+        };
+
+        std::env::split_paths(&unparsed_path).any(|dir| dir.join(command_name).exists())
+    } else if cfg!(target = "windows") {
+        let mut cmd = Command::new("Get-Command");
+
+        cmd.args([command_name]);
+
+        let cmd_str = format!("{:?}", cmd);
+
+        let cmd_out = cmd.output().unwrap_or_else(|err| {
+            panic!(
+                "Failed to execute `{}` to check if {} is available:\n    {}",
+                cmd_str, command_name, err
+            )
+        });
+
+        cmd_out.status.success()
+    } else {
+        // We're in uncharted waters, best not to panic if
+        // things may end up working out down the line.
+        true
+    }
+}
+
+pub fn pretty_command_string(command: &Command) -> std::ffi::OsString {
+    let mut command_string = std::ffi::OsString::new();
+    command_string.push(command.get_program());
+
+    for arg in command.get_args() {
+        command_string.push(" ");
+        command_string.push(arg);
+    }
+
+    command_string
+}

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

@@ -0,0 +1,65 @@
+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"));
+
+pub fn host_wasm_tempfile() -> std::io::Result<NamedTempFile> {
+    let tempfile = tempfile::Builder::new()
+        .prefix("host_bitcode")
+        .suffix(".wasm")
+        .rand_bytes(8)
+        .tempfile()?;
+
+    std::fs::write(tempfile.path(), HOST_WASM)?;
+
+    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()?;
+
+    std::fs::write(tempfile.path(), HOST_UNIX)?;
+
+    Ok(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_WINDOWS)?;
+
+    Ok(tempfile)
+}
+
+pub fn host_tempfile() -> std::io::Result<NamedTempFile> {
+    #[cfg(unix)]
+    {
+        host_unix_tempfile()
+    }
+
+    #[cfg(windows)]
+    {
+        host_windows_tempfile()
+    }
+
+    #[cfg(not(any(windows, unix)))]
+    {
+        unreachable!()
+    }
+}