don't use a global on the zig side (surgical linking can't do those yet)

crates/compiler/builtins/bitcode/src/expect.zig

@@ -19,10 +19,37 @@ pub fn setSharedBuffer(ptr: [*]u8, length: usize) callconv(.C) usize {
     return 0;
 }
 
-pub fn expectFailedStart() callconv(.C) [*]u8 {
+pub fn expectFailedStartSharedBuffer() callconv(.C) [*]u8 {
     return SHARED_BUFFER.ptr;
 }
 
+pub fn expectFailedStartSharedFile() callconv(.C) [*]u8 {
+    // IMPORTANT: shared memory object names must begin with / and contain no other slashes!
+    var name: [100]u8 = undefined;
+    _ = std.fmt.bufPrint(name[0..100], "/roc_expect_buffer_{}\x00", .{roc_getppid()}) catch unreachable;
+
+    if (builtin.os.tag == .macos or builtin.os.tag == .linux) {
+        const shared_fd = roc_shm_open(@ptrCast(*const i8, &name), O_RDWR | O_CREAT, 0o666);
+
+        const length = 4096;
+
+        const shared_ptr = roc_mmap(
+            null,
+            length,
+            PROT_WRITE,
+            MAP_SHARED,
+            shared_fd,
+            0,
+        );
+
+        const ptr = @ptrCast([*]u8, shared_ptr);
+
+        return ptr;
+    } else {
+        unreachable;
+    }
+}
+
 extern fn roc_send_signal(pid: c_int, sig: c_int) c_int;
 extern fn roc_shm_open(name: *const i8, oflag: c_int, mode: c_uint) c_int;
 extern fn roc_mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) *anyopaque;
@@ -30,7 +57,6 @@ extern fn roc_getppid() c_int;
 
 pub fn readSharedBufferEnv() callconv(.C) void {
     if (builtin.os.tag == .macos or builtin.os.tag == .linux) {
-        // const name = "/roc_expect_buffer";
 
         // IMPORTANT: shared memory object names must begin with / and contain no other slashes!
         var name: [100]u8 = undefined;

crates/compiler/builtins/bitcode/src/main.zig

@@ -169,12 +169,12 @@ comptime {
     @export(utils.panic, .{ .name = "roc_builtins.utils." ++ "panic", .linkage = .Weak });
 
     if (builtin.target.cpu.arch != .wasm32) {
-        exportUtilsFn(expect.expectFailedStart, "expect_failed_start");
+        exportUtilsFn(expect.expectFailedStartSharedBuffer, "expect_failed_start_shared_buffer");
+        exportUtilsFn(expect.expectFailedStartSharedFile, "expect_failed_start_shared_file");
         exportUtilsFn(expect.expectFailedFinalize, "expect_failed_finalize");
 
         // sets the buffer used for expect failures
         @export(expect.setSharedBuffer, .{ .name = "set_shared_buffer", .linkage = .Weak });
-        //
 
         exportUtilsFn(expect.readSharedBufferEnv, "read_env_shared_buffer");
     }

crates/compiler/builtins/src/bitcode.rs

@@ -404,7 +404,10 @@ pub const UTILS_INCREF: &str = "roc_builtins.utils.incref";
 pub const UTILS_DECREF: &str = "roc_builtins.utils.decref";
 pub const UTILS_DECREF_CHECK_NULL: &str = "roc_builtins.utils.decref_check_null";
 
-pub const UTILS_EXPECT_FAILED_START: &str = "roc_builtins.utils.expect_failed_start";
+pub const UTILS_EXPECT_FAILED_START_SHARED_BUFFER: &str =
+    "roc_builtins.utils.expect_failed_start_shared_buffer";
+pub const UTILS_EXPECT_FAILED_START_SHARED_FILE: &str =
+    "roc_builtins.utils.expect_failed_start_shared_file";
 pub const UTILS_EXPECT_FAILED_FINALIZE: &str = "roc_builtins.utils.expect_failed_finalize";
 pub const UTILS_EXPECT_READ_ENV_SHARED_BUFFER: &str = "roc_builtins.utils.read_env_shared_buffer";
 

crates/compiler/gen_llvm/src/llvm/build.rs

@@ -2817,10 +2817,6 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>(
             if env.mode.runs_expects() {
                 bd.position_at_end(throw_block);
 
-                if let LlvmBackendMode::BinaryDev = env.mode {
-                    crate::llvm::expect::read_env_shared_buffer(env);
-                }
-
                 match env.target_info.ptr_width() {
                     roc_target::PtrWidth::Bytes8 => {
                         clone_to_shared_memory(

crates/compiler/gen_llvm/src/llvm/expect.rs

@@ -14,7 +14,8 @@ use roc_mono::layout::{Builtin, Layout, LayoutIds, UnionLayout};
 use roc_region::all::Region;
 
 use super::build::{
-    add_func, load_roc_value, load_symbol_and_layout, use_roc_value, FunctionSpec, Scope,
+    add_func, load_roc_value, load_symbol_and_layout, use_roc_value, FunctionSpec, LlvmBackendMode,
+    Scope,
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -93,16 +94,6 @@ fn write_state<'a, 'ctx, 'env>(
     env.builder.build_store(offset_ptr, offset);
 }
 
-pub(crate) fn read_env_shared_buffer(env: &Env) {
-    let func = env
-        .module
-        .get_function(bitcode::UTILS_EXPECT_READ_ENV_SHARED_BUFFER)
-        .unwrap();
-
-    env.builder
-        .build_call(func, &[], "call_expect_read_env_shared_buffer");
-}
-
 pub(crate) fn finalize(env: &Env) {
     let func = env
         .module
@@ -121,10 +112,13 @@ pub(crate) fn clone_to_shared_memory<'a, 'ctx, 'env>(
     region: Region,
     lookups: &[Symbol],
 ) {
-    let func = env
-        .module
-        .get_function(bitcode::UTILS_EXPECT_FAILED_START)
-        .unwrap();
+    let start_function = if let LlvmBackendMode::BinaryDev = env.mode {
+        bitcode::UTILS_EXPECT_FAILED_START_SHARED_FILE
+    } else {
+        bitcode::UTILS_EXPECT_FAILED_START_SHARED_BUFFER
+    };
+
+    let func = env.module.get_function(start_function).unwrap();
 
     let call_result = env
         .builder