merge upstream/main

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

@@ -163,6 +163,7 @@ impl<'a, 'ctx> Scope<'a, 'ctx> {
 pub enum LlvmBackendMode {
     /// Assumes primitives (roc_alloc, roc_panic, etc) are provided by the host
     Binary,
+    BinaryDev,
     /// Creates a test wrapper around the main roc function to catch and report panics.
     /// Provides a testing implementation of primitives (roc_alloc, roc_panic, etc)
     GenTest,
@@ -174,6 +175,7 @@ impl LlvmBackendMode {
     pub(crate) fn has_host(self) -> bool {
         match self {
             LlvmBackendMode::Binary => true,
+            LlvmBackendMode::BinaryDev => true,
             LlvmBackendMode::GenTest => false,
             LlvmBackendMode::WasmGenTest => true,
             LlvmBackendMode::CliTest => false,
@@ -184,6 +186,7 @@ impl LlvmBackendMode {
     fn returns_roc_result(self) -> bool {
         match self {
             LlvmBackendMode::Binary => false,
+            LlvmBackendMode::BinaryDev => false,
             LlvmBackendMode::GenTest => true,
             LlvmBackendMode::WasmGenTest => true,
             LlvmBackendMode::CliTest => true,
@@ -193,6 +196,7 @@ impl LlvmBackendMode {
     fn runs_expects(self) -> bool {
         match self {
             LlvmBackendMode::Binary => false,
+            LlvmBackendMode::BinaryDev => true,
             LlvmBackendMode::GenTest => false,
             LlvmBackendMode::WasmGenTest => false,
             LlvmBackendMode::CliTest => true,
@@ -2824,6 +2828,10 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>(
                             lookups,
                         );
 
+                        if let LlvmBackendMode::BinaryDev = env.mode {
+                            crate::llvm::expect::finalize(env);
+                        }
+
                         bd.build_unconditional_branch(then_block);
                     }
                     roc_target::PtrWidth::Bytes4 => {
@@ -3925,7 +3933,7 @@ fn expose_function_to_host_help_c_abi<'a, 'ctx, 'env>(
             )
         }
 
-        LlvmBackendMode::Binary => {}
+        LlvmBackendMode::Binary | LlvmBackendMode::BinaryDev => {}
     }
 
     // a generic version that writes the result into a passed *u8 pointer
@@ -3976,7 +3984,9 @@ fn expose_function_to_host_help_c_abi<'a, 'ctx, 'env>(
             roc_result_type(env, roc_function.get_type().get_return_type().unwrap()).into()
         }
 
-        LlvmBackendMode::Binary => basic_type_from_layout(env, &return_layout),
+        LlvmBackendMode::Binary | LlvmBackendMode::BinaryDev => {
+            basic_type_from_layout(env, &return_layout)
+        }
     };
 
     let size: BasicValueEnum = return_type.size_of().unwrap().into();
@@ -4948,7 +4958,7 @@ pub fn build_proc<'a, 'ctx, 'env>(
                 GenTest | WasmGenTest | CliTest => {
                     /* no host, or exposing types is not supported */
                 }
-                Binary => {
+                Binary | BinaryDev => {
                     for (alias_name, (generated_function, top_level, layout)) in aliases.iter() {
                         expose_alias_to_host(
                             env,

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,6 +94,16 @@ fn write_state<'a, 'ctx, 'env>(
     env.builder.build_store(offset_ptr, offset);
 }
 
+pub(crate) fn finalize(env: &Env) {
+    let func = env
+        .module
+        .get_function(bitcode::UTILS_EXPECT_FAILED_FINALIZE)
+        .unwrap();
+
+    env.builder
+        .build_call(func, &[], "call_expect_failed_finalize");
+}
+
 pub(crate) fn clone_to_shared_memory<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     scope: &Scope<'a, 'ctx>,
@@ -101,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

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

@@ -155,10 +155,32 @@ pub fn add_default_roc_externs(env: &Env<'_, '_, '_>) {
             }
         }
 
+        unreachable_function(env, "roc_getppid");
+        unreachable_function(env, "roc_mmap");
+        unreachable_function(env, "roc_send_signal");
+        unreachable_function(env, "roc_shm_open");
+
         add_sjlj_roc_panic(env)
     }
 }
 
+fn unreachable_function(env: &Env, name: &str) {
+    // The type of this function (but not the implementation) should have
+    // already been defined by the builtins, which rely on it.
+    let fn_val = env.module.get_function(name).unwrap();
+
+    // Add a basic block for the entry point
+    let entry = env.context.append_basic_block(fn_val, "entry");
+
+    env.builder.position_at_end(entry);
+
+    env.builder.build_unreachable();
+
+    if cfg!(debug_assertions) {
+        crate::llvm::build::verify_fn(fn_val);
+    }
+}
+
 pub fn add_sjlj_roc_panic(env: &Env<'_, '_, '_>) {
     let ctx = env.context;
     let module = env.module;

crates/compiler/gen_llvm/src/run_roc.rs

@@ -120,7 +120,11 @@ macro_rules! run_jit_function {
 
                 $transform(success)
             }
-            Err(error_msg) => panic!("Roc failed with message: {}", error_msg),
+            Err(error_msg) => {
+                eprintln!("This Roc code crashed with: \"{error_msg}\"");
+
+                Expr::MalformedClosure
+            }
         }
     }};
 }