fix(sdk): c64 linking true object

Author: kassane

build.zig

@@ -1198,12 +1198,17 @@ fn addC64Exe(
     });
     exe.bundle_compiler_rt = false;
     exe.lto = .full;
+    exe.forceUndefinedSymbol("__zig_call_main_section");
+    exe.forceUndefinedSymbol("main");
     // basic-header.S and unmap-basic.S replace INPUT(basic-header.o) / INPUT(unmap-basic.o).
     exe.root_module.addAssemblyFile(sdk_dep.path("mos-platform/c64/basic-header.S"));
     exe.root_module.addAssemblyFile(sdk_dep.path("mos-platform/c64/unmap-basic.S"));
+    if (libs.crt0_obj) |obj| exe.root_module.addObject(obj);
     exe.root_module.linkLibrary(libs.crt);
     exe.root_module.linkLibrary(libs.crt0);
     exe.root_module.linkLibrary(libs.c);
+    if (libs.printf) |libprintf| exe.root_module.linkLibrary(libprintf);
+    if (libs.mem) |mem_obj| exe.root_module.addObject(mem_obj);
     if (with_printf_flt) exe.root_module.linkSystemLibrary("printf_flt", .{ .use_pkg_config = .no });
     exe.setLibCFile(libc_txt);
     exe.root_module.link_libc = true;

c64/fibonacci/fibonacci.c

@@ -1,17 +1,28 @@
 // Copyright (c) 2024 Matheus C. França
 // SPDX-License-Identifier: Apache-2.0
-//! C64 Fibonacci — computes and prints fib(0..9) using comptime recursion.
+//! C64 Fibonacci — prints fib(0..9) from a ROM lookup table.
 pub const panic = @import("mos_panic");
 const std = @import("std");
 
-/// Recursive Fibonacci evaluated at comptime when called with a comptime argument.
-fn fibonacci(comptime T: type, n: T) T {
-    return if (n < 2) n else fibonacci(T, n - 1) + fibonacci(T, n - 2);
+fn fibonacci(comptime n: usize) c_int {
+    return if (n <= 1) @intCast(n) else fibonacci(n - 1) + fibonacci(n - 2);
 }
 
+const fib_table = blk: {
+    var table: [10]c_int = undefined;
+    for (0..10) |i| table[i] = fibonacci(i);
+    break :blk table;
+};
+
 export fn main() void {
-    comptime var i: u8 = 0;
-    inline while (i < 10) : (i += 1) {
-        _ = std.c.printf("fib(%d) = %d\n", @as(c_int, i), @as(c_int, fibonacci(u8, i)));
+    // Split into two single-vararg printf calls: LLVM-MOS misplaces the second
+    // c_int vararg (slot 4 instead of slot 2) when the loop is unrolled with
+    // two varargs, producing 0 for every fib value.
+    var i: c_int = 0;
+    const ip: *volatile c_int = &i;
+    while (ip.* < 10) : (ip.* += 1) {
+        const idx: usize = @intCast(ip.*);
+        _ = std.c.printf("fib(%d) = ", ip.*);
+        _ = std.c.printf("%d\n", fib_table[idx]);
     }
 }

c64/fibonacci/fibonacci.zig

@@ -4,12 +4,14 @@
 //! Uses the translated c64.h module for VIC struct type and color constants.
 pub const panic = @import("mos_panic");
 
+const std = @import("std");
 const c64 = @import("c64");
 
-const VIC: *volatile c64.struct___vic2 = @ptrFromInt(0xD000);
+const VIC: *volatile c64.__vic2 = @ptrFromInt(0xD000);
 
 export fn main() void {
     VIC.unnamed_2.unnamed_0.bgcolor0 = c64.COLOR_BLACK;
+    _ = std.c.printf("Hello Zig!\n");
     while (true) {
         VIC.bordercolor +%= 1;
     }

c64/hello/hello.zig

@@ -26,6 +26,13 @@ pub const Libs = struct {
     // Platforms that need a strong __memset (overrides the weak recursive stub):
     // built as a TRUE object so ld.lld sees the strong definition before the archive.
     mem: ?*std.Build.Step.Compile = null,
+    // C64/CBM: printf.cc + varint.cc compiled with lto=.none (C++ bitcode crashes LLVM LTO codegen for 6502).
+    printf: ?*std.Build.Step.Compile = null,
+    // C64/CBM: crt0.S must be a TRUE object (not an archive member).
+    // common-crt0-o in CMake = add_platform_object_file → always force-linked.
+    // Without this, .call_main (jsr main) is a section-only archive member with no
+    // exported symbol, so ld.lld never extracts it → main is never called.
+    crt0_obj: ?*std.Build.Step.Compile = null,
 };
 
 /// Build platform libraries for `pd` from the SDK source tree at `sdk_root`.
@@ -138,16 +145,28 @@ pub fn buildPlatform(b: *std.Build, sdk_root: []const u8, pd: Platform, opt: std
     libcrt0.root_module.addIncludePath(.{ .cwd_relative = com_inc });
     libcrt0.root_module.addCSourceFiles(.{
         .root = .{ .cwd_relative = crt0_dir },
-        .files = &.{ "crt0.S", "init-stack.S" },
+        // crt0.S is kept here for sim (sim uses Zig start.zig + forceUndefinedSymbol
+        // for startup, so the archive copy is harmless).  For CBM platforms, crt0.S
+        // is built as a TRUE object (crt0_obj) and added directly to each exe, because
+        // its .call_main section has no exported symbol → ld.lld would silently skip
+        // the archive member → main is never called.
+        .files = if (std.mem.eql(u8, pd.name, "sim")) &.{ "crt0.S", "init-stack.S" } else &.{"init-stack.S"},
     });
     libcrt0.root_module.addCSourceFiles(.{
         .root = .{ .cwd_relative = crt0_dir },
         .files = &.{"copy-zp-data.c"},
     });
-    const exit_file: []const u8 = if (std.mem.eql(u8, pd.name, "sim")) "exit-custom.S" else "exit-loop.c";
+    // CBM exit: exit-custom.S defines __after_main (jmp exit) so crt0.S's undefined
+    // __after_main reference pulls it from the archive.  exit.c provides exit() which
+    // calls _fini() + _Exit().  exit-loop.c provides _Exit() = infinite loop.
+    // sim only needs exit-custom.S (it defines __after_main for that platform too).
+    const exit_files: []const []const u8 = if (std.mem.eql(u8, pd.name, "sim"))
+        &.{"exit-custom.S"}
+    else
+        &.{ "exit-custom.S", "exit-loop.c", "exit.c" };
     libcrt0.root_module.addCSourceFiles(.{
         .root = .{ .cwd_relative = b.fmt("{s}/exit", .{crt0_dir}) },
-        .files = &.{exit_file},
+        .files = exit_files,
     });
 
     // libc — platform I/O and kernal wrappers.
@@ -160,12 +179,14 @@ pub fn buildPlatform(b: *std.Build, sdk_root: []const u8, pd: Platform, opt: std
             .files = &.{ "putchar.c", "stdlib.c", "sim-io.c" },
         });
     } else {
+        const com_c_dir = b.fmt("{s}/c", .{common});
         const asm_files: []const []const u8 = if (std.mem.eql(u8, pd.name, "mega65"))
             &.{ "filevars.s", "kernal.S" }
         else
             &.{ "basic-header.S", "kernal.S", "unmap-basic.S", "devnum.s" };
         libc.root_module.addIncludePath(.{ .cwd_relative = plat_dir });
         libc.root_module.addIncludePath(.{ .cwd_relative = comm_dir });
+        libc.root_module.addIncludePath(.{ .cwd_relative = com_c_dir });
         libc.root_module.addIncludePath(.{ .cwd_relative = com_asm });
         libc.root_module.addIncludePath(.{ .cwd_relative = com_inc });
         libc.root_module.addCSourceFiles(.{
@@ -174,8 +195,48 @@ pub fn buildPlatform(b: *std.Build, sdk_root: []const u8, pd: Platform, opt: std
         });
         libc.root_module.addCSourceFiles(.{
             .root = .{ .cwd_relative = comm_dir },
-            .files = &.{ "abort.c", "cbm_k_bsout.c", "cbm_k_chrout.c", "chrout.c", "char-conv.c" },
+            .files = &.{ "abort.c", "cbm_k_bsout.c", "cbm_k_chrout.c", "chrout.c", "char-conv.c", "putchar.c", "getchar.c" },
+        });
+        libc.root_module.addCSourceFiles(.{
+            .root = .{ .cwd_relative = com_c_dir },
+            .files = &.{ "stdio-minimal.c", "mem.c", "util.c", "string.c" },
+        });
+        // Build printf.cc + varint.cc with lto=.none: C++ bitcode crashes LLVM LTO
+        // codegen for the 6502 target. Pre-compiling to native code avoids the crash.
+        const libprintf = addLib(b, "printf", target, opt);
+        libprintf.lto = .none;
+        libprintf.root_module.addIncludePath(.{ .cwd_relative = plat_dir });
+        libprintf.root_module.addIncludePath(.{ .cwd_relative = comm_dir });
+        libprintf.root_module.addIncludePath(.{ .cwd_relative = com_c_dir });
+        libprintf.root_module.addIncludePath(.{ .cwd_relative = com_asm });
+        libprintf.root_module.addIncludePath(.{ .cwd_relative = com_inc });
+        libprintf.root_module.addCSourceFiles(.{
+            .root = .{ .cwd_relative = com_c_dir },
+            .files = &.{ "printf.cc", "varint.cc" },
+            .flags = &.{ "-fno-exceptions", "-fno-rtti" },
+        });
+        // sdk/mem.s — strong __memset + abort TRUE object (same pattern as NES/SNES).
+        const mem_obj = b.addObject(.{
+            .name = "mem",
+            .root_module = b.createModule(.{ .target = target, .optimize = opt }),
+        });
+        mem_obj.root_module.addCSourceFiles(.{ .root = b.path("sdk"), .files = &.{"mem.s"} });
+        mem_obj.lto = .none;
+        // crt0.S TRUE object — mirrors cmake add_platform_object_file(common-crt0-o).
+        // Must be linked directly (not via archive) so its .call_main / .fini_rts
+        // anonymous sections reach the linker.  lto=.none matches libcrt0 policy.
+        const crt0_obj = b.addObject(.{
+            .name = "crt0",
+            .root_module = b.createModule(.{ .target = target, .optimize = opt }),
+        });
+        crt0_obj.root_module.addIncludePath(.{ .cwd_relative = com_asm });
+        crt0_obj.root_module.addIncludePath(.{ .cwd_relative = com_inc });
+        crt0_obj.root_module.addCSourceFiles(.{
+            .root = .{ .cwd_relative = crt0_dir },
+            .files = &.{"crt0.S"},
         });
+        crt0_obj.lto = .none;
+        return .{ .crt = libcrt, .crt0 = libcrt0, .c = libc, .printf = libprintf, .mem = mem_obj, .crt0_obj = crt0_obj };
     }
 
     return .{ .crt = libcrt, .crt0 = libcrt0, .c = libc };