ci: Add arm64x build support and a Windows on Arm arm64x test job

A shippable Windows on Arm loader is an arm64x binary that fuses the arm64 and
arm64ec code, which takes two builds combined at link time (see
https://learn.microsoft.com/en-us/windows/arm/arm64x-build). Add a BUILD_AS_ARM64X
switch that drives the arm64 pass to emit a link repro and the arm64ec pass to
graft those inputs in with /machine:arm64x, plus a windows_arm64x CI job that
builds the fused binary and runs both the arm64ec and an x64 test suite against it.

The arm64x build support and CI job come from charles-lunarg's add_arm64x_ci_test
branch.

Author: BoiledElectricity

.github/workflows/build.yml

@@ -297,6 +297,49 @@ jobs:
             - run: cmake --install build --prefix build/install --config ${{matrix.config}}
             - run: ctest --parallel --output-on-failure -C ${{matrix.config}} --test-dir build/
 
+    windows_arm64x:
+        # Native Windows on Arm: build a real arm64x binary and check the x64 test suite passes against it.
+        # windows is 2x expensive to run on GitHub machines, so only run after the cheaper arm jobs pass.
+        needs: windows_arm
+        runs-on: windows-11-arm
+        timeout-minutes: 30
+        steps:
+            - uses: actions/checkout@v6
+            - uses: actions/setup-python@v5
+              with:
+                python-version: '3.x'
+            - run: python scripts/update_deps.py --arch arm64 --api vulkan --dir external --clean-build --clean-install
+            - run: |
+                cmake -S. -B build_arm64x `
+                -A arm64 `
+                -D BUILD_AS_ARM64X=ARM64 `
+                -D CMAKE_BUILD_TYPE=Release `
+                -D BUILD_WERROR=ON `
+                -C external/helper.cmake
+            - run: cmake --build build_arm64x/ --config Release
+            - run: |
+                cmake -S. -B build_arm64xec `
+                -A arm64ec `
+                -D BUILD_AS_ARM64X=ARM64EC `
+                -D BUILD_TESTS=ON `
+                -D CMAKE_BUILD_TYPE=Release `
+                -D BUILD_WERROR=ON `
+                -C external/helper.cmake
+            - run: cmake --build build_arm64xec/ --config Release
+            - run: cmake --install build_arm64xec --prefix build/install --config Release
+            - run: ctest --parallel --output-on-failure -C Release --test-dir build_arm64xec/
+            - run: |
+                cmake -S. -B build_x64 `
+                -A x64 `
+                -D BUILD_TESTS=ON `
+                -D CMAKE_BUILD_TYPE=Release `
+                -D BUILD_WERROR=ON `
+                -C external/helper.cmake
+            - run: cmake --build build_x64/ --config Release
+            - run: ctest --parallel --output-on-failure -C Release --test-dir build_x64/
+              env:
+                VK_LOADER_TEST_LOADER_PATH: ${{ github.workspace }}/build_arm64xec/loader/Release/vulkan-1.dll
+
     # Test both clang and clang-cl (Chromium project uses clang-cl)
     windows_clang:
       # windows is 2x expensive to run on GitHub machines, so only run if we know something else simple passed as well

CMakeLists.txt

@@ -324,3 +324,42 @@ if (BUILD_TESTS)
     enable_testing()
     add_subdirectory(tests)
 endif()
+
+# Building an arm64x binary takes two builds: one for the arm64 code and one for the arm64ec/x64 code,
+# combined at link time. See https://learn.microsoft.com/en-us/windows/arm/arm64x-build
+if(DEFINED BUILD_AS_ARM64X)
+    set(ARM64X_TARGETS vulkan)
+
+    # Where the arm64 build drops the link.rsp file the arm64ec build reads back.
+    set(arm64ReproDir "${CMAKE_CURRENT_SOURCE_DIR}/repros")
+
+    # Pull the arm64 objs, libs and def out of the rsp the arm64 build produced and feed them to the
+    # arm64ec link with /machine:arm64x so the two halves fuse into one arm64x binary.
+    function(set_arm64_dependencies n)
+        set(REPRO_FILE "${arm64ReproDir}/${n}.rsp")
+        file(STRINGS "${REPRO_FILE}" ARM64_OBJS REGEX obj\"$)
+        file(STRINGS "${REPRO_FILE}" ARM64_DEF REGEX def\"$)
+        file(STRINGS "${REPRO_FILE}" ARM64_LIBS REGEX lib\"$)
+        string(REPLACE "\"" ";" ARM64_OBJS "${ARM64_OBJS}")
+        string(REPLACE "\"" ";" ARM64_LIBS "${ARM64_LIBS}")
+        string(REPLACE "\"" ";" ARM64_DEF "${ARM64_DEF}")
+        string(REPLACE "/def:" "/defArm64Native:" ARM64_DEF "${ARM64_DEF}")
+
+        target_sources(${n} PRIVATE ${ARM64_OBJS})
+        target_link_options(${n} PRIVATE /machine:arm64x "${ARM64_DEF}" "${ARM64_LIBS}")
+    endfunction()
+
+    if("${BUILD_AS_ARM64X}" STREQUAL "ARM64")
+        # arm64 pass: emit an rsp with absolute paths to every linker input.
+        add_custom_target(mkdirs ALL COMMAND cmd /c (if not exist \"${arm64ReproDir}/\" mkdir \"${arm64ReproDir}\" ))
+        foreach (n ${ARM64X_TARGETS})
+            add_dependencies(${n} mkdirs)
+            target_link_options(${n} PRIVATE "/LINKREPROFULLPATHRSP:${arm64ReproDir}/${n}.rsp")
+        endforeach()
+    elseif("${BUILD_AS_ARM64X}" STREQUAL "ARM64EC")
+        # arm64ec pass: graft the arm64 inputs in to produce the arm64x binary.
+        foreach (n ${ARM64X_TARGETS})
+            set_arm64_dependencies(${n})
+        endforeach()
+    endif()
+endif()