Hand the contract a launcher it can execute

The Intel macOS host built its whole SDK, validated it, and then died
with

    no such file or directory

naming nothing. The Rosetta gate passes `arch -x86_64` as the launcher
that lets an arm64 machine run what it cross-built, and that arrives as
one string. Interpolated into a VERBATIM COMMAND, a string with a space
in it is one argv[0], so what was looked up on disk was a program called
"arch -x86_64":

    $ cmake -E env FOO=1 "arch -x86_64" cmake -E echo ran
    no such file or directory
    $ cmake -E env FOO=1 arch -x86_64 cmake -E echo ran
    ran

The Intel host is cross-built, so the contract is the only thing that
executes what it produced: without it the host publishes unverified,
which is the situation the gate was written to end.

Second defect of the same commit, and it was hidden behind the first --
the build never reached the contract while the smoke test was killing
the arm64 leg it cross-builds from. tests/cmake/host-runner-command.cmake
runs the shape the target uses, with a two-word launcher that exists
wherever the test runs; against a runner that is not split it fails
three ways, one of them by not running the command at all.

Author: frangarcj

cmake/HostRunner.cmake

@@ -0,0 +1,10 @@
+include_guard(GLOBAL)
+
+# A launcher prefix arrives as one string -- "arch -x86_64" -- and has to
+# reach COMMAND as separate arguments. Under VERBATIM a string with a space
+# in it is one argv[0], so the run dies with "no such file or directory"
+# naming nothing, after the whole SDK has been built.
+function(vitasdk_host_runner_command output runner)
+    separate_arguments(parts NATIVE_COMMAND "${runner}")
+    set(${output} ${parts} PARENT_SCOPE)
+endfunction()

cmake/recipes/FinalizeSdk.cmake

@@ -130,13 +130,16 @@ add_custom_target(finalize-sdk
 # this machine can still execute -- x86_64 macOS on arm64, through Rosetta --
 # sets it to the launcher that makes that true, so the contract runs against
 # the SDK that was actually built rather than being skipped.
+include(${CMAKE_CURRENT_LIST_DIR}/../HostRunner.cmake)
+
 set(VITASDK_HOST_RUNNER "" CACHE STRING
     "Launcher prefix for running this host's binaries, if one is needed")
+vitasdk_host_runner_command(vitasdk_host_runner_argv "${VITASDK_HOST_RUNNER}")
 
 add_custom_target(check-toolchain-contract
     COMMAND ${CMAKE_COMMAND} -E env
         VITASDK=${CMAKE_INSTALL_PREFIX}
-        ${VITASDK_HOST_RUNNER}
+        ${vitasdk_host_runner_argv}
         ${CMAKE_SOURCE_DIR}/tests/toolchain-contract/run.sh
     DEPENDS finalize-sdk
     VERBATIM

tests/cmake/host-runner-command.cmake

@@ -0,0 +1,50 @@
+# A launcher with arguments has to reach the command as arguments.
+#
+# The Rosetta gate runs the Intel macOS contract through `arch -x86_64`, and
+# that arrives from the shell as one string. Interpolated into a VERBATIM
+# COMMAND it became a single argv[0] with a space in it, so the run died with
+#
+#     no such file or directory
+#
+# naming nothing, after the whole SDK had been built and validated. The Intel
+# host is cross-built, so this is the only thing that executes what it made.
+
+cmake_minimum_required(VERSION 3.20)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../cmake/HostRunner.cmake)
+
+function(check_length description runner expected)
+    vitasdk_host_runner_command(parts "${runner}")
+    list(LENGTH parts length)
+    if(NOT length EQUAL expected)
+        message(SEND_ERROR "${description}: expected ${expected} argument(s), got ${length}: ${parts}")
+    endif()
+endfunction()
+
+check_length("a host that runs its own binaries needs no launcher" "" 0)
+check_length("a launcher with an argument stays two arguments" "arch -x86_64" 2)
+check_length("a launcher with several arguments keeps them all" "qemu-aarch64 -L /sysroot" 3)
+
+vitasdk_host_runner_command(runner_argv "arch -x86_64")
+list(GET runner_argv 0 first)
+if(NOT first STREQUAL "arch")
+    message(SEND_ERROR "the launcher itself is not the first argument: ${first}")
+endif()
+
+# The shape the target uses, run for real: a two-word launcher, an
+# environment, and a command behind it. cmake -E env is the launcher here
+# because it exists wherever this test runs.
+vitasdk_host_runner_command(launcher "${CMAKE_COMMAND} -E env")
+execute_process(
+    COMMAND ${CMAKE_COMMAND} -E env VITASDK=irrelevant
+        ${launcher}
+        ${CMAKE_COMMAND} -E echo the-contract-ran
+    OUTPUT_VARIABLE output
+    RESULT_VARIABLE status
+    ERROR_VARIABLE errors)
+string(STRIP "${output}" output)
+if(NOT status EQUAL 0 OR NOT output STREQUAL "the-contract-ran")
+    message(SEND_ERROR "a launcher with arguments did not reach the command: status ${status}, output '${output}', errors '${errors}'")
+endif()
+
+message(STATUS "host runner command: all checks passed")