From 5ab88018ae88fb7d4e0a334b64931dae9532b5af Mon Sep 17 00:00:00 2001 From: Eduardo Speroni Date: Wed, 18 Nov 2026 15:20:42 -0300 Subject: [PATCH] feat(macos): build arm64-macos and x64-macos V8 slices Adds two macOS variants to the Apple job. They are target_os="mac" with no target_environment, keep the full tier set like Catalyst, and share the rest of the Apple gn args (pointer compression and the cppgc cage off), since every Apple slice is compiled against the same include/ and embedder defines. chrome_pgo_phase=0 is required: is_official_build otherwise makes gn exec a Chromium-only PGO script. The deployment target, 13.3, follows the macOS runtime in NativeScript/runtimes. The slices ship as macos-. build-ios.sh --print-slice resolves the dist/ directory and asset stem, and the workflow reads it before the R2 lookup, so a cache hit and a fresh build use the same key. Existing ios- names and R2 keys are unchanged. The config job now chooses the Apple matrix, so a dispatch with platforms: macos builds only the two macOS slices; every other event builds all nine Apple variants. tests/apple-args.py covers the macOS arguments and every variant's slice name. Supersedes #12, without its Android pointer-compression change, the src-headers closure rewrite, or the manual release_tag input. Co-authored-by: Ammar Ahmed --- .github/workflows/build-matrix.yml | 42 +++++++++++++++------ README.md | 22 +++++++++-- config.env | 3 ++ scripts/matrix/build-ios.sh | 59 ++++++++++++++++++++++++++---- tests/apple-args.py | 32 ++++++++++++++++ 5 files changed, 135 insertions(+), 23 deletions(-) diff --git a/.github/workflows/build-matrix.yml b/.github/workflows/build-matrix.yml index 843f329..4704243 100644 --- a/.github/workflows/build-matrix.yml +++ b/.github/workflows/build-matrix.yml @@ -8,7 +8,7 @@ on: platforms: description: Which platforms to build type: choice - options: [all, android, ios] + options: [all, android, ios, macos] default: all push: branches: [main] @@ -40,9 +40,12 @@ jobs: v8_version: ${{ steps.cfg.outputs.v8_version }} ndk_release: ${{ steps.cfg.outputs.ndk_release }} inputs_hash: ${{ steps.cfg.outputs.inputs_hash }} + apple_variants: ${{ steps.cfg.outputs.apple_variants }} steps: - uses: actions/checkout@v7 - id: cfg + env: + PLATFORMS: ${{ github.event_name == 'workflow_dispatch' && inputs.platforms || 'all' }} run: | set -a; . ./config.env; set +a echo "v8_version=$V8_VERSION" >> "$GITHUB_OUTPUT" @@ -52,6 +55,17 @@ jobs: # finished build in R2 can be reused instead of repeated. echo "inputs_hash=$(git ls-files -s config.env patches scripts/matrix .github/workflows/build-matrix.yml \ | git hash-object --stdin)" >> "$GITHUB_OUTPUT" + # iOS and macOS variants run in the same job definition but are + # dispatched separately, so the matrix is chosen here. + ios='"arm64-device","arm64-simulator","x64-simulator","arm64-catalyst","x64-catalyst","arm64-tvdevice","arm64-tvsimulator"' + macos='"arm64-macos","x64-macos"' + case "$PLATFORMS" in + ios) variants="[$ios]" ;; + macos) variants="[$macos]" ;; + android) variants="[]" ;; + *) variants="[$ios,$macos]" ;; + esac + echo "apple_variants=$variants" >> "$GITHUB_OUTPUT" android: needs: config @@ -192,15 +206,15 @@ jobs: path: v8-*-src-headers.tar.gz retention-days: 7 - ios: + apple: needs: config - if: ${{ github.event_name != 'workflow_dispatch' || inputs.platforms == 'all' || inputs.platforms == 'ios' }} + if: ${{ needs.config.outputs.apple_variants != '[]' }} runs-on: macos-15 timeout-minutes: 300 strategy: fail-fast: false matrix: - variant: [arm64-device, arm64-simulator, x64-simulator, arm64-catalyst, x64-catalyst, arm64-tvdevice, arm64-tvsimulator] + variant: ${{ fromJSON(needs.config.outputs.apple_variants) }} # See the android job for the R2 bucket layout and the missing-secrets # fallback; this job mirrors it. env: @@ -221,11 +235,17 @@ jobs: - name: Check Apple build arguments run: python3 tests/apple-args.py + # The slice names dist/, the asset and the R2 key. It is resolved before + # the R2 check because a hit skips the build. + - name: Resolve the slice + id: slice + run: echo "slice=$(scripts/matrix/build-ios.sh --variant ${{ matrix.variant }} --print-slice)" >> "$GITHUB_OUTPUT" + - name: Check R2 for a prebuilt artifact id: cache if: env.AWS_ACCESS_KEY_ID != '' run: | - key="artifacts/${{ needs.config.outputs.inputs_hash }}/v8-${{ needs.config.outputs.v8_version }}-ios-${{ matrix.variant }}.tar.gz" + key="artifacts/${{ needs.config.outputs.inputs_hash }}/v8-${{ needs.config.outputs.v8_version }}-${{ steps.slice.outputs.slice }}.tar.gz" if aws s3api head-object --endpoint-url "$R2_ENDPOINT" \ --bucket "$R2_BUCKET" --key "$key" >/dev/null 2>&1; then aws s3 cp --endpoint-url "$R2_ENDPOINT" "s3://$R2_BUCKET/$key" . @@ -266,24 +286,24 @@ jobs: - name: Package if: steps.cache.outputs.hit != 'true' run: | - tar -czf "v8-${{ needs.config.outputs.v8_version }}-ios-${{ matrix.variant }}.tar.gz" \ - -C dist "ios-${{ matrix.variant }}" + tar -czf "v8-${{ needs.config.outputs.v8_version }}-${{ steps.slice.outputs.slice }}.tar.gz" \ + -C dist "${{ steps.slice.outputs.slice }}" - name: Upload the artifact to R2 if: env.AWS_ACCESS_KEY_ID != '' && steps.cache.outputs.hit != 'true' run: | - f="v8-${{ needs.config.outputs.v8_version }}-ios-${{ matrix.variant }}.tar.gz" + f="v8-${{ needs.config.outputs.v8_version }}-${{ steps.slice.outputs.slice }}.tar.gz" aws s3 cp --endpoint-url "$R2_ENDPOINT" "$f" \ "s3://$R2_BUCKET/artifacts/${{ needs.config.outputs.inputs_hash }}/$f" - uses: actions/upload-artifact@v7 with: - name: v8-ios-${{ matrix.variant }} - path: v8-*-ios-${{ matrix.variant }}.tar.gz + name: v8-${{ steps.slice.outputs.slice }} + path: v8-*-${{ steps.slice.outputs.slice }}.tar.gz retention-days: 7 release: - needs: [config, android, ios] + needs: [config, android, apple] if: startsWith(github.ref, 'refs/tags/v8-') runs-on: ubuntu-24.04 steps: diff --git a/README.md b/README.md index 069f076..9414a68 100644 --- a/README.md +++ b/README.md @@ -41,6 +41,7 @@ from a pinned revision, with the gn args under review, is the point of this repo |---|---|---| | Android | `arm64-v8a`, `x86_64`, `armeabi-v7a`, `x86` | `ubuntu-24.04` | | Apple | `arm64-device`, `arm64-simulator`, `x64-simulator`, `arm64-catalyst`, `x64-catalyst`, `arm64-tvdevice`, `arm64-tvsimulator` | `macos-15` | +| macOS | `arm64-macos`, `x64-macos` | `macos-15` | Each target is its own job with its own checkout. That costs one `gclient sync` per job, but the sync is about 6 minutes against 90–145 minutes of compile, so @@ -50,6 +51,17 @@ This replaces the previous arrangement of one branch per architecture. Nine branches meant nine places to apply a V8 bump or a patch, and cutting a release needs a single ref to tag. +### macOS + +The macOS variants are built by the Apple job from the same iOS checkout, but +they are `target_os="mac"` rather than an iOS `target_environment`, so they ship +as `macos-` (`v8--macos-arm64.tar.gz`) instead of +`ios-`. Like Catalyst they keep the full tier set, and they share the +rest of the Apple gn args, pointer compression and the cppgc cage off included: +every Apple slice is compiled against the same `include/` and embedder defines. +`MACOS_DEPLOYMENT_TARGET` follows the macOS runtime in +[NativeScript/runtimes](https://github.com/NativeScript/runtimes). + ### visionOS needs no build of its own V8's build system has no visionOS support — `target_platform` accepts only @@ -114,14 +126,16 @@ scripts/matrix/build-android.sh --abi arm64-v8a --ndk-root "$ANDROID_HOME/ndk/-/`. The two platforms +Sources land in `.v8/`, output in `dist//` (`build-ios.sh --variant +--print-slice` prints it). The two platforms need different DEPS, so use separate `--v8-dir` checkouts to keep both without re-syncing. -To iterate on one platform in CI without rebuilding the other (~2.5 hours per -platform), dispatch the workflow with `platforms: android` or `platforms: ios`. +To iterate on one platform in CI without rebuilding the others (~2.5 hours per +platform), dispatch the workflow with `platforms: android`, `ios` or `macos`. ## Patches @@ -197,4 +211,4 @@ disabled so that this does not enable an incomplete Wasm configuration. The existing iOS and Catalyst arguments are unchanged. Run `python3 tests/apple-args.py` on macOS to check the emitted GN arguments -for all seven Apple variants without compiling V8. +for all nine Apple variants without compiling V8. diff --git a/config.env b/config.env index 1c5a3ab..782ec76 100644 --- a/config.env +++ b/config.env @@ -12,3 +12,6 @@ ANDROID_NDK_RELEASE=r29 IOS_DEPLOYMENT_TARGET=13.0 # arm64 macabi does not exist below 14.0. CATALYST_DEPLOYMENT_TARGET=14.0 +# Keep in step with the macOS CMAKE_OSX_DEPLOYMENT_TARGET in NativeScript/runtimes +# (NativeScript/CMakeLists.txt). +MACOS_DEPLOYMENT_TARGET=13.3 diff --git a/scripts/matrix/build-ios.sh b/scripts/matrix/build-ios.sh index 174243b..b4ed12f 100755 --- a/scripts/matrix/build-ios.sh +++ b/scripts/matrix/build-ios.sh @@ -1,12 +1,15 @@ #!/bin/bash set -e # -# Builds the V8 static libraries for one Apple variant into dist/ios-/. +# Builds the V8 static libraries for one Apple variant into dist//, where +# the slice is ios-, or macos- for the macOS variants. The slice +# also names the release asset; --print-slice prints it without building. # # Usage: build-ios.sh --variant [--v8-dir ] [-- ] # # Variants: arm64-device, arm64-simulator, x64-simulator, -# arm64-catalyst, x64-catalyst +# arm64-catalyst, x64-catalyst, arm64-tvdevice, arm64-tvsimulator, +# arm64-macos, x64-macos # # Unlike Android, V8 has no monolith target here -- the iOS runtime links a set # of per-module archives, so each is rebuilt from its objects. ninja emits thin @@ -20,18 +23,22 @@ source "$ROOT_DIR/config.env" V8_DIR="$ROOT_DIR/.v8/v8" VARIANT="" CC_WRAPPER="" +PRINT_SLICE=false NINJA_ARGS=() usage() { cat < [--v8-dir ] - [--cc-wrapper ] [-- ] + [--cc-wrapper ] [--print-slice] [-- ] --variant arm64-device | arm64-simulator | x64-simulator | arm64-catalyst | x64-catalyst | arm64-tvdevice | arm64-tvsimulator + | arm64-macos | x64-macos --cc-wrapper Compiler launcher (e.g. sccache), passed to gn as cc_wrapper. Must be on PATH. + --print-slice Print the variant's dist/ directory and release asset + stem (e.g. ios-arm64-device, macos-arm64) and exit. EOF } @@ -43,12 +50,15 @@ while [ $# -gt 0 ]; do --v8-dir=*) V8_DIR="${1#*=}"; shift ;; --cc-wrapper) CC_WRAPPER="$2"; shift 2 ;; --cc-wrapper=*) CC_WRAPPER="${1#*=}"; shift ;; + --print-slice) PRINT_SLICE=true; shift ;; --) shift; NINJA_ARGS=("$@"); break ;; -h|--help) usage; exit 0 ;; *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;; esac done +# macOS is target_os="mac", which has no target_environment. +TARGET_OS=ios case "$VARIANT" in arm64-device) CPU=arm64; TARGET_ENV=device ;; arm64-simulator) CPU=arm64; TARGET_ENV=simulator ;; @@ -57,9 +67,22 @@ case "$VARIANT" in x64-catalyst) CPU=x64; TARGET_ENV=catalyst ;; arm64-tvdevice) CPU=arm64; TARGET_ENV=device ;; arm64-tvsimulator) CPU=arm64; TARGET_ENV=simulator ;; + arm64-macos) CPU=arm64; TARGET_ENV=""; TARGET_OS=mac ;; + x64-macos) CPU=x64; TARGET_ENV=""; TARGET_OS=mac ;; *) echo "Invalid --variant '$VARIANT'" >&2; usage >&2; exit 1 ;; esac +if [ "$TARGET_OS" = "mac" ]; then + SLICE="macos-$CPU" +else + SLICE="ios-$VARIANT" +fi + +if [ "$PRINT_SLICE" = true ]; then + echo "$SLICE" + exit 0 +fi + [ "$(uname)" = "Darwin" ] || { echo "Apple variants require a macOS host." >&2; exit 1; } MODULES=( @@ -103,14 +126,17 @@ MODULES=( # process by device RAM, so that reservation fails outright on smaller devices # -- four tries, then Oilpan's fatal OOM handler, before any JS runs. It crashed # on an iPad Air while an iPad Pro was fine. +# +# macOS takes the same shared set: every Apple slice is compiled against one +# include/ with one set of embedder defines (no V8_COMPRESS_POINTERS, no caged +# heap), so a slice that differs here is an ABI mismatch, not a tuning choice. GN_ARGS=" - target_os=\"ios\" + target_os=\"$TARGET_OS\" treat_warnings_as_errors=false icu_use_data_file=false use_custom_libcxx=false is_component_build=false is_debug=false - ios_enable_code_signing=false v8_control_flow_integrity=false v8_monolithic=false v8_static_library=true @@ -127,20 +153,37 @@ GN_ARGS=" symbol_level=0 " -if [ "$TARGET_ENV" = "catalyst" ]; then +if [ "$TARGET_OS" = "mac" ]; then + # Full tier set, as for Catalyst. On desktop targets is_official_build also + # defaults chrome_pgo_phase to 2, which makes gn exec + # //tools/update_pgo_profiles.py -- a Chromium script absent from a + # standalone V8 checkout, so gn gen fails without the override. + GN_ARGS="$GN_ARGS + is_official_build=true + use_thin_lto=false + chrome_pgo_phase=0 + v8_enable_lite_mode=false + mac_deployment_target=\"$MACOS_DEPLOYMENT_TARGET\"" +elif [ "$TARGET_ENV" = "catalyst" ]; then # is_official_build here implies ThinLTO, which emits bitcode rather than # object code and cannot be vendored, hence the explicit override. GN_ARGS="$GN_ARGS is_official_build=true use_thin_lto=false v8_enable_lite_mode=false + ios_enable_code_signing=false ios_deployment_target=\"$CATALYST_DEPLOYMENT_TARGET\"" else GN_ARGS="$GN_ARGS v8_enable_lite_mode=true + ios_enable_code_signing=false ios_deployment_target=\"$IOS_DEPLOYMENT_TARGET\"" fi +if [ -n "$TARGET_ENV" ]; then + GN_ARGS="$GN_ARGS target_environment=\"$TARGET_ENV\"" +fi + # Chromium requires Blink configuration for tvOS even for standalone V8. # Disable DrumBrake explicitly: tvOS otherwise enables it independently of # v8_enable_webassembly, producing references to omitted Wasm types. @@ -153,7 +196,7 @@ if [ -n "$CC_WRAPPER" ]; then fi OUTFOLDER="out.gn/$VARIANT-release" -DIST="$ROOT_DIR/dist/ios-$VARIANT" +DIST="$ROOT_DIR/dist/$SLICE" cd "$V8_DIR" @@ -181,7 +224,7 @@ archive_lib() { } rm -rf "$OUTFOLDER" -gn gen "$OUTFOLDER" --args="$GN_ARGS target_environment=\"$TARGET_ENV\" target_cpu=\"$CPU\" v8_target_cpu=\"$CPU\"" +gn gen "$OUTFOLDER" --args="$GN_ARGS target_cpu=\"$CPU\" v8_target_cpu=\"$CPU\"" echo "Building $VARIANT: $(date)" ninja "${NINJA_ARGS[@]}" -C "$OUTFOLDER" "${MODULES[@]}" inspector diff --git a/tests/apple-args.py b/tests/apple-args.py index ee43d58..cea04f2 100644 --- a/tests/apple-args.py +++ b/tests/apple-args.py @@ -39,5 +39,37 @@ def test_catalyst_is_built_with_the_jit(self): for variant in ['arm64-catalyst', 'x64-catalyst']: self.assertIn('v8_enable_lite_mode=false', self.args_for(variant)) + def test_ios_variants_target_ios_with_an_environment(self): + for variant in ['arm64-device', 'arm64-simulator', 'x64-simulator', 'arm64-catalyst', 'x64-catalyst', 'arm64-tvdevice', 'arm64-tvsimulator']: + args = self.args_for(variant) + for flag in ['target_os="ios"', 'target_environment=', 'ios_deployment_target=', 'ios_enable_code_signing=false']: + self.assertIn(flag, args) + self.assertNotIn('mac_deployment_target=', args) + + def test_macos_is_target_os_mac_with_the_jit(self): + for variant, cpu in [('arm64-macos', 'arm64'), ('x64-macos', 'x64')]: + args = self.args_for(variant) + for flag in ['target_os="mac"', f'target_cpu="{cpu}"', 'is_official_build=true', 'use_thin_lto=false', 'chrome_pgo_phase=0', 'v8_enable_lite_mode=false', 'mac_deployment_target=', 'v8_enable_pointer_compression=false', 'cppgc_enable_caged_heap=false']: + self.assertIn(flag, args) + for flag in ['target_environment=', 'target_platform=', 'ios_deployment_target=', 'ios_enable_code_signing=']: + self.assertNotIn(flag, args) + + def test_slice_names(self): + expected = { + 'arm64-device': 'ios-arm64-device', + 'arm64-simulator': 'ios-arm64-simulator', + 'x64-simulator': 'ios-x64-simulator', + 'arm64-catalyst': 'ios-arm64-catalyst', + 'x64-catalyst': 'ios-x64-catalyst', + 'arm64-tvdevice': 'ios-arm64-tvdevice', + 'arm64-tvsimulator': 'ios-arm64-tvsimulator', + 'arm64-macos': 'macos-arm64', + 'x64-macos': 'macos-x64', + } + for variant, slice_name in expected.items(): + result = subprocess.run([str(ROOT / 'scripts/matrix/build-ios.sh'), '--variant', variant, '--print-slice'], capture_output=True, text=True) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout.strip(), slice_name) + if __name__ == '__main__': unittest.main()