deps(tinycc): enable bun:ffi on Windows ARM64

scripts/build/config.ts

@@ -863,10 +863,9 @@
   // failure is loud ("cannot find -l:libatomic.a") and the fix is obvious.
   const staticLibatomic = partial.staticLibatomic ?? true;
 
-  // TinyCC: off on Windows ARM64 (not supported), Android (no upstream
-  // bionic support; FFI cc() falls back to dlopen-only), and FreeBSD
-  // (oven-sh/tinycc has no FreeBSD target).
-  const tinycc = partial.tinycc ?? !((windows && arm64) || abi === "android" || freebsd);
+  // TinyCC: off on Android (no upstream bionic support; FFI cc() falls back
+  // to dlopen-only) and FreeBSD (oven-sh/tinycc has no FreeBSD target).
+  const tinycc = partial.tinycc ?? !(abi === "android" || freebsd);
 
   const valgrind = partial.valgrind ?? false;
   const fuzzilli = partial.fuzzilli ?? false;

scripts/build/deps/tinycc.ts

@@ -2,8 +2,6 @@
  * TinyCC — small embeddable C compiler. Powers bun:ffi's JIT-compile path,
  * where user-provided C gets compiled and linked at runtime.
  *
- * Disabled on windows-arm64 (tinycc doesn't have an arm64-coff backend).
- *
  * Built via DirectBuild — no cmake sub-process. The old overlay
  * CMakeLists.txt had two recurring ASAN workarounds for the c2str host
  * tool (Linux ASLR/shadow-map, macOS 26.4 dyld deadlock); DirectBuild's
@@ -12,14 +10,12 @@
 
 import type { Dependency, DirectBuild } from "../source.ts";
 
-const TINYCC_COMMIT = "12882eee073cfe5c7621bcfadf679e1372d4537b";
+const TINYCC_COMMIT = "c49c2204b07c526c9ad935fabfcaf3802cae1346";
 
 export const tinycc: Dependency = {
   name: "tinycc",
   versionMacro: "TINYCC",
 
-  // The cfg.tinycc flag already encodes the windows-arm64 exclusion
-  // (see config.ts: `tinycc ?? !(windows && arm64)`).
   enabled: cfg => cfg.tinycc,
 
   source: () => ({

scripts/build/source.ts

@@ -446,7 +446,7 @@ export interface Dependency {
 
   /**
    * Whether this dep participates in the build at all. Defaults to always-on.
-   * E.g. libuv is windows-only, tinycc is disabled on windows-arm64.
+   * E.g. libuv is windows-only.
    */
   enabled?: (cfg: Config) => boolean;
 

test/js/bun/ffi/cc.test.ts

@@ -1,16 +1,13 @@
 import { cc, CString, JSCallback, ptr, type FFIFunction, type Library } from "bun:ffi";
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
 import { promises as fs } from "fs";
-import { bunEnv, bunExe, isArm64, isASAN, isWindows, normalizeBunSnapshot, tempDir, tempDirWithFiles } from "harness";
+import { bunEnv, bunExe, isASAN, isWindows, normalizeBunSnapshot, tempDir, tempDirWithFiles } from "harness";
 import path from "path";
 
-// TinyCC (and all of bun:ffi) is disabled on Windows ARM64
-const isFFIUnavailable = isWindows && isArm64;
-
 // TODO: we need to install build-essential and Apple SDK in CI.
 // It can't find includes. It can on machines with that enabled.
 // TinyCC's setjmp/longjmp error handling conflicts with ASan.
-it.todoIf(isWindows || isASAN || isFFIUnavailable)("can run a .c file", () => {
+it.todoIf(isWindows || isASAN)("can run a .c file", () => {
   const result = Bun.spawnSync({
     cmd: [bunExe(), path.join(__dirname, "cc-fixture.js")],
     cwd: __dirname,
@@ -23,7 +20,7 @@ it.todoIf(isWindows || isASAN || isFFIUnavailable)("can run a .c file", () => {
 
 // TinyCC's setjmp/longjmp error handling conflicts with ASan.
 // TinyCC is disabled on Windows ARM64.
-describe.skipIf(isASAN || isFFIUnavailable)("given an add(a, b) function", () => {
+describe.skipIf(isASAN)("given an add(a, b) function", () => {
   const source = /* c */ `
       int add(int a, int b) {
         return a + b;
@@ -391,7 +388,7 @@ describe.skipIf(isWindows || isASAN)("threadsafe JSCallback invoked from a forei
 // Pins GC liveness: compiled trampolines survive the library wrapper being
 // collected, and a JSCallback's closure stays alive until close().
 // TinyCC's setjmp/longjmp error handling conflicts with ASan.
-describe.skipIf(isASAN || isFFIUnavailable)("GC liveness of compiled symbols and callbacks", () => {
+describe.skipIf(isASAN)("GC liveness of compiled symbols and callbacks", () => {
   it("keeps symbol functions and callback closures alive across forced GC", async () => {
     using dir = tempDir("bun-ffi-cc-gc-liveness", {
       "lib.c": /* c */ `
@@ -457,7 +454,7 @@ describe.skipIf(isASAN || isFFIUnavailable)("GC liveness of compiled symbols and
   });
 });
 
-describe.skipIf(isFFIUnavailable)("double <-> JSValue conversions", () => {
+describe("double <-> JSValue conversions", () => {
   // JSC NaN-boxes doubles, so a NaN whose payload collides with the tag space
   // ("impure NaN", see JSC's PureNaN.h) must never be encoded as-is: it would
   // decode as a native-chosen JSValue (true, undefined, an Int32, or a cell

test/js/bun/ffi/ffi-error-messages.test.ts

@@ -1,11 +1,8 @@
 import { dlopen, linkSymbols } from "bun:ffi";
 import { describe, expect, test } from "bun:test";
-import { isArm64, isMusl, isWindows } from "harness";
+import { isMusl } from "harness";
 
-// TinyCC (and all of bun:ffi) is disabled on Windows ARM64
-const isFFIUnavailable = isWindows && isArm64;
-
-describe.skipIf(isFFIUnavailable)("FFI error messages", () => {
+describe("FFI error messages", () => {
   test("dlopen shows library name when library cannot be opened", () => {
     // Try to open a non-existent library
     try {

test/js/bun/ffi/ffi-viewSource-non-object.test.ts

@@ -1,9 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { isArm64, isWindows } from "harness";
 
-const isFFIUnavailable = isWindows && isArm64;
-
-describe.skipIf(isFFIUnavailable)("FFI viewSource", () => {
+describe("FFI viewSource", () => {
   test("rejects non-object symbol descriptor values", () => {
     // These should throw a TypeError because each symbol descriptor
     // must be an object like { args: [...], returns: "void" }.

test/js/node/fs/fs-writeSync-stdio-windows.test.ts

@@ -8,14 +8,11 @@
 // Now `fromJS`/`fromJSValidated` return `.fromUV(0|1|2)` directly, and
 // `FD.uv()` checks the cached stdio handles before `GetStdHandle`.
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isArm64, isWindows, tempDir } from "harness";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
 import { join } from "node:path";
 
 describe.concurrent.skipIf(!isWindows)("fs.writeSync on Windows stdio/handles", () => {
-  // bun:ffi (TinyCC) is unavailable on Windows arm64, so this repro can only
-  // run on x64. The second test below covers the plain openSync→writeSync path
-  // on all Windows arches.
-  test.skipIf(isArm64)("fs.writeSync(1, ...) does not panic after SetStdHandle swaps stdout", async () => {
+  test("fs.writeSync(1, ...) does not panic after SetStdHandle swaps stdout", async () => {
     const fixture = `
       const fs = require("node:fs");
       const { dlopen } = require("bun:ffi");

test/napi/napi-value-ffi.test.ts

@@ -1,14 +1,13 @@
 import { spawnSync } from "bun";
 import { cc, dlopen } from "bun:ffi";
 import { beforeAll, describe, expect, it } from "bun:test";
-import { bunEnv, bunExe, canBuildNodeAddons, isArm64, isASAN, isWindows } from "harness";
+import { bunEnv, bunExe, canBuildNodeAddons, isASAN, isWindows } from "harness";
 import { join } from "path";
 
 import source from "./napi-app/ffi_addon_1.c" with { type: "file" };
 
-// TinyCC (and all of bun:ffi) is disabled on Windows ARM64; the napi-app
-// fixture needs a toolchain that can compile the reported Node headers.
-const isFFIUnavailable = (isWindows && isArm64) || !canBuildNodeAddons();
+// The napi-app fixture needs a toolchain that can compile the Node headers.
+const isFFIUnavailable = !canBuildNodeAddons();
 
 const symbols = {
   set_instance_data: {