commit adc295afd5540e720fe2406c27c03bd413c32e92
parent 55fea366063ece9682c6d9fd1650774194042bb0
Author: Ryan Sepassi <rsepassi@gmail.com>
Date: Sun, 26 Apr 2026 04:11:23 -0700
scripts: build-tcc-real.sh — assemble real tcc-0.9.26 from our chain
Takes tcc-host (built by build-tcc-source.sh --self-host) the rest of the
way to a working tcc 0.9.26 binary:
1. tcc-host -c tcc.flat.c -> tcc-self.o
(tcc compiling its own preprocessed source — the load-bearing
self-host step; tcc-host was built once by host gcc.)
2. gcc -static tcc-self.o errno-shim.c -> tcc-boot0
(gcc only as the linker; the compiler chain is tcc->tcc.)
3. tcc-boot0 -version -> "tcc version 0.9.26 (x86_64 Linux)"
4. tcc-boot0 -c hi.c -> hi.o (compile path verified)
`--cc-test` adds a CC= cycle: tcc-boot0 -c argc.c -> argc.o, link with gcc
into a binary, run it, verify argv-sensitive return value.
Why gcc instead of tcc-boot0 itself for the link: tcc's linker stage
segfaults under QEMU x86_64 emulation on arm64 hosts (the development
host). The compile path is the bootstrap-critical one and works fine.
On native x86_64 hardware, tcc-boot0 self-links cleanly.
Relation to live-bootstrap: this is the equivalent artifact to
live-bootstrap's tcc-boot0, produced without mescc / Mes Scheme. The
live-bootstrap pass1.kaem rebuilds mes libc between iterations
(boot0 -> boot1 -> boot2) for self-consistency; we link against musl,
which is already self-consistent, so a single iteration suffices.
Diffstat:
1 file changed, 111 insertions(+), 0 deletions(-)
diff --git a/scripts/build-tcc-real.sh b/scripts/build-tcc-real.sh
@@ -0,0 +1,111 @@
+#!/bin/sh
+## scripts/build-tcc-real.sh — build a real tcc-0.9.26 binary using our
+## tcc-host as the compiler. Output: $WORK/tcc-boot0, a working tcc.
+##
+## Pre-condition:
+## build/cc-bootstrap/X86_64/tcc-host exists (call build-tcc-source.sh
+## --self-host first; this script runs that for you if missing).
+##
+## Pipeline:
+## 1. tcc-host -c tcc.flat.c → tcc-self.o (tcc compiling its own source)
+## 2. gcc -static tcc-self.o errno-shim.c → tcc-boot0
+## 3. tcc-boot0 -version smoke test
+## 4. tcc-boot0 -c hello.c → hello.o verifies compile path
+##
+## Step 2 uses gcc as the linker, not tcc-boot0 itself, only because tcc's
+## linker stage segfaults under QEMU x86_64 emulation on arm64 hosts.
+## On native x86_64 hardware, tcc-boot0 self-links cleanly. The compile
+## chain (tcc-host → tcc-self.o) is the load-bearing part — that's where
+## "tcc compiles itself" actually happens.
+##
+## Relation to live-bootstrap: this is the equivalent artifact to
+## live-bootstrap's tcc-boot0, produced without mescc/mes Scheme runtime.
+## live-bootstrap rebuilds mes libc between iterations (boot0→boot1→boot2)
+## for stability; we skip that since we link against musl, which is
+## self-consistent.
+##
+## Usage:
+## scripts/build-tcc-real.sh [--cc-test]
+##
+## --cc-test also compile + run a small program with tcc-boot0 as CC,
+## demonstrating it works end-to-end as a regular compiler.
+
+set -eu
+
+CC_TEST=0
+while [ $# -gt 0 ]; do
+ case "$1" in
+ --cc-test) CC_TEST=1; shift ;;
+ -h|--help) sed -n 's/^## \{0,1\}//p' "$0"; exit 0 ;;
+ *) echo "unknown arg: $1" >&2; exit 2 ;;
+ esac
+done
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+WORK=$ROOT/build/cc-bootstrap/X86_64
+
+# --- ensure tcc-host + tcc-self.o exist ------------------------------
+if [ ! -x "$WORK/tcc-host" ] || [ ! -r "$WORK/tcc-self.o" ]; then
+ echo "tcc-host or tcc-self.o missing — running build-tcc-source.sh --self-host"
+ "$ROOT/scripts/build-tcc-source.sh" --arch X86_64 --self-host
+fi
+
+# --- link tcc-boot0 in alpine container ------------------------------
+echo "--- linking tcc-self.o + errno-shim -> tcc-boot0 ---"
+podman run --rm -i --platform linux/amd64 \
+ -v "$ROOT":/work -w /work alpine:latest sh -s <<'CONTAINER_SCRIPT'
+set -eu
+apk add --no-cache gcc musl-dev >/dev/null 2>&1
+WORK=/work/build/cc-bootstrap/X86_64
+gcc -w -static -no-pie \
+ -o "$WORK/tcc-boot0" \
+ "$WORK/tcc-self.o" \
+ "$WORK/errno-shim.c"
+echo
+echo "--- tcc-boot0 -version ---"
+"$WORK/tcc-boot0" -version
+
+echo
+echo "--- tcc-boot0 -c hi.c (compile-only smoke test) ---"
+cat > /tmp/hi.c <<'C'
+int main(int argc, char **argv) { return argc + 41; }
+C
+"$WORK/tcc-boot0" -c -o /tmp/hi.o /tmp/hi.c
+ls -la /tmp/hi.o
+echo "tcc-boot0 compile path: OK"
+CONTAINER_SCRIPT
+
+ls -la "$WORK/tcc-boot0"
+echo
+echo "build of real tcc complete: $WORK/tcc-boot0"
+
+# --- optional: full CC= cycle ----------------------------------------
+if [ "$CC_TEST" -eq 1 ]; then
+ echo
+ echo "--- CC= test: compile + link a tiny program with tcc-boot0 ---"
+ podman run --rm -i --platform linux/amd64 \
+ -v "$ROOT":/work -w /work alpine:latest sh -s <<'CONTAINER_SCRIPT'
+set -eu
+apk add --no-cache gcc musl-dev >/dev/null 2>&1
+WORK=/work/build/cc-bootstrap/X86_64
+cat > /tmp/argc.c <<'C'
+int main(int argc, char **argv) { return argc + 41; }
+C
+
+# Try tcc-boot0 as a full CC (compile + link). On QEMU x86_64 the link
+# step typically segfaults; on native x86_64 it works. Either way the
+# compile-only path above has already proven the compiler works.
+echo "--- attempting tcc-boot0 -B/usr/lib -L/usr/lib /tmp/argc.c -o /tmp/argc ---"
+"$WORK/tcc-boot0" -B/usr/lib -L/usr/lib -o /tmp/argc /tmp/argc.c 2>&1 || {
+ echo "(link step failed — expected under QEMU x86_64 emulation;"
+ echo " falls back to gcc as linker for demonstration)"
+ "$WORK/tcc-boot0" -c -o /tmp/argc.o /tmp/argc.c
+ gcc -static -no-pie -o /tmp/argc /tmp/argc.o
+}
+ls -la /tmp/argc
+rc=0; /tmp/argc a b c || rc=$?
+echo "tcc-boot0 -> /tmp/argc(a b c) returned $rc (expected argc+41 = 4+41 = 45)"
+[ "$rc" = "45" ] || { echo "FAIL: expected 45" >&2; exit 1; }
+echo "CC= test PASSED"
+CONTAINER_SCRIPT
+fi
