Refuse to publish a host under a name it was not built for

VITASDK_HOST_NAME is what the artifacts are called; the toolchain triplet is
what they are. Nothing compared the two, so the build whose toolchain file
had gone missing named one host and produced another, and everything
downstream agreed with the name: the tarball, the package architecture, the
bootstrap, the provenance.

The check runs as soon as both are known, which costs seconds instead of the
18 minutes the bootstrap smoke test needed to reach the same conclusion by
running a binary. arm64 and aarch64 are one machine here: Apple writes the
first, config.sub the second, and both reach this line depending on who was
asked.

The name derivation moves to cmake/PublishedHostName.cmake so its test can
call it instead of keeping a second copy of the FreeBSD rule.

Author: frangarcj

CMakeLists.txt

@@ -113,6 +113,7 @@ endif()
 
 include(Utils)
 include(GetTriplet)
+include(PublishedHostName)
 include(ExternalProject)
 
 set(vitasdk_base_c_flags "${CMAKE_C_FLAGS}")
@@ -135,14 +136,12 @@ get_host_triplet(host_native)
 get_build_triplet(build_native)
 
 # What this host is called where it is published -- in artifact names, in the
-# package architecture, in the vdpm bundle it embeds. It is the toolchain
-# triplet on every host but FreeBSD, whose cross compiler carries a release
-# number (x86_64-unknown-freebsd14-gcc) that its published name does not.
-string(REGEX REPLACE "^(.*-unknown-freebsd)[0-9]+$" "\\1"
-    host_published_default "${host_native}")
+# package architecture, in the vdpm bundle it embeds.
+vitasdk_published_host_name("${host_native}" host_published_default)
 set(VITASDK_HOST_NAME "${host_published_default}" CACHE STRING
     "Name this host publishes under, if not its toolchain triplet")
 set(host_published "${VITASDK_HOST_NAME}")
+vitasdk_check_published_host_name("${host_published}" "${host_native}")
 
 message(STATUS "Host:   ${host_native}")
 message(STATUS "Build:  ${build_native}")

cmake/PublishedHostName.cmake

@@ -0,0 +1,40 @@
+#
+# Copyright(c) 2016 codestation
+# Distributed under the MIT License (http://opensource.org/licenses/MIT)
+#
+
+# A host is called two things: the triplet its cross compiler answers to, and
+# the name it publishes under. Keeping them apart is what lets a host be
+# published under a name it was not built for, which is silent -- the
+# artifacts are well formed, they just belong to another machine.
+
+include_guard(GLOBAL)
+
+# The name a host triplet publishes under. The same everywhere except
+# FreeBSD, whose cross compiler carries a release number (x86_64-unknown-
+# freebsd14-gcc) that its published name does not.
+function(vitasdk_published_host_name triplet out_name)
+    string(REGEX REPLACE "^(.*-unknown-freebsd)[0-9]+$" "\\1" name "${triplet}")
+    set(${out_name} "${name}" PARENT_SCOPE)
+endfunction()
+
+# arm64 and aarch64 name one machine: Apple writes the first, config.sub the
+# second, and both reach here depending on who was asked.
+function(vitasdk_canonical_host_name name out_name)
+    string(REGEX REPLACE "^arm64-" "aarch64-" canonical "${name}")
+    set(${out_name} "${canonical}" PARENT_SCOPE)
+endfunction()
+
+# Fail unless published is the name triplet is entitled to publish under.
+function(vitasdk_check_published_host_name published triplet)
+    vitasdk_published_host_name("${triplet}" expected)
+    vitasdk_canonical_host_name("${expected}" expected_canonical)
+    vitasdk_canonical_host_name("${published}" published_canonical)
+    if(published_canonical STREQUAL expected_canonical)
+        return()
+    endif()
+    message(FATAL_ERROR
+        "this build publishes as ${published} but its toolchain builds "
+        "${triplet}. Either it is missing the toolchain file that would make "
+        "it cross-compile, or VITASDK_HOST_NAME names the wrong host.")
+endfunction()

tests/cmake/published-host-name-check.cmake

@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.16)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../cmake/PublishedHostName.cmake")
+
+vitasdk_check_published_host_name("${PUBLISHED}" "${TRIPLET}")

tests/cmake/published-host-name.cmake

@@ -1,17 +1,9 @@
 cmake_minimum_required(VERSION 3.16)
 
-# A host is called two things: the triplet its cross compiler answers to, and
-# the name it publishes under. They are the same everywhere except FreeBSD,
-# whose compiler carries a release number its published name does not -- and
-# mixing them up published a bundle nobody could match to a host.
-
-function(published_name_of triplet out)
-    string(REGEX REPLACE "^(.*-unknown-freebsd)[0-9]+$" "\\1" name "${triplet}")
-    set(${out} "${name}" PARENT_SCOPE)
-endfunction()
+include("${CMAKE_CURRENT_LIST_DIR}/../../cmake/PublishedHostName.cmake")
 
 function(assert_published triplet expected)
-    published_name_of("${triplet}" actual)
+    vitasdk_published_host_name("${triplet}" actual)
     if(NOT "${actual}" STREQUAL "${expected}")
         message(FATAL_ERROR
             "${triplet} publishes as '${actual}', expected '${expected}'")
@@ -28,4 +20,39 @@ foreach(triplet x86_64-linux-gnu aarch64-linux-gnu x86_64-linux-musl
     assert_published("${triplet}" "${triplet}")
 endforeach()
 
+# The gate: a name may only be published by the toolchain that earns it.
+function(assert_gate published triplet expected_result)
+    execute_process(
+        COMMAND ${CMAKE_COMMAND}
+            -DPUBLISHED=${published} -DTRIPLET=${triplet}
+            -P "${CMAKE_CURRENT_LIST_DIR}/published-host-name-check.cmake"
+        RESULT_VARIABLE result
+        OUTPUT_QUIET
+        ERROR_VARIABLE error)
+    if(expected_result STREQUAL "accepts" AND NOT result EQUAL 0)
+        message(FATAL_ERROR "${triplet} must publish as ${published}: ${error}")
+    endif()
+    if(expected_result STREQUAL "rejects")
+        if(result EQUAL 0)
+            message(FATAL_ERROR "${triplet} must not publish as ${published}")
+        endif()
+        if(NOT error MATCHES "${published}" OR NOT error MATCHES "${triplet}")
+            message(FATAL_ERROR "the rejection must name both, got: ${error}")
+        endif()
+    endif()
+endfunction()
+
+assert_gate(x86_64-linux-gnu x86_64-linux-gnu accepts)
+assert_gate(x86_64-unknown-freebsd x86_64-unknown-freebsd14 accepts)
+# Apple's spelling of the machine config.sub calls aarch64.
+assert_gate(arm64-apple-darwin aarch64-apple-darwin accepts)
+assert_gate(aarch64-apple-darwin arm64-apple-darwin accepts)
+
+# What shipped an arm64 SDK under the Intel name: the cross host lost its
+# toolchain file, so the build named one host and produced another.
+assert_gate(x86_64-apple-darwin arm64-apple-darwin rejects)
+assert_gate(arm64-apple-darwin x86_64-apple-darwin rejects)
+assert_gate(x86_64-w64-mingw32 x86_64-linux-gnu rejects)
+assert_gate(aarch64-linux-gnu x86_64-linux-gnu rejects)
+
 message(STATUS "published host name checks passed")