buninu-linux 0.8.56 → 0.10.56

package/initramfs/usr/lib/bootstrap/12.build-gcc.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env bun
+import {
+  chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync,
+  readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync,
+} from "node:fs";
+import {
+  bootstrap, cli, sha256,
+} from "./lib/common.js";
+import {
+  buildRoot, command, configure,
+  makeIn, patch, deps, ready,
+  resultRoot, source, sourceRoot, stage, useLog,
+  toolchain, tools,
+} from "./lib/build.js";
+
+const gccCommit = "9d2b63d100ae7c99ee8b128fb41086fd85c8f57d";
+// GCC clears MAKEOVERRIDES. Preserve its normal explicit submake flags
+// and append our header-install selection to that forwarding list.
+const headerInstallFlags =
+  "FLAGS_TO_PASS=$(BASE_FLAGS_TO_PASS) $(EXTRA_HOST_FLAGS) " +
+  "INSTALL_HEADERS_DIR=install-include-dir";
+
+async function main(args) {
+  const { arch, triple } = stage(
+    12, "gcc", args
+  );
+  // GCC's ARM vendor 4.7 branch has
+  // both the ARM64 and x64 backends.
+  // Pin the full commit, not a branch.
+  const src = await source(
+    "gcc@4.7-9d2b63d",
+    "gcc-" + gccCommit
+  );
+  const build = buildRoot + "/gcc-4.7";
+  prepareGcc(src, arch);
+  // Install native assembler/linker
+  // before building target libgcc.
+  installBinutils();
+  await configure(src, build, [
+    "--build=" + triple,
+    "--host=" + triple,
+    "--target=" + triple,
+    "--prefix=" + resultRoot,
+    "--enable-languages=c",
+    "--disable-build-with-cxx",
+    "--disable-bootstrap",
+    "--disable-libquadmath",
+    "--disable-decimal-float",
+    "--disable-fixed-point",
+    "--disable-lto",
+    "--disable-libgomp",
+    "--disable-multilib",
+    "--disable-multiarch",
+    "--disable-libmudflap",
+    "--disable-libssp",
+    "--disable-libitm", "--disable-nls",
+    "--disable-werror",
+    "--with-gmp=" + deps,
+    "--with-mpfr=" + deps,
+    "--with-mpc=" + deps,
+    "--with-build-time-tools=" +
+      toolchain + "/bin",
+    "--with-as=" +
+      resultRoot + "/bin/as",
+    "--with-ld=" +
+      resultRoot + "/bin/ld",
+    "--with-native-system-header-dir=" +
+      "/usr/include",
+  ]);
+
+  // Explicit make assignments avoid
+  // cached missing-tool commands.
+  await makeIn(build, [
+    "M4=" + tools + "/m4",
+    "FLEX=" + tools + "/flex", "all",
+  ]);
+  // Install compiler, headers, CRT
+  // support and libgcc into result.
+  // Create include directories via
+  // Make; copy headers with JS below.
+  // No tar pipe or cp -p -r needed.
+  await makeIn(build, [
+    headerInstallFlags, "install-gcc",
+  ]);
+  await makeIn(build, [
+    "install-target-libgcc",
+  ]);
+  // libgcc installs unwind.h too.
+  // Copy headers last to remove links
+  // back into the source tree.
+  installCompilerHeaders(
+    src, build, triple
+  );
+  // Test with all intermediate trees
+  // hidden, then restore them.
+  await verifyGcc(arch, triple);
+  ready(
+    12, "GCC 4.7 C compiler + libgcc"
+  );
+  console.log(
+    "Compiler: " +
+    resultRoot + "/bin/gcc"
+  );
+  console.log(
+    "Stop: GCC 4.7 milestone reached."
+  );
+}
+
+function prepareGcc(src, arch) {
+  const header = "bootstrap-musl.h";
+  const text = `/* Local ordinary Linux-musl bootstrap target settings. */
+#undef GNU_USER_DYNAMIC_LINKER
+#define GNU_USER_DYNAMIC_LINKER "/lib/ld-musl-${arch}.so.1"
+#undef GNU_USER_DYNAMIC_LINKER64
+#define GNU_USER_DYNAMIC_LINKER64 "/lib/ld-musl-${arch}.so.1"
+#undef OPTION_GLIBC
+#define OPTION_GLIBC 0
+#undef TARGET_C99_FUNCTIONS
+#define TARGET_C99_FUNCTIONS 1
+#undef TARGET_HAS_SINCOS
+#define TARGET_HAS_SINCOS 1
+#undef INT_FAST16_TYPE
+#define INT_FAST16_TYPE "int"
+#undef INT_FAST32_TYPE
+#define INT_FAST32_TYPE "int"
+#undef UINT_FAST16_TYPE
+#define UINT_FAST16_TYPE "unsigned int"
+#undef UINT_FAST32_TYPE
+#define UINT_FAST32_TYPE "unsigned int"
+`;
+  writeFileSync(src + "/gcc/config/" + header, text);
+  const path = src + "/gcc/config.gcc";
+  const config = readFileSync(path, "utf8");
+  const marker = "# Buninu native musl bootstrap";
+  if (!config.includes(marker)) writeFileSync(path, config + `\n${marker}\ncase $target in\n  aarch64-*-linux-musl*|x86_64-*-linux-musl*) tm_file="$tm_file ${header}" ;;\nesac\n`);
+  patch(src + "/libiberty/regex.c", "# ifdef REGEX_MALLOC\n", "/* TinyCC: use the existing heap allocation path. */\n# if defined __TINYC__ && !defined REGEX_MALLOC\n#  define REGEX_MALLOC 1\n# endif\n# ifdef REGEX_MALLOC\n");
+  patch(src + "/libiberty/argv.c", '#include "libiberty.h"', '#include <stdlib.h>\n#include "libiberty.h"');
+}
+
+function verificationSource(arch) {
+  return  `#include <stdint.h>
+#include <stdio.h>
+#include <unwind.h>
+#ifdef __gnu_linux__
+#error musl must not claim glibc
+#endif
+#if !defined(__linux__) || !defined(${arch === "aarch64" ? "__aarch64__" : "__x86_64__"})
+#error unexpected target
+#endif
+typedef char fast16[__builtin_types_compatible_p(__INT_FAST16_TYPE__,int_fast16_t)?1:-1];
+typedef char fast32[__builtin_types_compatible_p(__UINT_FAST32_TYPE__,uint_fast32_t)?1:-1];
+static volatile unsigned __int128 large=((unsigned __int128)1<<100)+123,divisor=7;
+int main(void){unsigned __int128 a=large,b=divisor,q=a/b,r=a%b;
+if(q*b+r!=a||r>=b)return 1;
+puts("GCC 4.7 C and libgcc runtime verified");return 0;}
+`;
+}
+
+function installCompilerHeaders(src, build, triple) {
+  const version = readFileSync(src + "/gcc/BASE-VER", "utf8").trim();
+  if (!/^4\.7\.\d+$/.test(version)) throw new Error(`Unexpected GCC version: ${version}`);
+  const destination = `${resultRoot}/lib/gcc/${triple}/${version}`;
+  for (const name of ["include", "include-fixed"]) {
+    const source = `${build}/gcc/${name}`;
+    if (!statSync(source).isDirectory()) throw new Error(`Missing GCC headers: ${source}`);
+    const target = `${destination}/${name}`;
+    // Replace only the generated private header directory. Dereference
+    // unwind.h and other source/build links so result survives their removal.
+    rmSync(target, { recursive: true, force: true });
+    cpSync(source, target, { recursive: true, dereference: true, preserveTimestamps: true });
+  }
+}
+
+function installBinutils() {
+  mkdirSync(resultRoot + "/bin", { recursive: true });
+  rmSync(resultRoot + "/verified.json", { force: true });
+  for (const name of ["as", "ld", "ar", "ranlib", "nm", "objcopy", "objdump", "readelf", "strip", "size", "strings", "addr2line", "c++filt"]) {
+    // Copy bytes, not symlinks into the intermediate toolchain tree.
+    const target = resultRoot + "/bin/" + name;
+    copyFileSync(toolchain + "/bin/" + name, target);
+    chmodSync(target, 0o755);
+  }
+  const notices = resultRoot + "/share/licenses/bootstrap";
+  mkdirSync(notices, { recursive: true });
+  copyFileSync(bootstrap + "/NOTICE.md", notices + "/NOTICE.md");
+  copyFileSync(bootstrap + "/LICENSE", notices + "/LICENSE");
+  cpSync(bootstrap + "/LICENSES", notices + "/LICENSES", { recursive: true });
+  // Keep notices with the installed binaries, including static dependencies.
+  for (const directory of ["gcc-" + gccCommit, "binutils-2.39", "gmp-4.3.2", "mpfr-2.4.2", "mpc-0.8.1"]) {
+    const target = resultRoot + "/share/licenses/" + directory;
+    mkdirSync(target, { recursive: true });
+    for (const name of readdirSync(sourceRoot + "/" + directory)) {
+      if (/^(COPYING|COPYRIGHT|LICENSE)/.test(name) && statSync(sourceRoot + "/" + directory + "/" + name).isFile()) {
+        copyFileSync(sourceRoot + "/" + directory + "/" + name, target + "/" + name);
+      }
+    }
+  }
+}
+
+async function verifyGcc(arch, triple) {
+  const gcc = resultRoot + "/bin/gcc";
+  const work = mkdtempSync("/tmp/bootstrap-result-check-");
+  const hidden = [];
+  // No compiler search-path overrides: exercise the installed defaults.
+  const env = {
+    PATH: resultRoot + "/bin:/bin:/usr/bin",
+    SHELL: "/bin/sh", CONFIG_SHELL: "/bin/sh", CC: gcc,
+    LD_LIBRARY_PATH: resultRoot + "/lib:" + resultRoot + "/lib64",
+  };
+  useLog(resultRoot + "/verification.log");
+  try {
+    for (const path of [sourceRoot, deps, toolchain, buildRoot]) {
+      const backup = path + ".verification-hidden";
+      if (existsSync(backup)) throw new Error(`Restore interrupted verification directory first: ${backup} -> ${path}`);
+      renameSync(path, backup);
+      hidden.push([path, backup]);
+    }
+    const version = (await command([gcc, "-dumpversion"], work, env, true)).trim();
+    if (!/^4\.7\./.test(version)) throw new Error(`Unexpected GCC version: ${version}`);
+    for (const name of ["libgcc.a", "libgcc_s.so.1", "crtbegin.o", "crtend.o", "crtbeginS.o", "crtendS.o"]) {
+      const path = (await command([gcc, "-print-file-name=" + name], work, env, true)).trim();
+      if (!path.startsWith(resultRoot + "/") || !existsSync(path)) throw new Error(`Missing installed support file: ${name}: ${path}`);
+      if (name === "libgcc_s.so.1") env.LD_LIBRARY_PATH = path.slice(0, path.lastIndexOf("/")) + ":" + env.LD_LIBRARY_PATH;
+    }
+    writeFileSync(work + "/verify.c", verificationSource(arch));
+    for (const optimization of ["-O0", "-O2"]) {
+      await command([gcc, optimization, "verify.c", "-o", "verify-gcc"], work, env);
+      const headers = await command([resultRoot + "/bin/readelf", "-l", "verify-gcc"], work, env, true);
+      if (!headers.includes(`/lib/ld-musl-${arch}.so.1`)) throw new Error("Wrong musl interpreter");
+      await command([work + "/verify-gcc"], work, env);
+    }
+    // Exercise installed crtbeginS/crtendS and shared libgcc, too.
+    writeFileSync(work + "/shared.c", "__int128 divide(__int128 a,__int128 b){return a/b;}\n");
+    writeFileSync(work + "/shared-main.c", "extern __int128 divide(__int128,__int128);int main(void){return divide(((__int128)1<<100)+1,7)!=(((__int128)1<<100)+1)/7;}\n");
+    await command([gcc, "-shared", "-fPIC", "-shared-libgcc", "shared.c", "-o", "libverify.so"], work, env);
+    await command([gcc, "shared-main.c", "-L.", "-lverify", "-Wl,-rpath,$ORIGIN", "-o", "verify-shared"], work, env);
+    await command([work + "/verify-shared"], work, env);
+    const files = [];
+    function inventory(directory, prefix = "") {
+      for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = prefix + entry.name;
+        if (entry.isDirectory()) inventory(directory + "/" + entry.name, path + "/");
+        else if (statSync(directory + "/" + entry.name).isFile() && !["verified.json", "verification.log"].includes(path)) {
+          const bytes = readFileSync(directory + "/" + entry.name);
+          files.push({ path, bytes: bytes.length, sha256: sha256(bytes) });
+        }
+      }
+    }
+    inventory(resultRoot);
+    writeFileSync(resultRoot + "/verified.json", JSON.stringify({
+      version, arch, triple, compiler: gcc, independentOf: hidden.map(([path]) => path),
+      requires: ["/usr/include", "/usr/lib", "/lib"], files,
+    }, null, 2) + "\n");
+  } finally {
+    // Restore in reverse order even when a compiler check fails.
+    for (const [path, backup] of hidden.reverse()) renameSync(backup, path);
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/2.enter-rootfs.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+import {
+  cli, isBuninuLinux, options, quote,
+} from "./lib/common.js";
+
+const archAlias = /^(x|x64|x86_64|x86-64|a|arm64|aarch64)$/;
+
+export function printEntry(rootfs = "/path/to/your/rootfs") {
+  console.log("\nEnter the rootfs:");
+  console.log(isBuninuLinux()
+    ? `  chroot ${quote(rootfs)} /bin/sh`
+    : `  bun x bunproot -koe -r ${quote(rootfs)}`);
+  console.log("Then run inside it:");
+  console.log("  cd /bootstrap");
+  console.log("  bun 3.gen-musl-dev.js");
+  console.log("  bun 4.build-tcc.js");
+}
+
+async function main(args) {
+  // Print instructions only. No
+  // rootfs or marker file is read.
+  if (!args.length) {
+    printEntry();
+    return;
+  }
+  if (args.includes("--help") ||
+      args.includes("-h")) {
+    console.log(
+      "Usage: bun 2.enter-rootfs.js " +
+      "[ARCH] [ROOTFS]"
+    );
+    console.log(
+      "No ROOTFS: print commands " +
+      "using /path/to/your/rootfs."
+    );
+    return;
+  }
+  // Keep stage 1's argument aliases,
+  // but never infer roota or rootx.
+  const archOnly = args.length === 1
+    && archAlias.test(args[0]);
+  const selected = options(archOnly
+    ? [...args, "/path/to/your/rootfs"]
+    : args);
+  if (!selected) return;
+  printEntry(selected.rootfs);
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/3.gen-musl-dev.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env bun
+import { cc } from "bun:ffi";
+import {
+  mkdtempSync, readFileSync, renameSync,
+  rmSync, writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  assertAbsent, bootstrap, cli,
+  requireRootfs, validateElf,
+} from "./lib/common.js";
+import {
+  generateHeaders,
+} from "./lib/musl-headers.js";
+
+async function main(args) {
+  // Run inside the prepared rootfs.
+  // This generates public headers
+  // and ordinary dynamic-link CRT.
+  // It does not build libc or rcrt1.
+  if (args.length) throw new Error(
+    "Usage: bun 3.gen-musl-dev.js"
+  );
+  const { arch } = requireRootfs();
+  const names = [
+    "crt1.o", "crti.o", "crtn.o",
+  ];
+  assertAbsent("/usr/include");
+  for (const name of names) {
+    assertAbsent(`/usr/lib/${name}`);
+  }
+
+  // Follow musl's Makefile rules in
+  // JS: public headers, arch bits,
+  // alltypes.h and syscall.h.
+  console.log(
+    "① Generating musl headers"
+  );
+  generateHeaders(
+    arch,
+    "/bootstrap/src/musl",
+    "/usr/include"
+  );
+  // chroot mounts /tmp separately;
+  // stage objects on the same FS as
+  // /usr/lib for the final rename.
+  const work = mkdtempSync(
+    "/usr/lib/.musl-crt-"
+  );
+  let compiler;
+  try {
+    // ARM64 TCC does not handle adrp.
+    // Ordinary crt1's _start_c uses
+    // x0, not x1 (_DYNAMIC). Omit just
+    // that unused argument in a
+    // temporary header override.
+    // Keep musl sources untouched.
+    if (arch === "aarch64") {
+      prepareArm64Startup(work);
+    }
+
+    // Bun.cc builds libtcc.c in memory
+    // without standalone cc or CRT.
+    // TCC_OUTPUT_OBJ emits the three
+    // relocatable startup objects.
+    console.log(
+      "② Building CRT with Bun.cc"
+    );
+    compiler = cc({
+      source: join(
+        bootstrap,
+        "lib/compile-object.c"
+      ),
+      library: ["gcc_s"],
+      flags: ["-L/usr/lib", "-L/lib"],
+      include: [
+        "/bootstrap/src/tinycc",
+        "/bootstrap/src/tinycc/include",
+        "/usr/include",
+      ],
+      symbols: {
+        compile_object: {
+          args: [
+            "cstring", "cstring",
+            "cstring",
+          ],
+          returns: "int",
+        },
+      },
+    });
+    compileCrt(
+      compiler, arch, work, names
+    );
+    for (const name of names) {
+      renameSync(
+        join(work, name),
+        `/usr/lib/${name}`
+      );
+    }
+    console.log(
+      "Ready: musl headers and CRT."
+    );
+    console.log(
+      "Next: bun " +
+      "/bootstrap/" +
+      "4.build-tcc.js"
+    );
+  } finally {
+    compiler?.close();
+    rmSync(work, {
+      recursive: true, force: true,
+    });
+  }
+}
+
+function prepareArm64Startup(work) {
+  const original = readFileSync("/bootstrap/src/musl/arch/aarch64/crt_arch.h", "utf8");
+  const lines = original.split("\n");
+  const removed = lines.filter(line => line.includes("_DYNAMIC"));
+  if (removed.length !== 4 || !removed.some(line => line.includes("adrp x1"))) {
+    throw new Error("Unexpected musl ARM64 startup code; refusing compatibility edit");
+  }
+  writeFileSync(join(work, "crt_arch.h"), lines.filter(line => !line.includes("_DYNAMIC")).join("\n"));
+}
+
+function compileCrt(compiler, arch, work, names) {
+  const z = text => Buffer.from(text + "\0");
+  const flags = `-nostdinc -DCRT -D_XOPEN_SOURCE=700 -I${work} -I/bootstrap/src/musl/arch/${arch} -I/bootstrap/src/musl/arch/generic -I/bootstrap/src/musl/src/include -I/bootstrap/src/musl/src/internal -I/usr/include -I/bootstrap/src/tinycc/include`;
+  for (const name of names) {
+    const source = name === "crt1.o" ? "/bootstrap/src/musl/crt/crt1.c" : `/bootstrap/src/musl/crt/${arch}/${name.slice(0, -2)}.s`;
+    const output = join(work, name);
+    console.log(`${source} -> /usr/lib/${name}`);
+    const result = compiler.symbols.compile_object(z(source), z(output), z(flags));
+    if (result) throw new Error(`${name}: TinyCC returned ${result}`);
+    const bytes = readFileSync(output);
+    validateElf(name, bytes, arch);
+    if (bytes.readUInt16LE(16) !== 1) throw new Error(`${name} is not a relocatable ELF object`);
+  }
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/4.build-tcc.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  bootstrap, cli, requireRootfs, run,
+  validateElf,
+} from "./lib/common.js";
+import {
+  buildTcc,
+} from "./lib/tcc-build.js";
+
+async function main(args) {
+  // Stage 3 must have generated
+  // headers and the three CRT files.
+  if (args.length) throw new Error(
+    "Usage: bun 4.build-tcc.js"
+  );
+  const { arch } = requireRootfs();
+  for (const name of [
+    "crt1.o", "crti.o", "crtn.o",
+  ]) {
+    validateElf(
+      name,
+      readFileSync(`/usr/lib/${name}`),
+      arch
+    );
+  }
+
+  // Bun.cc -> standalone stage1 ->
+  // stage2, then compare bytes.
+  // Build x64 runtime helpers when
+  // needed and test /bin/cc.
+  await buildTcc();
+
+  // Exercise the generated CRT:
+  // argv, env, constructors,
+  // destructors and exit status.
+  await verifyStartup();
+  console.log(
+    "Ready: cc source.c -o program"
+  );
+  console.log(
+    "Next: bun /bootstrap/" +
+    "5.build-make.js"
+  );
+}
+
+async function verifyStartup() {
+  const output = "/bootstrap/build/tinycc/startup-check";
+  await run(["/bin/cc", join(bootstrap, "lib/startup-check.c"), "-o", output]);
+  const child = Bun.spawn([output, "hello", "two words"], {
+    env: { PATH: "/bin:/usr/bin", CRT_TEST: "seed-free" }, stdout: "pipe", stderr: "inherit",
+  });
+  const stdout = await new Response(child.stdout).text();
+  if (await child.exited !== 42 || stdout !== "argc/argv, environment, constructor OK\ndestructor OK\n") {
+    throw new Error(`CRT startup check failed: ${stdout}`);
+  }
+  console.log(stdout + "exit status 42: OK");
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/5.build-make.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+import {
+  chmodSync, copyFileSync,
+} from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, command, configure,
+  installAdapters, makeIn, patch,
+  ready, shell, source, stage, tools,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { triple } = stage(
+    5, "make", args
+  );
+  installAdapters();
+  const src = await source(
+    "make@4.4.1", "make-4.4.1"
+  );
+  const build = buildRoot + "/make";
+  prepareMake(src);
+  await configure(src, build, [
+    "--build=" + triple,
+    "--prefix=/bootstrap/toolchain",
+    "--disable-dependency-tracking",
+    "--without-guile", "--disable-nls",
+  ]);
+
+  // GNU Make provides its own
+  // no-make shell bootstrap builder.
+  await command(
+    [shell, src + "/build.sh"],
+    build
+  );
+  copyFileSync(
+    build + "/make", tools + "/make"
+  );
+  chmodSync(tools + "/make", 0o755);
+  await makeIn(build, ["clean"]);
+  await makeIn(build);
+  copyFileSync(
+    build + "/make", tools + "/make"
+  );
+  await command(
+    [tools + "/make", "--version"]
+  );
+  ready(5, "GNU Make self-rebuild");
+}
+
+function prepareMake(src) {
+  patch(src + "/build.sh", '  LIBOBJS="${LIBOBJS:+$LIBOBJS }lib/$lo"',
+    '  lo=${lo#\'${LIBOBJDIR}\'}\n  LIBOBJS="${LIBOBJS:+$LIBOBJS }lib/$lo"');
+  patch(src + "/src/mkcustom.h", "char *alloca ();", "void *alloca ();");
+  patch(src + "/lib/glob.c", "extern char *alloca ();", "extern void *alloca ();");
+  patch(src + "/lib/alloca.c", "memory_full ();", "abort ();");
+}
+
+if (import.meta.main) await cli(main);

package/initramfs/usr/lib/bootstrap/6.build-binutils.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+import {
+  existsSync, readdirSync,
+  readFileSync, statSync,
+  copyFileSync, writeFileSync,
+} from "node:fs";
+import { cli } from "./lib/common.js";
+import {
+  buildRoot, command, configure,
+  makeIn, ready, source, stage,
+  toolchain, tools,
+} from "./lib/build.js";
+
+async function main(args) {
+  const { arch, triple } = stage(
+    6, "binutils", args
+  );
+  const src = await source(
+    "binutils@2.39", "binutils-2.39"
+  );
+  const build = buildRoot + "/binutils";
+  const env = {
+    CFLAGS: "-O2 -D__LITTLE_ENDIAN__=1",
+  };
+  await configure(src, build, [
+    "--build=" + triple,
+    "--host=" + triple,
+    "--target=" + triple,
+    "--prefix=" + toolchain,
+    "--disable-nls", "--disable-werror",
+    "--disable-gprofng",
+    "--disable-gold", "--disable-gdb",
+    "--disable-sim", "--disable-libctf",
+    "--disable-shared",
+    "--disable-multilib",
+    "--disable-dependency-tracking",
+    "--without-debuginfod",
+    "--without-zstd",
+  ], env);
+  await makeIn(build, ["all"], env);
+  restoreManpages(src, build);
+  await makeIn(build, ["install"], env);
+  await runtime(arch);
+  await command([
+    toolchain + "/bin/as", "--version",
+  ]);
+  await command([
+    toolchain + "/bin/ld", "--version",
+  ]);
+  ready(6, "Binutils and TCC runtime");
+}
+
+function restoreManpages(src, build) {
+  for (const dir of ["gas/doc", "binutils/doc", "ld", "gprof"]) {
+    for (const name of readdirSync(src + "/" + dir).filter(n => n.endsWith(".1"))) {
+      const target = `${build}/${dir}/${name}`;
+      if (existsSync(target) && statSync(target).size === 0) copyFileSync(`${src}/${dir}/${name}`, target);
+    }
+  }
+}
+
+async function runtime(arch) {
+  const cwd = buildRoot + "/tcc-runtime";
+  if (arch === "aarch64") {
+    await command([tools + "/cc", "-c", "/bootstrap/src/tinycc/lib/lib-arm64.c", "-o", "lib-arm64.o"], cwd);
+    await command([toolchain + "/bin/ar", "rcs", toolchain + "/lib/tcc/libbootstrap-tcc-arm64.a", "lib-arm64.o"], cwd);
+  }
+  const code = `static volatile long double a=1.5L,b=2.0L;
+int main(void){long double x=a,y=b;return x*y!=3.0L||x/y!=0.75L||x+y!=3.5L||x-y!=-0.5L||!(x<y)||(double)(x*y)!=3.0;}`;
+  // command() creates the working directory before compilation.
+  await command([toolchain + "/bin/ar", "--version"], cwd);
+  writeFileSync(cwd + "/quad.c", code);
+  await command([tools + "/cc", "quad.c", "-o", "quad"], cwd);
+  await command([cwd + "/quad"], cwd);
+}
+
+if (import.meta.main) await cli(main);