Merge branch 'trunk' into NumBytesTo

cli/src/repl/gen.rs

@@ -135,10 +135,6 @@ pub fn gen_and_eval<'a>(
             &context, "",
         ));
 
-        // Add roc_alloc, roc_realloc, and roc_dealloc, since the repl has no
-        // platform to provide them.
-        add_default_roc_externs(&context, module, &builder, ptr_bytes);
-
         // mark our zig-defined builtins as internal
         for function in FunctionIterator::from_module(module) {
             let name = function.get_name().to_str().unwrap();
@@ -183,11 +179,15 @@ pub fn gen_and_eval<'a>(
             interns,
             module,
             ptr_bytes,
-            leak: false,
+            is_gen_test: false,
             // important! we don't want any procedures to get the C calling convention
             exposed_to_host: MutSet::default(),
         };
 
+        // Add roc_alloc, roc_realloc, and roc_dealloc, since the repl has no
+        // platform to provide them.
+        add_default_roc_externs(&env);
+
         let (main_fn_name, main_fn) = roc_gen_llvm::llvm::build::build_procedures_return_main(
             &env,
             opt_level,

cli/tests/fixtures/multi-dep-str/platform/host.zig

@@ -40,6 +40,13 @@ export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void {
     free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
 }
 
+export fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    const msg = @ptrCast([*:0]const u8, c_ptr);
+    stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
+    std.process.exit(0);
+}
+
 const RocCallResult = extern struct { flag: usize, content: RocStr };
 
 const Unit = extern struct {};

cli/tests/fixtures/multi-dep-thunk/platform/host.zig

@@ -40,6 +40,13 @@ export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void {
     free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
 }
 
+export fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    const msg = @ptrCast([*:0]const u8, c_ptr);
+    stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
+    std.process.exit(0);
+}
+
 const RocCallResult = extern struct { flag: usize, content: RocStr };
 
 const Unit = extern struct {};

compiler/build/src/link.rs

@@ -421,9 +421,6 @@ fn link_linux(
                 "-lrt",
                 "-lutil",
                 "-lc_nonshared",
-                "-lc++",
-                "-lc++abi",
-                "-lunwind",
                 libgcc_path.to_str().unwrap(),
                 // Output
                 "-o",
@@ -488,9 +485,6 @@ fn link_macos(
                 // "-lrt", // TODO shouldn't we need this?
                 // "-lc_nonshared", // TODO shouldn't we need this?
                 // "-lgcc", // TODO will eventually need compiler_rt from gcc or something - see https://github.com/rtfeldman/roc/pull/554#discussion_r496370840
-                "-lc++",
-                // "-lc++abi",
-                // "-lunwind", // TODO will eventually need this, see https://github.com/rtfeldman/roc/pull/554#discussion_r496370840
                 // "-framework", // Uncomment this line & the following ro run the `rand` crate in examples/cli
                 // "Security",
                 // Output

compiler/build/src/program.rs

@@ -144,7 +144,9 @@ pub fn gen_from_mono_module(
         interns: loaded.interns,
         module,
         ptr_bytes,
-        leak: false,
+        // in gen_tests, the compiler provides roc_panic
+        // and sets up the setjump/longjump exception handling
+        is_gen_test: false,
         exposed_to_host: loaded.exposed_to_host.keys().copied().collect(),
     };
 
@@ -158,6 +160,9 @@ pub fn gen_from_mono_module(
 
     env.dibuilder.finalize();
 
+    // we don't use the debug info, and it causes weird errors.
+    module.strip_debug_info();
+
     // Uncomment this to see the module's optimized LLVM instruction output:
     // env.module.print_to_stderr();
 

compiler/builtins/bitcode/src/main.zig

@@ -105,6 +105,14 @@ comptime {
     exportStrFn(str.fromUtf8RangeC, "from_utf8_range");
 }
 
+// Utils
+const utils = @import("utils.zig");
+comptime {
+    exportUtilsFn(utils.test_panic, "test_panic");
+
+    @export(utils.panic, .{ .name = "roc_builtins.utils." ++ "panic", .linkage = .Weak });
+}
+
 // Export helpers - Must be run inside a comptime
 fn exportBuiltinFn(comptime func: anytype, comptime func_name: []const u8) void {
     @export(func, .{ .name = "roc_builtins." ++ func_name, .linkage = .Strong });
@@ -125,6 +133,10 @@ fn exportDecFn(comptime func: anytype, comptime func_name: []const u8) void {
     exportBuiltinFn(func, "dec." ++ func_name);
 }
 
+fn exportUtilsFn(comptime func: anytype, comptime func_name: []const u8) void {
+    exportBuiltinFn(func, "utils." ++ func_name);
+}
+
 // Custom panic function, as builtin Zig version errors during LLVM verification
 pub fn panic(message: []const u8, stacktrace: ?*std.builtin.StackTrace) noreturn {
     std.debug.print("{s}: {?}", .{ message, stacktrace });

compiler/builtins/bitcode/src/utils.zig

@@ -15,12 +15,16 @@ extern fn roc_realloc(c_ptr: *c_void, new_size: usize, old_size: usize, alignmen
 // This should never be passed a null pointer.
 extern fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void;
 
+// Signals to the host that the program has paniced
+extern fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void;
+
 comptime {
     // During tetsts, use the testing allocators to satisfy these functions.
     if (std.builtin.is_test) {
         @export(testing_roc_alloc, .{ .name = "roc_alloc", .linkage = .Strong });
         @export(testing_roc_realloc, .{ .name = "roc_realloc", .linkage = .Strong });
         @export(testing_roc_dealloc, .{ .name = "roc_dealloc", .linkage = .Strong });
+        @export(testing_roc_panic, .{ .name = "roc_panic", .linkage = .Strong });
     }
 }
 
@@ -41,6 +45,10 @@ fn testing_roc_dealloc(c_ptr: *c_void, _: u32) callconv(.C) void {
     std.testing.allocator.destroy(ptr);
 }
 
+fn testing_roc_panic(c_ptr: *c_void, _: u32) callconv(.C) void {
+    @panic("Roc paniced");
+}
+
 pub fn alloc(size: usize, alignment: u32) [*]u8 {
     return @ptrCast([*]u8, @call(.{ .modifier = always_inline }, roc_alloc, .{ size, alignment }));
 }
@@ -53,6 +61,22 @@ pub fn dealloc(c_ptr: [*]u8, alignment: u32) void {
     return @call(.{ .modifier = always_inline }, roc_dealloc, .{ c_ptr, alignment });
 }
 
+// must export this explicitly because right now it is not used from zig code
+pub fn panic(c_ptr: *c_void, alignment: u32) callconv(.C) void {
+    return @call(.{ .modifier = always_inline }, roc_panic, .{ c_ptr, alignment });
+}
+
+// indirection because otherwise zig creats an alias to the panic function which our LLVM code
+// does not know how to deal with
+pub fn test_panic(c_ptr: *c_void, alignment: u32) callconv(.C) void {
+    const cstr = @ptrCast([*:0]u8, c_ptr);
+
+    // const stderr = std.io.getStdErr().writer();
+    // stderr.print("Roc panicked: {s}!\n", .{cstr}) catch unreachable;
+
+    std.c.exit(1);
+}
+
 pub const Inc = fn (?[*]u8) callconv(.C) void;
 pub const IncN = fn (?[*]u8, u64) callconv(.C) void;
 pub const Dec = fn (?[*]u8) callconv(.C) void;

compiler/builtins/src/bitcode.rs

@@ -80,3 +80,5 @@ pub const DEC_ADD_WITH_OVERFLOW: &str = "roc_builtins.dec.add_with_overflow";
 pub const DEC_SUB_WITH_OVERFLOW: &str = "roc_builtins.dec.sub_with_overflow";
 pub const DEC_MUL_WITH_OVERFLOW: &str = "roc_builtins.dec.mul_with_overflow";
 pub const DEC_DIV: &str = "roc_builtins.dec.div";
+
+pub const UTILS_TEST_PANIC: &str = "roc_builtins.utils.test_panic";

compiler/gen_dev/src/object_builder.rs

@@ -179,6 +179,12 @@ fn build_object<'a, B: Backend<'a>>(
             "roc_dealloc".into(),
             "free".into(),
         )?;
+        generate_wrapper(
+            &mut backend,
+            &mut output,
+            "roc_panic".into(),
+            "roc_builtins.utils.test_panic".into(),
+        )?;
     }
 
     // Setup layout_ids for procedure calls.

compiler/gen_llvm/src/llvm/externs.rs

@@ -1,19 +1,18 @@
+use crate::llvm::build::Env;
 use crate::llvm::build::{add_func, C_CALL_CONV};
 use crate::llvm::convert::ptr_int;
-use inkwell::builder::Builder;
-use inkwell::context::Context;
-use inkwell::module::{Linkage, Module};
+use inkwell::module::Linkage;
 use inkwell::values::BasicValue;
 use inkwell::AddressSpace;
 
 /// Define functions for roc_alloc, roc_realloc, and roc_dealloc
 /// which use libc implementations (malloc, realloc, and free)
-pub fn add_default_roc_externs<'ctx>(
-    ctx: &'ctx Context,
-    module: &Module<'ctx>,
-    builder: &Builder<'ctx>,
-    ptr_bytes: u32,
-) {
+pub fn add_default_roc_externs(env: &Env<'_, '_, '_>) {
+    let ctx = env.context;
+    let module = env.module;
+    let builder = env.builder;
+    let ptr_bytes = env.ptr_bytes;
+
     let usize_type = ptr_int(ctx, ptr_bytes);
     let i8_ptr_type = ctx.i8_type().ptr_type(AddressSpace::Generic);
 
@@ -139,4 +138,69 @@ pub fn add_default_roc_externs<'ctx>(
             crate::llvm::build::verify_fn(fn_val);
         }
     }
+
+    add_sjlj_roc_panic(env)
+}
+
+pub fn add_sjlj_roc_panic(env: &Env<'_, '_, '_>) {
+    let ctx = env.context;
+    let module = env.module;
+    let builder = env.builder;
+
+    // roc_panic
+    {
+        use crate::llvm::build::LLVM_LONGJMP;
+
+        // The type of this function (but not the implementation) should have
+        // already been defined by the builtins, which rely on it.
+        let fn_val = module.get_function("roc_panic").unwrap();
+        let mut params = fn_val.get_param_iter();
+        let ptr_arg = params.next().unwrap();
+
+        // in debug mode, this is assumed to be NullTerminatedString
+        let _tag_id_arg = params.next().unwrap();
+
+        debug_assert!(params.next().is_none());
+
+        let subprogram = env.new_subprogram("roc_panic");
+        fn_val.set_subprogram(subprogram);
+
+        env.dibuilder.finalize();
+
+        // Add a basic block for the entry point
+        let entry = ctx.append_basic_block(fn_val, "entry");
+
+        builder.position_at_end(entry);
+
+        let buffer = crate::llvm::build::get_sjlj_buffer(env);
+
+        // write our error message pointer
+        let index = env.ptr_int().const_int(3 * env.ptr_bytes as u64, false);
+        let message_buffer_raw =
+            unsafe { builder.build_gep(buffer, &[index], "raw_msg_buffer_ptr") };
+        let message_buffer = builder.build_bitcast(
+            message_buffer_raw,
+            env.context
+                .i8_type()
+                .ptr_type(AddressSpace::Generic)
+                .ptr_type(AddressSpace::Generic),
+            "to **u8",
+        );
+
+        env.builder
+            .build_store(message_buffer.into_pointer_value(), ptr_arg);
+
+        let tag = env.context.i32_type().const_int(1, false);
+        if true {
+            let _call = env.build_intrinsic_call(LLVM_LONGJMP, &[buffer.into()]);
+        } else {
+            let _call = env.build_intrinsic_call(LLVM_LONGJMP, &[buffer.into(), tag.into()]);
+        }
+
+        builder.build_unreachable();
+
+        if cfg!(debug_assertions) {
+            crate::llvm::build::verify_fn(fn_val);
+        }
+    }
 }

compiler/gen_llvm/src/llvm/refcounting.rs

@@ -278,7 +278,7 @@ impl<'ctx> PointerToRefcount<'ctx> {
         // build then block
         {
             builder.position_at_end(then_block);
-            if !env.leak {
+            if !env.is_gen_test {
                 let ptr = builder.build_pointer_cast(
                     refcount_ptr.value,
                     ctx.i8_type().ptr_type(AddressSpace::Generic),

compiler/mono/src/ir.rs

@@ -6228,36 +6228,6 @@ fn add_needed_external<'a>(
     existing.insert(name, solved_type);
 }
 
-fn can_throw_exception(call: &Call) -> bool {
-    match call.call_type {
-        CallType::ByName { name, .. } => matches!(
-            name,
-            Symbol::NUM_ADD
-                | Symbol::NUM_SUB
-                | Symbol::NUM_MUL
-                | Symbol::NUM_DIV_FLOAT
-                | Symbol::NUM_ABS
-                | Symbol::NUM_NEG
-        ),
-
-        CallType::Foreign { .. } => {
-            // calling foreign functions is very unsafe
-            true
-        }
-
-        CallType::LowLevel { .. } => {
-            // lowlevel operations themselves don't throw
-            // TODO except for on allocation?
-            false
-        }
-        CallType::HigherOrderLowLevel { .. } => {
-            // TODO throwing is based on whether the HOF can throw
-            // or if there is (potentially) allocation in the lowlevel
-            false
-        }
-    }
-}
-
 /// Symbol that links an Invoke with a Rethrow
 /// we'll assign the exception object to this symbol
 /// so we can later rethrow the exception
@@ -6271,26 +6241,13 @@ impl ExceptionId {
 }
 
 fn build_call<'a>(
-    env: &mut Env<'a, '_>,
+    _env: &mut Env<'a, '_>,
     call: Call<'a>,
     assigned: Symbol,
     return_layout: Layout<'a>,
     hole: &'a Stmt<'a>,
 ) -> Stmt<'a> {
-    if can_throw_exception(&call) {
-        let id = ExceptionId(env.unique_symbol());
-        let fail = env.arena.alloc(Stmt::Resume(id));
-        Stmt::Invoke {
-            symbol: assigned,
-            call,
-            layout: return_layout,
-            fail,
-            pass: hole,
-            exception_id: id,
-        }
-    } else {
-        Stmt::Let(assigned, Expr::Call(call), return_layout, hole)
-    }
+    Stmt::Let(assigned, Expr::Call(call), return_layout, hole)
 }
 
 #[allow(clippy::too_many_arguments)]

compiler/test_gen/src/gen_list.rs

@@ -27,6 +27,25 @@ pub unsafe fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) {
     libc::free(c_ptr)
 }
 
+#[no_mangle]
+pub unsafe fn roc_panic(c_ptr: *mut c_void, tag_id: u32) {
+    use roc_gen_llvm::llvm::build::PanicTagId;
+
+    use libc::c_char;
+    use std::convert::TryFrom;
+    use std::ffi::CStr;
+
+    match PanicTagId::try_from(tag_id) {
+        Ok(PanicTagId::NullTerminatedString) => {
+            let slice = CStr::from_ptr(c_ptr as *const c_char);
+            let string = slice.to_str().unwrap();
+            eprintln!("Roc hit a panic: {}", string);
+            std::process::exit(1);
+        }
+        Err(_) => unreachable!(),
+    }
+}
+
 #[test]
 fn roc_list_construction() {
     let list = RocList::from_slice(&[1i64; 23]);

compiler/test_gen/src/gen_primitives.rs

@@ -2393,7 +2393,6 @@ fn call_invalid_layout() {
         3,
         i64,
         |x| x,
-        false,
         true
     );
 }

compiler/test_gen/src/helpers/eval.rs

@@ -33,7 +33,7 @@ pub fn helper<'a>(
     arena: &'a bumpalo::Bump,
     src: &str,
     stdlib: &'a roc_builtins::std::StdLib,
-    leak: bool,
+    is_gen_test: bool,
     ignore_problems: bool,
     context: &'a inkwell::context::Context,
 ) -> (&'static str, String, Library) {
@@ -171,13 +171,6 @@ pub fn helper<'a>(
     let builder = context.create_builder();
     let module = roc_gen_llvm::llvm::build::module_from_builtins(context, "app");
 
-    // Add roc_alloc, roc_realloc, and roc_dealloc, since the repl has no
-    // platform to provide them.
-    add_default_roc_externs(context, &module, &builder, ptr_bytes);
-
-    // strip Zig debug stuff
-    module.strip_debug_info();
-
     let opt_level = if cfg!(debug_assertions) {
         OptLevel::Normal
     } else {
@@ -219,11 +212,18 @@ pub fn helper<'a>(
         interns,
         module,
         ptr_bytes,
-        leak,
+        is_gen_test,
         // important! we don't want any procedures to get the C calling convention
         exposed_to_host: MutSet::default(),
     };
 
+    // strip Zig debug stuff
+    module.strip_debug_info();
+
+    // Add roc_alloc, roc_realloc, and roc_dealloc, since the repl has no
+    // platform to provide them.
+    add_default_roc_externs(&env);
+
     let (main_fn_name, main_fn) = roc_gen_llvm::llvm::build::build_procedures_return_main(
         &env,
         opt_level,
@@ -233,6 +233,9 @@ pub fn helper<'a>(
 
     env.dibuilder.finalize();
 
+    // strip all debug info: we don't use it at the moment and causes weird validation issues
+    module.strip_debug_info();
+
     // Uncomment this to see the module's un-optimized LLVM instruction output:
     // env.module.print_to_stderr();
 
@@ -260,7 +263,7 @@ pub fn helper<'a>(
 
 #[macro_export]
 macro_rules! assert_llvm_evals_to {
-    ($src:expr, $expected:expr, $ty:ty, $transform:expr, $leak:expr, $ignore_problems:expr) => {
+    ($src:expr, $expected:expr, $ty:ty, $transform:expr, $ignore_problems:expr) => {
         use bumpalo::Bump;
         use inkwell::context::Context;
         use roc_gen_llvm::run_jit_function;
@@ -271,8 +274,15 @@ macro_rules! assert_llvm_evals_to {
         // NOTE the stdlib must be in the arena; just taking a reference will segfault
         let stdlib = arena.alloc(roc_builtins::std::standard_stdlib());
 
-        let (main_fn_name, errors, lib) =
-            $crate::helpers::eval::helper(&arena, $src, stdlib, $leak, $ignore_problems, &context);
+        let is_gen_test = true;
+        let (main_fn_name, errors, lib) = $crate::helpers::eval::helper(
+            &arena,
+            $src,
+            stdlib,
+            is_gen_test,
+            $ignore_problems,
+            &context,
+        );
 
         let transform = |success| {
             let expected = $expected;
@@ -284,7 +294,7 @@ macro_rules! assert_llvm_evals_to {
     };
 
     ($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
-        assert_llvm_evals_to!($src, $expected, $ty, $transform, true, false);
+        assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
     };
 }
 
@@ -296,20 +306,7 @@ macro_rules! assert_evals_to {
     ($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
         // Same as above, except with an additional transformation argument.
         {
-            assert_evals_to!($src, $expected, $ty, $transform, true);
-        }
-    };
-    ($src:expr, $expected:expr, $ty:ty, $transform:expr, $leak:expr) => {
-        // Run un-optimized tests, and then optimized tests, in separate scopes.
-        // These each rebuild everything from scratch, starting with
-        // parsing the source, so that there's no chance their passing
-        // or failing depends on leftover state from the previous one.
-        {
-            assert_llvm_evals_to!($src, $expected, $ty, $transform, $leak, false);
-        }
-        {
-            // NOTE at the moment, the optimized tests do the same thing
-            // assert_opt_evals_to!($src, $expected, $ty, $transform, $leak);
+            assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
         }
     };
 }
@@ -322,10 +319,10 @@ macro_rules! assert_non_opt_evals_to {
     ($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
         // Same as above, except with an additional transformation argument.
         {
-            assert_llvm_evals_to!($src, $expected, $ty, $transform, true, false);
+            assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
         }
     };
-    ($src:expr, $expected:expr, $ty:ty, $transform:expr, $leak:expr) => {{
-        assert_llvm_evals_to!($src, $expected, $ty, $transform, $leak);
+    ($src:expr, $expected:expr, $ty:ty, $transform:expr) => {{
+        assert_llvm_evals_to!($src, $expected, $ty, $transform);
     }};
 }

compiler/test_mono/generated/factorial.txt

@@ -1,6 +1,6 @@
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Test.15 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Test.15;
+    let Test.14 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Test.14;
 
 procedure Num.26 (#Attr.2, #Attr.3):
     let Test.12 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -8,13 +8,13 @@ procedure Num.26 (#Attr.2, #Attr.3):
 
 procedure Test.1 (Test.2, Test.3):
     joinpoint Test.7 Test.2 Test.3:
-        let Test.17 = 0i64;
-        let Test.18 = lowlevel Eq Test.17 Test.2;
-        if Test.18 then
+        let Test.15 = 0i64;
+        let Test.16 = lowlevel Eq Test.15 Test.2;
+        if Test.16 then
             ret Test.3;
         else
-            let Test.14 = 1i64;
-            let Test.10 = CallByName Num.25 Test.2 Test.14;
+            let Test.13 = 1i64;
+            let Test.10 = CallByName Num.25 Test.2 Test.13;
             let Test.11 = CallByName Num.26 Test.2 Test.3;
             jump Test.7 Test.10 Test.11;
     in

compiler/test_mono/generated/ir_int_add.txt

@@ -1,24 +1,20 @@
 procedure List.7 (#Attr.2):
-    let Test.7 = lowlevel ListLen #Attr.2;
-    ret Test.7;
+    let Test.6 = lowlevel ListLen #Attr.2;
+    ret Test.6;
 
 procedure Num.24 (#Attr.2, #Attr.3):
     let Test.5 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Test.5;
 
 procedure Test.0 ():
-    let Test.14 = 1i64;
-    let Test.15 = 2i64;
-    let Test.1 = Array [Test.14, Test.15];
-    let Test.11 = 5i64;
-    let Test.12 = 4i64;
-    invoke Test.8 = CallByName Num.24 Test.11 Test.12 catch
-        dec Test.1;
-        unreachable;
-    let Test.9 = 3i64;
-    invoke Test.3 = CallByName Num.24 Test.8 Test.9 catch
-        dec Test.1;
-        unreachable;
+    let Test.11 = 1i64;
+    let Test.12 = 2i64;
+    let Test.1 = Array [Test.11, Test.12];
+    let Test.9 = 5i64;
+    let Test.10 = 4i64;
+    let Test.7 = CallByName Num.24 Test.9 Test.10;
+    let Test.8 = 3i64;
+    let Test.3 = CallByName Num.24 Test.7 Test.8;
     let Test.4 = CallByName List.7 Test.1;
     dec Test.1;
     let Test.2 = CallByName Num.24 Test.3 Test.4;

compiler/test_mono/generated/ir_when_just.txt

@@ -3,16 +3,16 @@ procedure Num.24 (#Attr.2, #Attr.3):
     ret Test.6;
 
 procedure Test.0 ():
-    let Test.12 = 41i64;
-    let Test.1 = Just Test.12;
-    let Test.9 = 0i64;
-    let Test.10 = GetTagId Test.1;
-    let Test.11 = lowlevel Eq Test.9 Test.10;
-    if Test.11 then
+    let Test.11 = 41i64;
+    let Test.1 = Just Test.11;
+    let Test.8 = 0i64;
+    let Test.9 = GetTagId Test.1;
+    let Test.10 = lowlevel Eq Test.8 Test.9;
+    if Test.10 then
         let Test.3 = UnionAtIndex (Id 0) (Index 0) Test.1;
         let Test.5 = 1i64;
         let Test.4 = CallByName Num.24 Test.3 Test.5;
         ret Test.4;
     else
-        let Test.8 = 1i64;
-        ret Test.8;
+        let Test.7 = 1i64;
+        ret Test.7;

compiler/test_mono/generated/linked_list_length_twice.txt

@@ -3,18 +3,18 @@ procedure Num.24 (#Attr.2, #Attr.3):
     ret Test.10;
 
 procedure Test.3 (Test.5):
-    let Test.18 = 1i64;
-    let Test.19 = GetTagId Test.5;
-    let Test.20 = lowlevel Eq Test.18 Test.19;
-    if Test.20 then
-        let Test.13 = 0i64;
-        ret Test.13;
+    let Test.16 = 1i64;
+    let Test.17 = GetTagId Test.5;
+    let Test.18 = lowlevel Eq Test.16 Test.17;
+    if Test.18 then
+        let Test.12 = 0i64;
+        ret Test.12;
     else
         let Test.6 = UnionAtIndex (Id 0) (Index 1) Test.5;
-        let Test.15 = 1i64;
-        let Test.16 = CallByName Test.3 Test.6;
-        let Test.14 = CallByName Num.24 Test.15 Test.16;
-        ret Test.14;
+        let Test.14 = 1i64;
+        let Test.15 = CallByName Test.3 Test.6;
+        let Test.13 = CallByName Num.24 Test.14 Test.15;
+        ret Test.13;
 
 procedure Test.0 ():
     let Test.2 = Nil ;

compiler/test_mono/generated/list_cannot_update_inplace.txt

@@ -1,40 +1,40 @@
 procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
-    let Test.23 = lowlevel ListLen #Attr.2;
-    let Test.21 = lowlevel NumLt #Attr.3 Test.23;
-    if Test.21 then
-        let Test.22 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
-        ret Test.22;
+    let Test.22 = lowlevel ListLen #Attr.2;
+    let Test.20 = lowlevel NumLt #Attr.3 Test.22;
+    if Test.20 then
+        let Test.21 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
+        ret Test.21;
     else
         ret #Attr.2;
 
 procedure List.7 (#Attr.2):
-    let Test.10 = lowlevel ListLen #Attr.2;
-    ret Test.10;
+    let Test.9 = lowlevel ListLen #Attr.2;
+    ret Test.9;
 
 procedure Num.24 (#Attr.2, #Attr.3):
     let Test.7 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Test.7;
 
 procedure Test.1 ():
-    let Test.12 = 1i64;
-    let Test.13 = 2i64;
-    let Test.14 = 3i64;
-    let Test.11 = Array [Test.12, Test.13, Test.14];
-    ret Test.11;
+    let Test.11 = 1i64;
+    let Test.12 = 2i64;
+    let Test.13 = 3i64;
+    let Test.10 = Array [Test.11, Test.12, Test.13];
+    ret Test.10;
 
 procedure Test.2 (Test.3):
+    let Test.17 = 0i64;
     let Test.18 = 0i64;
-    let Test.19 = 0i64;
-    let Test.17 = CallByName List.4 Test.3 Test.18 Test.19;
-    ret Test.17;
+    let Test.16 = CallByName List.4 Test.3 Test.17 Test.18;
+    ret Test.16;
 
 procedure Test.0 ():
-    let Test.16 = CallByName Test.1;
-    let Test.15 = CallByName Test.2 Test.16;
-    let Test.5 = CallByName List.7 Test.15;
-    dec Test.15;
-    let Test.9 = CallByName Test.1;
-    let Test.6 = CallByName List.7 Test.9;
-    dec Test.9;
+    let Test.15 = CallByName Test.1;
+    let Test.14 = CallByName Test.2 Test.15;
+    let Test.5 = CallByName List.7 Test.14;
+    dec Test.14;
+    let Test.8 = CallByName Test.1;
+    let Test.6 = CallByName List.7 Test.8;
+    dec Test.8;
     let Test.4 = CallByName Num.24 Test.5 Test.6;
     ret Test.4;

compiler/test_mono/generated/list_len.txt

@@ -1,22 +1,22 @@
+procedure List.7 (#Attr.2):
+    let Test.7 = lowlevel ListLen #Attr.2;
+    ret Test.7;
+
 procedure List.7 (#Attr.2):
     let Test.8 = lowlevel ListLen #Attr.2;
     ret Test.8;
 
-procedure List.7 (#Attr.2):
-    let Test.9 = lowlevel ListLen #Attr.2;
-    ret Test.9;
-
 procedure Num.24 (#Attr.2, #Attr.3):
     let Test.6 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Test.6;
 
 procedure Test.0 ():
-    let Test.11 = 1i64;
-    let Test.12 = 2i64;
-    let Test.13 = 3i64;
-    let Test.1 = Array [Test.11, Test.12, Test.13];
-    let Test.10 = 1f64;
-    let Test.2 = Array [Test.10];
+    let Test.10 = 1i64;
+    let Test.11 = 2i64;
+    let Test.12 = 3i64;
+    let Test.1 = Array [Test.10, Test.11, Test.12];
+    let Test.9 = 1f64;
+    let Test.2 = Array [Test.9];
     let Test.4 = CallByName List.7 Test.1;
     dec Test.1;
     let Test.5 = CallByName List.7 Test.2;

compiler/test_mono/generated/nested_pattern_match.txt

@@ -3,28 +3,28 @@ procedure Num.24 (#Attr.2, #Attr.3):
     ret Test.8;
 
 procedure Test.0 ():
-    let Test.21 = 41i64;
-    let Test.20 = Just Test.21;
-    let Test.2 = Just Test.20;
-    joinpoint Test.17:
-        let Test.10 = 1i64;
-        ret Test.10;
+    let Test.20 = 41i64;
+    let Test.19 = Just Test.20;
+    let Test.2 = Just Test.19;
+    joinpoint Test.16:
+        let Test.9 = 1i64;
+        ret Test.9;
     in
-    let Test.15 = 0i64;
-    let Test.16 = GetTagId Test.2;
-    let Test.19 = lowlevel Eq Test.15 Test.16;
-    if Test.19 then
-        let Test.12 = UnionAtIndex (Id 0) (Index 0) Test.2;
-        let Test.13 = 0i64;
-        let Test.14 = GetTagId Test.12;
-        let Test.18 = lowlevel Eq Test.13 Test.14;
-        if Test.18 then
-            let Test.11 = UnionAtIndex (Id 0) (Index 0) Test.2;
-            let Test.5 = UnionAtIndex (Id 0) (Index 0) Test.11;
+    let Test.14 = 0i64;
+    let Test.15 = GetTagId Test.2;
+    let Test.18 = lowlevel Eq Test.14 Test.15;
+    if Test.18 then
+        let Test.11 = UnionAtIndex (Id 0) (Index 0) Test.2;
+        let Test.12 = 0i64;
+        let Test.13 = GetTagId Test.11;
+        let Test.17 = lowlevel Eq Test.12 Test.13;
+        if Test.17 then
+            let Test.10 = UnionAtIndex (Id 0) (Index 0) Test.2;
+            let Test.5 = UnionAtIndex (Id 0) (Index 0) Test.10;
             let Test.7 = 1i64;
             let Test.6 = CallByName Num.24 Test.5 Test.7;
             ret Test.6;
         else
-            jump Test.17;
+            jump Test.16;
     else
-        jump Test.17;
+        jump Test.16;

compiler/test_mono/generated/optional_when.txt

@@ -3,10 +3,10 @@ procedure Num.26 (#Attr.2, #Attr.3):
     ret Test.17;
 
 procedure Test.1 (Test.6):
-    let Test.25 = StructAtIndex 1 Test.6;
-    let Test.26 = false;
-    let Test.27 = lowlevel Eq Test.26 Test.25;
-    if Test.27 then
+    let Test.22 = StructAtIndex 1 Test.6;
+    let Test.23 = false;
+    let Test.24 = lowlevel Eq Test.23 Test.22;
+    if Test.24 then
         let Test.8 = StructAtIndex 0 Test.6;
         ret Test.8;
     else
@@ -14,9 +14,9 @@ procedure Test.1 (Test.6):
         ret Test.10;
 
 procedure Test.1 (Test.6):
-    let Test.36 = false;
-    let Test.37 = lowlevel Eq Test.36 Test.6;
-    if Test.37 then
+    let Test.33 = false;
+    let Test.34 = lowlevel Eq Test.33 Test.6;
+    if Test.34 then
         let Test.8 = 3i64;
         ret Test.8;
     else
@@ -24,19 +24,19 @@ procedure Test.1 (Test.6):
         ret Test.10;
 
 procedure Test.0 ():
-    let Test.40 = true;
-    let Test.5 = CallByName Test.1 Test.40;
-    let Test.38 = false;
-    let Test.3 = CallByName Test.1 Test.38;
-    let Test.31 = 11i64;
-    let Test.32 = true;
-    let Test.30 = Struct {Test.31, Test.32};
-    let Test.4 = CallByName Test.1 Test.30;
-    let Test.28 = 7i64;
-    let Test.29 = false;
-    let Test.22 = Struct {Test.28, Test.29};
-    let Test.2 = CallByName Test.1 Test.22;
-    let Test.19 = CallByName Num.26 Test.2 Test.3;
-    let Test.16 = CallByName Num.26 Test.19 Test.4;
+    let Test.37 = true;
+    let Test.5 = CallByName Test.1 Test.37;
+    let Test.35 = false;
+    let Test.3 = CallByName Test.1 Test.35;
+    let Test.28 = 11i64;
+    let Test.29 = true;
+    let Test.27 = Struct {Test.28, Test.29};
+    let Test.4 = CallByName Test.1 Test.27;
+    let Test.25 = 7i64;
+    let Test.26 = false;
+    let Test.19 = Struct {Test.25, Test.26};
+    let Test.2 = CallByName Test.1 Test.19;
+    let Test.18 = CallByName Num.26 Test.2 Test.3;
+    let Test.16 = CallByName Num.26 Test.18 Test.4;
     let Test.15 = CallByName Num.26 Test.16 Test.5;
     ret Test.15;

compiler/test_mono/generated/quicksort_help.txt

@@ -3,30 +3,28 @@ procedure Num.24 (#Attr.2, #Attr.3):
     ret Test.19;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Test.23 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Test.23;
+    let Test.22 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Test.22;
 
 procedure Num.27 (#Attr.2, #Attr.3):
-    let Test.28 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Test.28;
+    let Test.26 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Test.26;
 
 procedure Test.1 (Test.2, Test.3, Test.4):
     joinpoint Test.12 Test.2 Test.3 Test.4:
         let Test.14 = CallByName Num.27 Test.3 Test.4;
         if Test.14 then
             dec Test.2;
-            let Test.27 = Array [];
-            let Test.26 = 0i64;
-            let Test.25 = Struct {Test.26, Test.27};
-            let Test.5 = StructAtIndex 0 Test.25;
-            let Test.6 = StructAtIndex 1 Test.25;
-            let Test.22 = 1i64;
-            let Test.21 = CallByName Num.25 Test.5 Test.22;
-            let Test.16 = CallByName Test.1 Test.6 Test.3 Test.21;
+            let Test.25 = Array [];
+            let Test.24 = 0i64;
+            let Test.23 = Struct {Test.24, Test.25};
+            let Test.5 = StructAtIndex 0 Test.23;
+            let Test.6 = StructAtIndex 1 Test.23;
+            let Test.21 = 1i64;
+            let Test.20 = CallByName Num.25 Test.5 Test.21;
+            let Test.16 = CallByName Test.1 Test.6 Test.3 Test.20;
             let Test.18 = 1i64;
-            invoke Test.17 = CallByName Num.24 Test.5 Test.18 catch
-                dec Test.16;
-                unreachable;
+            let Test.17 = CallByName Num.24 Test.5 Test.18;
             jump Test.12 Test.16 Test.17 Test.4;
         else
             ret Test.2;

compiler/test_mono/generated/record_optional_field_function_no_use_default.txt

@@ -10,8 +10,8 @@ procedure Test.1 (Test.4):
     ret Test.7;
 
 procedure Test.0 ():
-    let Test.10 = 4i64;
-    let Test.11 = 9i64;
-    let Test.6 = Struct {Test.10, Test.11};
+    let Test.9 = 4i64;
+    let Test.10 = 9i64;
+    let Test.6 = Struct {Test.9, Test.10};
     let Test.5 = CallByName Test.1 Test.6;
     ret Test.5;

compiler/test_mono/generated/record_optional_field_function_use_default.txt

@@ -9,6 +9,6 @@ procedure Test.1 (Test.4):
     ret Test.7;
 
 procedure Test.0 ():
-    let Test.10 = 9i64;
-    let Test.5 = CallByName Test.1 Test.10;
+    let Test.9 = 9i64;
+    let Test.5 = CallByName Test.1 Test.9;
     ret Test.5;

compiler/test_mono/generated/record_optional_field_let_no_use_default.txt

@@ -9,8 +9,8 @@ procedure Test.1 (Test.2):
     ret Test.7;
 
 procedure Test.0 ():
-    let Test.10 = 4i64;
-    let Test.11 = 9i64;
-    let Test.6 = Struct {Test.10, Test.11};
+    let Test.9 = 4i64;
+    let Test.10 = 9i64;
+    let Test.6 = Struct {Test.9, Test.10};
     let Test.5 = CallByName Test.1 Test.6;
     ret Test.5;

compiler/test_mono/generated/record_optional_field_let_use_default.txt

@@ -8,6 +8,6 @@ procedure Test.1 (Test.2):
     ret Test.7;
 
 procedure Test.0 ():
-    let Test.10 = 9i64;
-    let Test.5 = CallByName Test.1 Test.10;
+    let Test.9 = 9i64;
+    let Test.5 = CallByName Test.1 Test.9;
     ret Test.5;

compiler/test_mono/generated/somehow_drops_definitions.txt

@@ -1,23 +1,23 @@
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Test.25 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Test.25;
+    let Test.24 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Test.24;
 
 procedure Num.26 (#Attr.2, #Attr.3):
     let Test.19 = lowlevel NumMul #Attr.2 #Attr.3;
     ret Test.19;
 
 procedure Test.1 ():
-    let Test.27 = 1i64;
-    ret Test.27;
+    let Test.25 = 1i64;
+    ret Test.25;
 
 procedure Test.2 ():
-    let Test.21 = 2i64;
-    ret Test.21;
+    let Test.20 = 2i64;
+    ret Test.20;
 
 procedure Test.3 (Test.6):
-    let Test.24 = CallByName Test.1;
-    let Test.23 = CallByName Num.24 Test.6 Test.24;
-    ret Test.23;
+    let Test.23 = CallByName Test.1;
+    let Test.22 = CallByName Num.24 Test.6 Test.23;
+    ret Test.22;
 
 procedure Test.4 (Test.7):
     let Test.18 = CallByName Test.2;
@@ -34,8 +34,8 @@ procedure Test.0 ():
         let Test.11 = CallByName Test.5 Test.12 Test.13;
         ret Test.11;
     in
-    let Test.22 = true;
-    if Test.22 then
+    let Test.21 = true;
+    if Test.21 then
         let Test.3 = Struct {};
         jump Test.16 Test.3;
     else

compiler/test_mono/generated/specialize_closures.txt

@@ -1,6 +1,6 @@
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Test.29 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Test.29;
+    let Test.28 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Test.28;
 
 procedure Num.26 (#Attr.2, #Attr.3):
     let Test.25 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -23,8 +23,8 @@ procedure Test.1 (Test.2, Test.3):
 
 procedure Test.7 (Test.10, #Attr.12):
     let Test.4 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let Test.28 = CallByName Num.24 Test.10 Test.4;
-    ret Test.28;
+    let Test.27 = CallByName Num.24 Test.10 Test.4;
+    ret Test.27;
 
 procedure Test.8 (Test.11, #Attr.12):
     let Test.6 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
@@ -44,8 +44,8 @@ procedure Test.0 ():
         let Test.13 = CallByName Test.1 Test.14 Test.15;
         ret Test.13;
     in
-    let Test.27 = true;
-    if Test.27 then
+    let Test.26 = true;
+    if Test.26 then
         let Test.7 = ClosureTag(Test.7) Test.4;
         jump Test.22 Test.7;
     else

compiler/test_mono/generated/specialize_lowlevel.txt

@@ -1,6 +1,6 @@
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Test.25 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Test.25;
+    let Test.24 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Test.24;
 
 procedure Num.26 (#Attr.2, #Attr.3):
     let Test.21 = lowlevel NumMul #Attr.2 #Attr.3;
@@ -8,8 +8,8 @@ procedure Num.26 (#Attr.2, #Attr.3):
 
 procedure Test.6 (Test.8, #Attr.12):
     let Test.4 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let Test.24 = CallByName Num.24 Test.8 Test.4;
-    ret Test.24;
+    let Test.23 = CallByName Num.24 Test.8 Test.4;
+    ret Test.23;
 
 procedure Test.7 (Test.9, #Attr.12):
     let Test.5 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
@@ -35,8 +35,8 @@ procedure Test.0 ():
                 jump Test.15 Test.17;
         
     in
-    let Test.23 = true;
-    if Test.23 then
+    let Test.22 = true;
+    if Test.22 then
         let Test.6 = ClosureTag(Test.6) Test.4;
         jump Test.19 Test.6;
     else

compiler/test_mono/generated/when_nested_maybe.txt

@@ -3,28 +3,28 @@ procedure Num.24 (#Attr.2, #Attr.3):
     ret Test.8;
 
 procedure Test.0 ():
-    let Test.21 = 41i64;
-    let Test.20 = Just Test.21;
-    let Test.2 = Just Test.20;
-    joinpoint Test.17:
-        let Test.10 = 1i64;
-        ret Test.10;
+    let Test.20 = 41i64;
+    let Test.19 = Just Test.20;
+    let Test.2 = Just Test.19;
+    joinpoint Test.16:
+        let Test.9 = 1i64;
+        ret Test.9;
     in
-    let Test.15 = 0i64;
-    let Test.16 = GetTagId Test.2;
-    let Test.19 = lowlevel Eq Test.15 Test.16;
-    if Test.19 then
-        let Test.12 = UnionAtIndex (Id 0) (Index 0) Test.2;
-        let Test.13 = 0i64;
-        let Test.14 = GetTagId Test.12;
-        let Test.18 = lowlevel Eq Test.13 Test.14;
-        if Test.18 then
-            let Test.11 = UnionAtIndex (Id 0) (Index 0) Test.2;
-            let Test.5 = UnionAtIndex (Id 0) (Index 0) Test.11;
+    let Test.14 = 0i64;
+    let Test.15 = GetTagId Test.2;
+    let Test.18 = lowlevel Eq Test.14 Test.15;
+    if Test.18 then
+        let Test.11 = UnionAtIndex (Id 0) (Index 0) Test.2;
+        let Test.12 = 0i64;
+        let Test.13 = GetTagId Test.11;
+        let Test.17 = lowlevel Eq Test.12 Test.13;
+        if Test.17 then
+            let Test.10 = UnionAtIndex (Id 0) (Index 0) Test.2;
+            let Test.5 = UnionAtIndex (Id 0) (Index 0) Test.10;
             let Test.7 = 1i64;
             let Test.6 = CallByName Num.24 Test.5 Test.7;
             ret Test.6;
         else
-            jump Test.17;
+            jump Test.16;
     else
-        jump Test.17;
+        jump Test.16;

compiler/test_mono/generated/when_on_record.txt

@@ -3,7 +3,7 @@ procedure Num.24 (#Attr.2, #Attr.3):
     ret Test.5;
 
 procedure Test.0 ():
-    let Test.7 = 2i64;
+    let Test.6 = 2i64;
     let Test.4 = 3i64;
-    let Test.3 = CallByName Num.24 Test.7 Test.4;
+    let Test.3 = CallByName Num.24 Test.6 Test.4;
     ret Test.3;

compiler/test_mono/generated/when_on_two_values.txt

@@ -3,26 +3,26 @@ procedure Num.24 (#Attr.2, #Attr.3):
     ret Test.7;
 
 procedure Test.0 ():
-    let Test.17 = 3i64;
-    let Test.16 = 2i64;
-    let Test.4 = Struct {Test.16, Test.17};
-    joinpoint Test.13:
+    let Test.16 = 3i64;
+    let Test.15 = 2i64;
+    let Test.4 = Struct {Test.15, Test.16};
+    joinpoint Test.12:
         let Test.2 = StructAtIndex 0 Test.4;
         let Test.3 = StructAtIndex 1 Test.4;
         let Test.6 = CallByName Num.24 Test.2 Test.3;
         ret Test.6;
     in
-    let Test.11 = StructAtIndex 1 Test.4;
-    let Test.12 = 3i64;
-    let Test.15 = lowlevel Eq Test.12 Test.11;
-    if Test.15 then
-        let Test.9 = StructAtIndex 0 Test.4;
-        let Test.10 = 4i64;
-        let Test.14 = lowlevel Eq Test.10 Test.9;
-        if Test.14 then
+    let Test.10 = StructAtIndex 1 Test.4;
+    let Test.11 = 3i64;
+    let Test.14 = lowlevel Eq Test.11 Test.10;
+    if Test.14 then
+        let Test.8 = StructAtIndex 0 Test.4;
+        let Test.9 = 4i64;
+        let Test.13 = lowlevel Eq Test.9 Test.8;
+        if Test.13 then
             let Test.5 = 9i64;
             ret Test.5;
         else
-            jump Test.13;
+            jump Test.12;
     else
-        jump Test.13;
+        jump Test.12;

examples/benchmarks/platform/host.zig

@@ -45,6 +45,13 @@ export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void {
     free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
 }
 
+export fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    const msg = @ptrCast([*:0]const u8, c_ptr);
+    stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
+    std.process.exit(0);
+}
+
 const Unit = extern struct {};
 
 pub export fn main() u8 {

examples/effect/thing/platform-dir/host.zig

@@ -45,6 +45,13 @@ export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void {
     free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
 }
 
+export fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    const msg = @ptrCast([*:0]const u8, c_ptr);
+    stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
+    std.process.exit(0);
+}
+
 const Unit = extern struct {};
 
 pub export fn main() u8 {

examples/hello-rust/platform/src/lib.rs

@@ -2,7 +2,9 @@
 
 use core::ffi::c_void;
 use core::mem::MaybeUninit;
+use libc::c_char;
 use roc_std::{RocCallResult, RocStr};
+use std::ffi::CStr;
 
 extern "C" {
     #[link_name = "roc__mainForHost_1_exposed"]
@@ -29,6 +31,19 @@ pub unsafe fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) {
     return libc::free(c_ptr);
 }
 
+#[no_mangle]
+pub unsafe fn roc_panic(c_ptr: *mut c_void, tag_id: u32) {
+    match tag_id {
+        0 => {
+            let slice = CStr::from_ptr(c_ptr as *const c_char);
+            let string = slice.to_str().unwrap();
+            eprintln!("Roc hit a panic: {}", string);
+            std::process::exit(1);
+        }
+        _ => todo!(),
+    }
+}
+
 #[no_mangle]
 pub fn rust_main() -> isize {
     let mut call_result: MaybeUninit<RocCallResult<RocStr>> = MaybeUninit::uninit();

examples/hello-world/platform/host.c

@@ -17,6 +17,12 @@ void roc_dealloc(void* ptr, unsigned int alignment) {
     free(ptr);
 }
 
+void roc_panic(void* ptr, unsigned int alignment) {
+    char* msg = (char *)ptr; 
+    fprintf(stderr, "Application crashed with message\n\n    %s\n\nShutting down\n", msg);
+    exit(0);
+}
+
 struct RocStr {
     char* bytes;
     size_t len;

examples/hello-zig/platform/host.zig

@@ -35,6 +35,13 @@ export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void {
     free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
 }
 
+export fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    const msg = @ptrCast([*:0]const u8, c_ptr);
+    stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
+    std.process.exit(0);
+}
+
 const mem = std.mem;
 const Allocator = mem.Allocator;
 

examples/quicksort/platform/host.zig

@@ -38,6 +38,13 @@ export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void {
     free(@alignCast(16, @ptrCast([*]u8, c_ptr)));
 }
 
+export fn roc_panic(c_ptr: *c_void, tag_id: u32) callconv(.C) void {
+    const stderr = std.io.getStdErr().writer();
+    const msg = @ptrCast([*:0]const u8, c_ptr);
+    stderr.print("Application crashed with message\n\n    {s}\n\nShutting down\n", .{msg}) catch unreachable;
+    std.process.exit(0);
+}
+
 // warning! the array is currently stack-allocated so don't make this too big
 const NUM_NUMS = 100;