Merge pull request #9623 from roc-lang/roc-build-default-app

Add build-only default app platform runtime

Author: rtfeldman

build.zig

@@ -4892,6 +4892,32 @@ fn addMainExe(
             b.pathJoin(&.{ "src/cli/targets", cross_target.name, builtins_extern_ext }),
         );
         exe.step.dependOn(&copy_cross_builtins_extern.step);
+
+        if (std.mem.eql(u8, cross_target.name, "x64musl") or std.mem.eql(u8, cross_target.name, "arm64musl")) {
+            const default_platform_runtime_obj = b.addObject(.{
+                .name = b.fmt("roc_default_platform_{s}", .{cross_target.name}),
+                .root_module = b.createModule(.{
+                    .root_source_file = b.path("src/default_platform/linux_runtime.zig"),
+                    .target = cross_resolved_target,
+                    .optimize = .ReleaseFast,
+                    .strip = false,
+                    .omit_frame_pointer = false,
+                    .pic = true,
+                    .single_threaded = true,
+                }),
+            });
+            default_platform_runtime_obj.root_module.stack_check = false;
+            default_platform_runtime_obj.root_module.link_libc = false;
+            default_platform_runtime_obj.bundle_compiler_rt = false;
+            configureBackend(default_platform_runtime_obj, cross_resolved_target);
+
+            const copy_default_platform_runtime = b.addUpdateSourceFiles();
+            copy_default_platform_runtime.addCopyFileToSource(
+                default_platform_runtime_obj.getEmittedBin(),
+                b.pathJoin(&.{ "src/cli/targets", cross_target.name, "roc_default_platform.o" }),
+            );
+            exe.step.dependOn(&copy_default_platform_runtime.step);
+        }
     }
 
     const config = b.addOptions();

src/backend/llvm/MonoLlvmCodeGen.zig

@@ -114,6 +114,7 @@ pub const BuildArgs = struct {
     warning_count_out: ?*usize = null, // optionally receive the total warning count
     require_executable_output: bool = false, // reject static/shared library targets
     suppress_build_status: bool = false, // suppress "Built..." output (used by roc run)
+    synthetic_default_platform: bool = false, // internal: build rewrote a headerless app to the default platform
 };
 
 /// Arguments for `roc test`

src/cli/cli_args.zig

@@ -257,6 +257,23 @@ const BuiltinsObjects = struct {
     }
 };
 
+const DefaultPlatformRuntimeObjects = struct {
+    const x64musl = if (builtin.is_test) &[_]u8{} else @embedFile("targets/x64musl/roc_default_platform.o");
+    const arm64musl = if (builtin.is_test) &[_]u8{} else @embedFile("targets/arm64musl/roc_default_platform.o");
+
+    pub fn forTarget(target: RocTarget) ?[]const u8 {
+        return switch (target) {
+            .x64musl => x64musl,
+            .arm64musl => arm64musl,
+            else => null,
+        };
+    }
+
+    pub fn filename() []const u8 {
+        return "roc_default_platform.o";
+    }
+};
+
 // Workaround for Zig standard library compilation issue on macOS ARM64.
 //
 // The Problem:
@@ -1814,6 +1831,7 @@ fn rocRun(ctx: *CliCtx, args: cli_args.RunArgs) anyerror!void {
                 host_input_paths.items,
                 try hostedSymbolsFromLir(ctx.arena, &view.store),
                 target_name,
+                false,
             );
         }
 
@@ -3570,13 +3588,9 @@ fn rocBuild(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
         return;
     }
 
-    // Headerless apps use a simple builtin platform and cannot be compiled
+    // Headerless apps build through a synthetic default platform.
     if (try readDefaultAppSource(ctx, args.path)) |source| {
-        ctx.gpa.free(source);
-        try renderProblem(ctx.gpa, ctx.io.stderr(), .{
-            .build_not_supported_for_headerless = .{ .app_path = args.path },
-        });
-        return error.UnsupportedTarget;
+        return rocBuildDefaultApp(ctx, args, source);
     }
 
     // Select build path based on optimization level
@@ -3587,6 +3601,63 @@ fn rocBuild(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
     }
 }
 
+fn rocBuildDefaultApp(ctx: *CliCtx, args: cli_args.BuildArgs, original_source: []const u8) anyerror!void {
+    defer ctx.gpa.free(original_source);
+
+    const temp_dir = createUniqueTempDir(ctx) catch |err| {
+        return ctx.fail(.{ .temp_dir_failed = .{ .err = err } });
+    };
+    defer std.Io.Dir.cwd().deleteTree(ctx.io.std_io, temp_dir) catch {};
+
+    const platform_dir = try std.fs.path.join(ctx.arena, &.{ temp_dir, ".roc_echo_platform" });
+    try std.Io.Dir.cwd().createDirPath(ctx.io.std_io, platform_dir);
+
+    const app_filename = std.fs.path.basename(args.path);
+    const app_path = try std.fs.path.join(ctx.arena, &.{ temp_dir, app_filename });
+    const platform_main_path = try std.fs.path.join(ctx.arena, &.{ platform_dir, "main.roc" });
+    const echo_module_path = try std.fs.path.join(ctx.arena, &.{ platform_dir, "Echo.roc" });
+
+    const header =
+        "app [main!] { pf: platform \"./.roc_echo_platform/main.roc\" }\n\n" ++
+        "import pf.Echo\n\n" ++
+        "echo! = |msg| Echo.line!(msg)\n\n";
+    const synthetic_source = try std.mem.concat(ctx.gpa, u8, &.{ header, original_source });
+    defer ctx.gpa.free(synthetic_source);
+
+    try std.Io.Dir.cwd().writeFile(ctx.io.std_io, .{ .sub_path = app_path, .data = synthetic_source });
+    try std.Io.Dir.cwd().writeFile(ctx.io.std_io, .{ .sub_path = platform_main_path, .data = defaultBuildPlatformSource(args) });
+    try std.Io.Dir.cwd().writeFile(ctx.io.std_io, .{ .sub_path = echo_module_path, .data = echo_platform.echo_module_source });
+
+    var synthetic_args = args;
+    synthetic_args.path = app_path;
+    synthetic_args.synthetic_default_platform = true;
+    if (synthetic_args.output == null) {
+        synthetic_args.output = try base.module_path.getModuleNameAlloc(ctx.arena, args.path);
+    }
+
+    switch (synthetic_args.opt) {
+        .dev => try rocBuildNative(ctx, synthetic_args),
+        .interpreter => try rocBuildEmbedded(ctx, synthetic_args),
+        .size, .speed => try rocBuildLlvm(ctx, synthetic_args),
+    }
+}
+
+fn defaultBuildPlatformSource(args: cli_args.BuildArgs) []const u8 {
+    const target = if (args.target) |target_str|
+        RocTarget.fromString(target_str)
+    else
+        RocTarget.detectNative();
+
+    if (target) |roc_build_target| {
+        return switch (roc_build_target.toOsTag()) {
+            .macos, .windows => echo_platform.build_c_platform_main_source,
+            else => echo_platform.build_platform_main_source,
+        };
+    }
+
+    return echo_platform.build_platform_main_source;
+}
+
 /// Build using the dev backend to generate native machine code.
 /// This produces truly compiled executables without an interpreter.
 fn nativeBuildEntrypoints(
@@ -3764,7 +3835,12 @@ fn verifyHostInputSymbols(
     host_input_paths: []const []const u8,
     hosted_symbols: []const []const u8,
     target_name: []const u8,
+    synthetic_default_platform: bool,
 ) anyerror!void {
+    if (host_input_paths.len == 0 and synthetic_default_platform) {
+        return;
+    }
+
     var needed = std.ArrayList([]const u8).empty;
     try needed.appendSlice(ctx.arena, &host_symbols.runtime_symbols);
     try needed.appendSlice(ctx.arena, hosted_symbols);
@@ -3778,6 +3854,16 @@ fn verifyHostInputSymbols(
     }
 }
 
+fn writeDefaultPlatformRuntimeObject(ctx: *CliCtx, build_cache_dir: []const u8, target: RocTarget) anyerror!?[]const u8 {
+    const bytes = DefaultPlatformRuntimeObjects.forTarget(target) orelse return null;
+    const runtime_path = try std.fs.path.join(ctx.arena, &.{ build_cache_dir, DefaultPlatformRuntimeObjects.filename() });
+    backend.writeFileWindowsAvSafe(ctx.io.std_io, runtime_path, bytes) catch |err| {
+        std.log.err("Failed to write default platform runtime object {s}: {}", .{ runtime_path, err });
+        return err;
+    };
+    return runtime_path;
+}
+
 /// The host inputs of a link, in link order.
 fn hostInputPaths(ctx: *CliCtx, link_inputs: PlatformLinkInputs) std.mem.Allocator.Error![]const []const u8 {
     var paths = try std.array_list.Managed([]const u8).initCapacity(
@@ -4459,6 +4545,8 @@ fn compileLlvmAppObject(
     link_type: roc_target.OutputKind,
     lowered: *const lir.CheckedPipeline.LoweredProgram,
     entrypoints: []const backend.Entrypoint,
+    enable_default_platform_runtime: bool,
+    enable_default_platform_hosted_calls: bool,
 ) anyerror!LlvmObjectPaths {
     const std_target = try stdTargetForLlvmBuild(ctx, target);
     const llvm_cpu = llvmCpuNameForTarget(std_target);
@@ -4471,6 +4559,9 @@ fn compileLlvmAppObject(
     );
     codegen.layout_store = &lowered.lir_result.layouts;
     codegen.emit_debug_info = true;
+    codegen.enable_default_platform_runtime = enable_default_platform_runtime;
+    codegen.enable_default_platform_hosted_calls = enable_default_platform_hosted_calls;
+    codegen.enable_default_platform_diagnostics = enable_default_platform_hosted_calls and args.debug;
     codegen.debug_producer = "roc " ++ build_options.compiler_version;
     defer codegen.deinit();
 
@@ -4624,7 +4715,7 @@ fn rocBuildWasmLlvm(
         unreachable;
     }
 
-    const app_object = try compileLlvmAppObject(ctx, args, build_cache_dir, .wasm32, link_type, lowered, entrypoints);
+    const app_object = try compileLlvmAppObject(ctx, args, build_cache_dir, .wasm32, link_type, lowered, entrypoints, false, false);
 
     var owned_inputs: std.ArrayList([]u8) = .empty;
     defer freeOwnedWasmInputs(ctx, &owned_inputs);
@@ -4890,6 +4981,7 @@ fn rocBuildLlvm(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
         .{
             .target_usize = target_usize,
             .list_in_place_map = listInPlaceMapForOpt(args.opt),
+            .proc_debug_names = args.synthetic_default_platform,
         },
     );
     defer lowered.deinit();
@@ -4929,7 +5021,20 @@ fn rocBuildLlvm(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
             static_data_exports,
         );
     } else {
-        const app_object = try compileLlvmAppObject(ctx, args, build_cache_dir, target, link_type, &lowered, entrypoints);
+        const hosted_symbols = try hostedSymbolsFromLir(ctx.arena, &lowered.lir_result.store);
+        const enable_default_platform_runtime = target_os == .linux and args.synthetic_default_platform;
+
+        const app_object = try compileLlvmAppObject(
+            ctx,
+            args,
+            build_cache_dir,
+            target,
+            link_type,
+            &lowered,
+            entrypoints,
+            enable_default_platform_runtime,
+            args.synthetic_default_platform,
+        );
 
         var static_data_obj_path: ?[]const u8 = null;
         if (static_data_exports.len > 0) {
@@ -4952,15 +5057,23 @@ fn rocBuildLlvm(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
         if (static_data_obj_path) |path| {
             try object_files.append(path);
         }
+        if (enable_default_platform_runtime) {
+            if (try writeDefaultPlatformRuntimeObject(ctx, build_cache_dir, target)) |runtime_path| {
+                try object_files.append(runtime_path);
+            } else {
+                return error.UnsupportedTarget;
+            }
+        }
 
         if (link_type == .archive) {
             try writeArchiveOutput(ctx, target, final_output_path, link_inputs, object_files.items);
         } else {
             try verifyHostInputSymbols(
                 ctx,
                 try hostInputPaths(ctx, link_inputs),
-                try hostedSymbolsFromLir(ctx.arena, &lowered.lir_result.store),
+                hosted_symbols,
                 link_inputs.target_name,
+                args.synthetic_default_platform,
             );
 
             const force_undefined_symbols = try staticDataLinkRootSymbols(ctx, static_data_exports);
@@ -5179,6 +5292,7 @@ fn rocBuildNative(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
             .target_usize = target_usize,
             .inline_mode = postCheckInlineModeForOpt(args.opt),
             .list_in_place_map = listInPlaceMapForOpt(args.opt),
+            .proc_debug_names = args.synthetic_default_platform,
         },
     );
     defer lowered.deinit();
@@ -5292,6 +5406,7 @@ fn rocBuildNative(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
             try hostInputPaths(ctx, link_inputs),
             try hostedSymbolsFromLir(ctx.arena, &lowered.lir_result.store),
             link_inputs.target_name,
+            false,
         );
 
         const force_undefined_symbols = try staticDataLinkRootSymbols(ctx, static_data_exports);