Support extra default app build targets

Author: rtfeldman

src/backend/llvm/MonoLlvmCodeGen.zig

@@ -997,14 +997,12 @@ pub const MonoLlvmCodeGen = struct {
         const file = try self.debugFileFor(builder, self.current_debug_file);
         const empty_expr = builder.debugExpression(&.{}) catch return error.OutOfMemory;
         const previous_debug_location = wip.debug_location;
-        if (self.enable_default_platform_diagnostics) {
-            wip.debug_location = .{ .location = .{
-                .line = proc_line,
-                .column = if (proc_line == 0) 0 else 1,
-                .scope = scope.toOptional(),
-                .inlined_at = .none,
-            } };
-        }
+        wip.debug_location = .{ .location = .{
+            .line = if (self.enable_default_platform_diagnostics) proc_line else 0,
+            .column = if (self.enable_default_platform_diagnostics and proc_line != 0) 1 else 0,
+            .scope = scope.toOptional(),
+            .inlined_at = .none,
+        } };
         defer wip.debug_location = previous_debug_location;
 
         for (self.store.getLocalSpan(proc.frame_locals)) |local_id| {

src/cli/main.zig

@@ -3643,19 +3643,22 @@ fn rocBuildDefaultApp(ctx: *CliCtx, args: cli_args.BuildArgs, original_source: [
 }
 
 fn defaultBuildPlatformSource(args: cli_args.BuildArgs) []const u8 {
-    const target = if (args.target) |target_str|
-        RocTarget.fromString(target_str)
-    else
-        RocTarget.detectNative();
+    if (args.target) |target_str| {
+        if (RocTarget.fromString(target_str)) |target| {
+            return switch (target) {
+                .x64glibc, .arm64glibc, .x64mac, .arm64mac, .x64win, .arm64win => echo_platform.build_c_platform_main_source,
+                .wasm32 => echo_platform.build_wasm_archive_platform_main_source,
+                else => echo_platform.build_platform_main_source,
+            };
+        }
 
-    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;
     }
 
-    return echo_platform.build_platform_main_source;
+    return switch (RocTarget.detectNative().toOsTag()) {
+        .macos, .windows => echo_platform.build_c_platform_main_source,
+        else => echo_platform.build_platform_main_source,
+    };
 }
 
 /// Build using the dev backend to generate native machine code.
@@ -5022,7 +5025,10 @@ fn rocBuildLlvm(ctx: *CliCtx, args: cli_args.BuildArgs) anyerror!void {
         );
     } else {
         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 enable_default_platform_runtime = args.synthetic_default_platform and switch (target) {
+            .x64musl, .arm64musl => true,
+            else => false,
+        };
 
         const app_object = try compileLlvmAppObject(
             ctx,

src/cli/test/parallel_cli_runner.zig

@@ -172,6 +172,9 @@ const CustomCase = enum {
     generated_graph_200_5,
     list_builtin_inlined,
     default_platform_linux_disassembly,
+    default_platform_build_x64glibc,
+    default_platform_build_arm64glibc,
+    default_platform_build_wasm32,
     default_platform_crash_x64musl,
     default_platform_crash_arm64musl,
     default_platform_crash_x64mac,
@@ -528,6 +531,9 @@ const subcommand_cases = [_]CliCase{
     .{ .id = 0, .suite = .subcommands, .name = "roc check generated module graph handles many imported files", .body = .{ .custom = .generated_graph_200_5 } },
     .{ .id = 0, .suite = .subcommands, .name = "list builtins inline in native --opt=speed build", .body = .{ .custom = .list_builtin_inlined } },
     .{ .id = 0, .suite = .subcommands, .name = "roc build default platform x64musl matches direct write assembly", .skip = .{ .always = "TODO: direct-write default-platform codegen" }, .body = .{ .custom = .default_platform_linux_disassembly } },
+    .{ .id = 0, .suite = .subcommands, .name = "roc build default platform x64glibc succeeds", .body = .{ .custom = .default_platform_build_x64glibc } },
+    .{ .id = 0, .suite = .subcommands, .name = "roc build default platform arm64glibc succeeds", .body = .{ .custom = .default_platform_build_arm64glibc } },
+    .{ .id = 0, .suite = .subcommands, .name = "roc build default platform wasm32 archive succeeds", .body = .{ .custom = .default_platform_build_wasm32 } },
     .{ .id = 0, .suite = .subcommands, .name = "default platform crash prints debug backtrace on x64musl", .body = .{ .custom = .default_platform_crash_x64musl } },
     .{ .id = 0, .suite = .subcommands, .name = "default platform crash prints debug backtrace on arm64musl", .body = .{ .custom = .default_platform_crash_arm64musl } },
     .{ .id = 0, .suite = .subcommands, .name = "default platform crash prints debug backtrace on x64mac", .body = .{ .custom = .default_platform_crash_x64mac } },
@@ -1397,6 +1403,9 @@ fn runCustomCase(
         .generated_graph_200_5 => customGeneratedModuleGraph(io, allocator, &env, &timer, timeout_ms, .{ .roc_file_count = 200, .symbols_per_file = 5 }),
         .list_builtin_inlined => customListBuiltinInlined(io, allocator, &env, &timer, timeout_ms),
         .default_platform_linux_disassembly => customDefaultPlatformLinuxDisassembly(io, allocator, &env, &timer, timeout_ms),
+        .default_platform_build_x64glibc => customDefaultPlatformBuild(io, allocator, &env, &timer, timeout_ms, .x64glibc),
+        .default_platform_build_arm64glibc => customDefaultPlatformBuild(io, allocator, &env, &timer, timeout_ms, .arm64glibc),
+        .default_platform_build_wasm32 => customDefaultPlatformBuild(io, allocator, &env, &timer, timeout_ms, .wasm32),
         .default_platform_crash_x64musl => customDefaultPlatformDebugBacktrace(io, allocator, &env, &timer, timeout_ms, .x64musl, .crash),
         .default_platform_crash_arm64musl => customDefaultPlatformDebugBacktrace(io, allocator, &env, &timer, timeout_ms, .arm64musl, .crash),
         .default_platform_crash_x64mac => customDefaultPlatformDebugBacktrace(io, allocator, &env, &timer, timeout_ms, .x64mac, .crash),
@@ -1719,20 +1728,30 @@ fn isHexDigit(byte: u8) bool {
 const DefaultPlatformTarget = enum {
     x64musl,
     arm64musl,
+    x64glibc,
+    arm64glibc,
     x64mac,
     arm64mac,
     x64win,
     arm64win,
+    wasm32,
 
     fn cliName(self: DefaultPlatformTarget) []const u8 {
         return @tagName(self);
     }
 
+    fn canBuildOnHost(self: DefaultPlatformTarget) bool {
+        return switch (self) {
+            .x64glibc, .arm64glibc => builtin.os.tag == .linux,
+            else => true,
+        };
+    }
+
     fn canRunOnHost(self: DefaultPlatformTarget) bool {
         return switch (builtin.os.tag) {
             .linux => switch (builtin.cpu.arch) {
-                .x86_64 => self == .x64musl,
-                .aarch64 => self == .arm64musl,
+                .x86_64 => self == .x64musl or self == .x64glibc,
+                .aarch64 => self == .arm64musl or self == .arm64glibc,
                 else => false,
             },
             .macos => switch (builtin.cpu.arch) {
@@ -1745,6 +1764,7 @@ const DefaultPlatformTarget = enum {
                 .aarch64 => self == .arm64win,
                 else => false,
             },
+            .freestanding => false,
             else => false,
         };
     }
@@ -1799,6 +1819,78 @@ const default_platform_stack_overflow_debug_app =
     \\
 ;
 
+const default_platform_echo_app =
+    \\main! = |_| {
+    \\    echo!("Hello, World!")
+    \\    Ok({})
+    \\}
+    \\
+;
+
+fn customDefaultPlatformBuild(
+    io: std.Io,
+    allocator: Allocator,
+    env: *const CaseEnv,
+    timer: *harness.Timer,
+    timeout_ms: u64,
+    target: DefaultPlatformTarget,
+) ?TestResult {
+    if (!target.canBuildOnHost()) {
+        const message = std.fmt.allocPrint(
+            allocator,
+            "{s} default-platform build requires Linux host support",
+            .{target.cliName()},
+        ) catch "default-platform build requires Linux host support";
+        return .{ .status = .skip, .phase = .setup, .duration_ns = timer.read(), .message = message };
+    }
+
+    const app_filename = std.fmt.allocPrint(allocator, "default_platform_build_{s}.roc", .{target.cliName()}) catch |err|
+        return customInfraFailure(allocator, timer, "failed to allocate default platform app filename: {}", .{err});
+    const app_path = std.fs.path.join(allocator, &.{ env.dirs.work_dir, app_filename }) catch |err|
+        return customInfraFailure(allocator, timer, "failed to allocate default platform app path: {}", .{err});
+    const output_path = std.fs.path.join(allocator, &.{ env.dirs.work_dir, "default_platform_build" }) catch |err|
+        return customInfraFailure(allocator, timer, "failed to allocate default platform output path: {}", .{err});
+    const target_arg = std.fmt.allocPrint(allocator, "--target={s}", .{target.cliName()}) catch |err|
+        return customInfraFailure(allocator, timer, "failed to allocate target arg: {}", .{err});
+    const out_arg = outputArg(allocator, output_path) catch |err|
+        return customInfraFailure(allocator, timer, "failed to allocate output arg: {}", .{err});
+
+    std.Io.Dir.cwd().writeFile(io, .{ .sub_path = app_path, .data = default_platform_echo_app }) catch |err|
+        return customInfraFailure(allocator, timer, "failed to write default platform app: {}", .{err});
+
+    if (runRocAndCheck(io, allocator, env, timer, timeout_ms, .{
+        .args = &.{ "build", "--opt=speed", "--no-cache", target_arg, out_arg },
+        .roc_file = app_path,
+        .contains = &.{.{ .stream = .stdout, .text = "Built " }},
+    })) |failure| return failure;
+
+    if (target == .wasm32) {
+        var file = std.Io.Dir.cwd().openFile(io, output_path, .{ .mode = .read_only }) catch |err|
+            return customInfraFailure(allocator, timer, "failed to open built wasm archive: {}", .{err});
+        defer file.close(io);
+
+        var magic: [8]u8 = undefined;
+        const bytes_read = file.readPositionalAll(io, &magic, 0) catch |err|
+            return customInfraFailure(allocator, timer, "failed to read built wasm archive: {}", .{err});
+        if (bytes_read != magic.len or !std.mem.eql(u8, magic[0..], "!<arch>\n")) {
+            return customFailure(allocator, timer, "wasm32 default platform output was not an archive", .{});
+        }
+    }
+
+    if (target.canRunOnHost()) {
+        const executable_path = runnableOutputPath(io, allocator, output_path) catch |err|
+            return customInfraFailure(allocator, timer, "failed to find built executable: {}", .{err});
+
+        if (runRawAndCheck(io, allocator, env, timer, timeout_ms, &.{executable_path}, env.dirs.work_dir, .{
+            .args = &.{},
+            .stdout_exact = "Hello, World!\n",
+            .stderr_exact = "",
+        })) |failure| return failure;
+    }
+
+    return null;
+}
+
 fn customDefaultPlatformDebugBacktrace(
     io: std.Io,
     allocator: Allocator,

src/echo_platform/mod.zig

@@ -58,6 +58,8 @@ pub const build_c_platform_main_source =
     \\    hosted { "roc_default_echo_line": Echo.line! }
     \\    targets: {
     \\        inputs: "targets/",
+    \\        x64glibc: { inputs: [app] },
+    \\        arm64glibc: { inputs: [app] },
     \\        x64mac: { inputs: [app] },
     \\        arm64mac: { inputs: [app] },
     \\        x64win: { inputs: [app] },
@@ -76,6 +78,33 @@ pub const build_c_platform_main_source =
     \\
 ;
 
+/// Build-only default platform for hostless wasm output. Without a platform
+/// host object there is no process entrypoint or stdout, so wasm default apps
+/// compile to an archive that a host can link and satisfy.
+pub const build_wasm_archive_platform_main_source =
+    \\platform ""
+    \\    requires {} { main! : List(Str) => Try({}, [Exit(I8), ..]) }
+    \\    exposes [Echo]
+    \\    packages {}
+    \\    provides { "main": main_for_host! }
+    \\    hosted { "roc_default_echo_line": Echo.line! }
+    \\    targets: {
+    \\        inputs: "targets/",
+    \\        wasm32: { inputs: [app], output: Archive },
+    \\    }
+    \\
+    \\import Echo
+    \\
+    \\main_for_host! : {} => I32
+    \\main_for_host! = |_args|
+    \\    match main!([]) {
+    \\        Ok({}) => 0
+    \\        Err(Exit(code)) => I8.to_i32(code)
+    \\        Err(_) => 1
+    \\    }
+    \\
+;
+
 /// Echo platform environment, passed as RocOps.env.
 /// On WASM the std_io field is unused (undefined); on native it holds the
 /// std.Io obtained from the process init or the global single-threaded I/O.