Merge branch 'main' into luke-windows

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

@@ -710,7 +710,7 @@ impl LlvmBackendMode {
         match self {
             LlvmBackendMode::Binary => false,
             LlvmBackendMode::BinaryDev => false,
-            LlvmBackendMode::BinaryGlue => false,
+            LlvmBackendMode::BinaryGlue => true,
             LlvmBackendMode::GenTest => true,
             LlvmBackendMode::WasmGenTest => true,
             LlvmBackendMode::CliTest => true,
@@ -1060,9 +1060,9 @@ pub fn module_from_builtins<'ctx>(
 
     // In testing, this adds about 20ms extra to compilation.
     // Long term it would be best if we could do this on the zig side.
-    // This change enables us to dce all the parts of compiler-rt we don't use.
-    // That said, it would be better to dce them before roc app compiltation time.
-    // Anything not depended on by a `roc_builtin.` function could alread by DCE'd theoretically.
+    // The core issue is that we have to properly labael certain functions as private and DCE them.
+    // Otherwise, now that zig bundles all of compiler-rt, we would optimize and compile the entire library.
+    // Anything not depended on by a `roc_builtin.` function could already by DCE'd theoretically.
     // That said, this workaround is good enough and fixes compilations times.
 
     // Also, must_keep is the functions we depend on that would normally be provide by libc.
@@ -1072,6 +1072,11 @@ pub fn module_from_builtins<'ctx>(
         "floorf",
         "memcpy",
         "memset",
+        // I have no idea why this function is special.
+        // Without it, some tests hang on M1 mac outside of nix.
+        "__muloti4",
+        // fixes `Undefined Symbol in relocation`
+        "__udivti3",
         // Roc special functions
         "__roc_force_longjmp",
         "__roc_force_setjmp",
@@ -4463,31 +4468,68 @@ fn expose_function_to_host_help_c_abi_generic<'a, 'ctx>(
         }
     }
 
-    let arguments_for_call = &arguments_for_call.into_bump_slice();
-
     let call_result = if env.mode.returns_roc_result() {
-        debug_assert_eq!(args.len(), roc_function.get_params().len());
+        if args.len() == roc_function.get_params().len() {
+            let arguments_for_call = &arguments_for_call.into_bump_slice();
 
-        let dbg_loc = builder.get_current_debug_location().unwrap();
-        let roc_wrapper_function =
-            make_exception_catcher(env, layout_interner, roc_function, return_layout);
-        debug_assert_eq!(
-            arguments_for_call.len(),
-            roc_wrapper_function.get_params().len()
-        );
+            let dbg_loc = builder.get_current_debug_location().unwrap();
+            let roc_wrapper_function =
+                make_exception_catcher(env, layout_interner, roc_function, return_layout);
+            debug_assert_eq!(
+                arguments_for_call.len(),
+                roc_wrapper_function.get_params().len()
+            );
 
-        builder.position_at_end(entry);
-        builder.set_current_debug_location(dbg_loc);
+            builder.position_at_end(entry);
+            builder.set_current_debug_location(dbg_loc);
 
-        let wrapped_layout = roc_call_result_layout(env.arena, return_layout);
-        call_direct_roc_function(
-            env,
-            layout_interner,
-            roc_function,
-            wrapped_layout,
-            arguments_for_call,
-        )
+            let wrapped_layout = roc_call_result_layout(env.arena, return_layout);
+            call_direct_roc_function(
+                env,
+                layout_interner,
+                roc_function,
+                wrapped_layout,
+                arguments_for_call,
+            )
+        } else {
+            debug_assert_eq!(args.len() + 1, roc_function.get_params().len());
+
+            arguments_for_call.push(args[0]);
+
+            let arguments_for_call = &arguments_for_call.into_bump_slice();
+
+            let dbg_loc = builder.get_current_debug_location().unwrap();
+            let roc_wrapper_function =
+                make_exception_catcher(env, layout_interner, roc_function, return_layout);
+
+            builder.position_at_end(entry);
+            builder.set_current_debug_location(dbg_loc);
+
+            let wrapped_layout = roc_call_result_layout(env.arena, return_layout);
+            let call_result = call_direct_roc_function(
+                env,
+                layout_interner,
+                roc_wrapper_function,
+                wrapped_layout,
+                arguments_for_call,
+            );
+
+            let output_arg_index = 0;
+
+            let output_arg = c_function
+                .get_nth_param(output_arg_index as u32)
+                .unwrap()
+                .into_pointer_value();
+
+            env.builder.new_build_store(output_arg, call_result);
+
+            builder.new_build_return(None);
+
+            return c_function;
+        }
     } else {
+        let arguments_for_call = &arguments_for_call.into_bump_slice();
+
         call_direct_roc_function(
             env,
             layout_interner,
@@ -4511,6 +4553,7 @@ fn expose_function_to_host_help_c_abi_generic<'a, 'ctx>(
         output_arg,
         call_result,
     );
+
     builder.new_build_return(None);
 
     c_function

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

@@ -80,10 +80,6 @@ pub(crate) fn add_intrinsics<'ctx>(ctx: &'ctx Context, module: &Module<'ctx>) {
     let i32_type = ctx.i32_type();
     let void_type = ctx.void_type();
 
-    if let Some(func) = module.get_function("__muloti4") {
-        func.set_linkage(Linkage::WeakAny);
-    }
-
     add_intrinsic(
         ctx,
         module,