build from scratch

Author: jhheider

projects/llvm.org/mingw-w64/package.yml

@@ -1,160 +1,95 @@
-# llvm-mingw: LLVM-based mingw-w64 cross-compiler toolchain.
+# llvm.org/mingw-w64 — from-source LLVM mingw-w64 cross-compiler toolchain.
 #
-# **Composition recipe** — wraps pantry's `llvm.org` (clang + lld
-# + LLVM tools) with `mingw-w64.org` (Windows runtime: headers + CRT
-# + winpthreads) to produce a self-contained from-source Windows
-# cross-compiler.
+# Builds the COMPLETE llvm-mingw toolchain from source via upstream
+# mstorsjo/llvm-mingw's own build orchestration (`build-all.sh`):
+#   - clang + lld + the LLVM binutils-equivalents
+#   - the mingw-w64 runtime (headers + CRT + winpthreads)
+#   - the LLVM runtimes for the Windows targets: compiler-rt builtins,
+#     libunwind, libc++abi, libc++
+#   - the per-target driver wrappers (install-wrappers.sh)
+# No vendored binaries — everything is compiled here.
 #
-# Build is trivial — just generates per-target driver scripts that
-# shim clang with `--target=<target>` + `--sysroot=<mingw-w64.org>`.
-# All real compilation work happens upstream in the two component
-# recipes.
+# Why inline (clang and all) rather than composing pantry's llvm.org: the
+# Windows-target runtimes must match the exact clang that builds them, and
+# pkgx dependency constraints can't "drift" to track that. Building the whole
+# toolchain from one source tree makes it internally consistent by
+# construction, and versioning to mstorsjo's releases (which pin the matching
+# llvm-project) means there's no LLVM-version dance to get wrong.
 #
-# Previously this recipe vendored upstream mstorsjo/llvm-mingw's
-# prebuilt tarballs. pkgx pantry policy is from-source over
-# vendored — so we now compose pantry's own builds. See
-# pkgxdev/pantry#13047 (mingw-w64.org runtime) for the runtime side.
+# Compiled on the builder at pkgx's glibc floor, so the host-side driver
+# binaries run on old hosts with NO bklibcvenv seal. (Replaces the previous
+# approach of vendoring mstorsjo's prebuilt tarball; pantry policy is
+# from-source over vendored.)
+#
+# NOTE: this is a full LLVM build — long, by design. "Build time isn't the
+# end of the world to get it right."
 
 distributable:
-  url: https://github.com/mstorsjo/llvm-mingw/archive/refs/tags/{{ version.raw }}.tar.gz
+  url: https://github.com/mstorsjo/llvm-mingw/archive/refs/tags/{{version.tag}}.tar.gz
   strip-components: 1
 
 versions:
   github: mstorsjo/llvm-mingw
 
-platforms:
-  - linux/x86-64
-  - linux/aarch64
-  - darwin/x86-64
-  - darwin/aarch64
-
+# Runtime libs the host-side clang/lld link. Built at the 2.28 floor, so these
+# pkgx-built deps (all <= 2.28) satisfy it — pkgx supplies them via its runtime
+# env, no seal needed. linux-only (darwin links libSystem/libc++ from the OS).
 dependencies:
-  llvm.org: '*'         # clang + clang++ + lld-link + LLVM tools
-  mingw-w64.org: '*'    # Windows runtime (headers + CRT + winpthreads)
+  linux:
+    gnu.org/gcc/libstdcxx: ^14 # libstdc++.so.6 + libgcc_s.so.1
+    zlib.net: "*"
+    facebook.com/zstd: "*"
 
 build:
   dependencies:
-    gnu.org/coreutils: '*'   # install(1), basename(1)
-  script:
-    # Generate per-target driver wrappers. Each <target>-<tool>
-    # script is a thin shim around pantry's llvm.org tools,
-    # configured for the Windows target via `--target=` and pointed
-    # at mingw-w64.org's install for headers + libs.
-    - run: |
-        set -e
-        mkdir -p "{{prefix}}/bin"
-        MINGW="{{deps.mingw-w64.org.prefix}}"
-        LLVM="{{deps.llvm.org.prefix}}"
-
-        for T in x86_64-w64-mingw32 aarch64-w64-mingw32; do
-          echo "── generating driver wrappers for $T ──"
-
-          # Compiler drivers. clang/clang++/cpp are clang frontends;
-          # gcc/g++ are aliases that autotools / Makefiles often
-          # hardcode.
-          for ENTRY in "clang:clang" "clang++:clang++" "cpp:clang" \
-                       "gcc:clang" "g++:clang++"; do
-            DRIVER="${ENTRY%:*}"
-            REAL="${ENTRY#*:}"
-            cat > "{{prefix}}/bin/$T-$DRIVER" <<EOF
-#!/bin/sh
-exec "$LLVM/bin/$REAL" --target=$T --sysroot="$MINGW/$T" -fuse-ld=lld "\$@"
-EOF
-            chmod 755 "{{prefix}}/bin/$T-$DRIVER"
-          done
-
-          # Binutils-equivalent tools — LLVM ships replacements.
-          # Per-target aliases for autotools / Makefile compat.
-          for ENTRY in "ar:llvm-ar" "ranlib:llvm-ranlib" "strip:llvm-strip" \
-                       "nm:llvm-nm" "objdump:llvm-objdump" "objcopy:llvm-objcopy" \
-                       "windres:llvm-windres" "dlltool:llvm-dlltool" \
-                       "ld:lld-link"; do
-            DRIVER="${ENTRY%:*}"
-            REAL="${ENTRY#*:}"
-            cat > "{{prefix}}/bin/$T-$DRIVER" <<EOF
-#!/bin/sh
-exec "$LLVM/bin/$REAL" "\$@"
-EOF
-            chmod 755 "{{prefix}}/bin/$T-$DRIVER"
-          done
-        done
-
-        # Top-level convenience symlinks for format-specific LLVM tools.
-        # Build systems sometimes invoke these without a target prefix.
-        for TOOL in lld-link llvm-rc llvm-cvtres llvm-windres llvm-dlltool; do
-          if [ -e "$LLVM/bin/$TOOL" ]; then
-            ln -sf "$LLVM/bin/$TOOL" "{{prefix}}/bin/$TOOL"
-          fi
-        done
+    cmake.org: "*"
+    ninja-build.org: "*"
+    git-scm.org: "*" # build-llvm.sh / build-mingw-w64.sh clone the sources
+    python.org: "~3.11" # LLVM's build tooling
+    zlib.net: "*"
+    facebook.com/zstd: "*"
+    # no compiler dep declared on purpose: brewkit's default toolchain is
+    # llvm, so the host bootstrap compiler is clang (cc/c++ shims → clang).
+  env:
+    # llvm-mingw builds per-target; we ship the x86_64 + aarch64 Windows
+    # cross-compilers (the two brewkit CI cares about).
+    TOOLCHAIN_ARCHS:
+      - x86_64
+      - aarch64
+  # mstorsjo's orchestrator builds clang/lld, native compiler-rt, installs
+  # the driver wrappers, builds the mingw-w64 runtime, then the Windows-target
+  # compiler-rt + libunwind/libc++. Trim lldb + clang-tools-extra to the
+  # cross-compiler essentials (still a full clang/lld build).
+  script: ./build-all.sh "{{prefix}}"
+    --disable-lldb
+    --disable-lldb-mi
+    --disable-clang-tools-extra
 
 test:
-  # Same end-to-end test as before: cross-compile hello.c for both
-  # target arches, verify PE/COFF magic, run x86_64 binary via wine.
   dependencies:
-    winehq.org: '*'
+    winehq.org: "*"
   env:
     WINEDEBUG: -all
     WINEDLLOVERRIDES: "mscoree=;mshtml="
     WINEPREFIX: $PWD/.wine
-    CLANG_X86_64: "{{prefix}}/bin/x86_64-w64-mingw32-clang"
-    CLANG_AARCH64: "{{prefix}}/bin/aarch64-w64-mingw32-clang"
   script:
-    # Diagnostics: confirm wrappers were generated + are executable.
-    - |
-      echo "── wrapper diagnostics ──"
-      ls -la "$CLANG_X86_64"  2>&1 || echo "(missing)"
-      ls -la "$CLANG_AARCH64" 2>&1 || echo "(missing)"
-      echo "── wrapper content ──"
-      cat "$CLANG_X86_64"
-
-    # Cross-compile hello.c for both target arches.
+    - x86_64-w64-mingw32-clang --version
     - run: cp $FIXTURE hello.c
       fixture: |
         #include <stdio.h>
-        int main(void) {
-          printf("Hello from native Windows cross-compile.\n");
-          return 0;
-        }
-    - $CLANG_X86_64  -o hello-x86_64.exe  hello.c
-    - $CLANG_AARCH64 -o hello-aarch64.exe hello.c
-
-    # PE/COFF magic-byte check.
-    - |
-      for f in hello-x86_64.exe hello-aarch64.exe; do
-        case "$(head -c 2 "$f")" in
-          MZ) echo "$f: PE/COFF DOS header OK" ;;
-          *)  echo "$f: NOT a PE binary"; exit 1 ;;
-        esac
-      done
-
-    # Runtime check via wine — soft-skip when wine isn't on PATH.
-    - |
-      if command -v wine64 >/dev/null 2>&1; then
-        WINE=wine64
-      elif command -v wine >/dev/null 2>&1; then
-        WINE=wine
-      else
-        echo "wine not available — compile + magic-check passed; skipping runtime test"
-        exit 0
-      fi
-
-    - echo "running hello-x86_64.exe under $($WINE --version)"
-    - out=$($WINE hello-x86_64.exe)
-    - 'echo "wine stdout: $out"'
-    - |
-      case "$out" in
-        "Hello from native Windows cross-compile.") echo "RUN PASS" ;;
-        *) echo "RUN FAIL: unexpected output"; exit 1 ;;
-      esac
+        int main(void) { printf("Hello from native Windows cross-compile.\n"); return 0; }
+    - x86_64-w64-mingw32-clang  -o hello-x86_64.exe  hello.c
+    - aarch64-w64-mingw32-clang -o hello-aarch64.exe hello.c
+    - test "$(head -c 2 hello-x86_64.exe)" = "MZ"
+    - test "$(head -c 2 hello-aarch64.exe)" = "MZ"
+    - if ! command -v wine64 >/dev/null 2>&1; then exit 0; fi
+    - test "$(wine64 hello-x86_64.exe | tr -d '\r')" = "Hello from native Windows cross-compile."
 
 provides:
-  # x86_64 cross drivers
   - bin/x86_64-w64-mingw32-clang
   - bin/x86_64-w64-mingw32-clang++
-  - bin/x86_64-w64-mingw32-cpp
   - bin/x86_64-w64-mingw32-gcc
   - bin/x86_64-w64-mingw32-g++
-  - bin/x86_64-w64-mingw32-ld
   - bin/x86_64-w64-mingw32-ar
   - bin/x86_64-w64-mingw32-ranlib
   - bin/x86_64-w64-mingw32-strip
@@ -163,13 +98,10 @@ provides:
   - bin/x86_64-w64-mingw32-objcopy
   - bin/x86_64-w64-mingw32-windres
   - bin/x86_64-w64-mingw32-dlltool
-  # aarch64 cross drivers (same set)
   - bin/aarch64-w64-mingw32-clang
   - bin/aarch64-w64-mingw32-clang++
-  - bin/aarch64-w64-mingw32-cpp
   - bin/aarch64-w64-mingw32-gcc
   - bin/aarch64-w64-mingw32-g++
-  - bin/aarch64-w64-mingw32-ld
   - bin/aarch64-w64-mingw32-ar
   - bin/aarch64-w64-mingw32-ranlib
   - bin/aarch64-w64-mingw32-strip
@@ -178,7 +110,9 @@ provides:
   - bin/aarch64-w64-mingw32-objcopy
   - bin/aarch64-w64-mingw32-windres
   - bin/aarch64-w64-mingw32-dlltool
-  # Top-level PE-aware tooling (symlinks to llvm.org's tools)
+  # don't want to grab these.
+  # - bin/clang
+  # - bin/clang++
   - bin/lld-link
   - bin/llvm-rc
   - bin/llvm-cvtres