CMake: Fix default architecture selection for macOS and iOS

Before this change, we created a CMake toolchain file for iOS and
macOS universal which propagated the initially configured
CMAKE_OSX_ARCHITECTURES values to user projects.

So if Qt was configured with 2 arches, configuring a CMake user
project using the generated toolchain file would also build the
user project targeting those 2 arches.

The reason for this that the same toolchain file is used for
configuring both Qt and users projects and we needed to ensure that
other Qt repos are built with the same set of arches. That
unfortunately led the multiple arches to carry over into user
projects.
This is different from qmake behavior which configured user projects
with 1 arch only.

Instead of the toolchain file explicitly setting
CMAKE_OSX_ARCHITECTURES for all projects, save the initial list of
arches into QT_OSX_ARCHITECTURES.
Then if the toolchain file detects that we're building a Qt repo (by
checking for the presence of QT_REPO_MODULE_VERSION) set
CMAKE_OSX_ARCHITECTURES to QT_OSX_ARCHITECTURES to propagate the
initial list of arches.

For user projects we want to have some sensible defaults.
For macOS projects, leave the decision of the architecture to build
to CMake.
For iOS Xcode projects, leave the decision to Xcode.
For iOS Ninja projects, set the architecture to the first value of the
architectures used when configuring Qt.

As a side note this fixes an issue in our CI where we configured macOS
Qt with 2 architectures and then tried to run CMake build tests for
both architectures on a machine that doesn't have the universal SDK.
This led to build failures.
Because the CMake build tests act as regular user projects, now they
are configured with a single architecture that is automtically
detected by CMake.

Pick-to: 6.1
Task-number: QTBUG-85447
Change-Id: Id1b7e78d7e67c1796efed10751416e5f857c16d2
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>

1 files changed, 41 insertions, 5 deletions

diff --git a/cmake/QtToolchainHelpers.cmake b/cmake/QtToolchainHelpers.cmake
index f2ef6147e1..f4ee35be31 100644
--- a/cmake/QtToolchainHelpers.cmake
+++ b/cmake/QtToolchainHelpers.cmake
@@ -112,12 +112,48 @@ function(qt_internal_create_toolchain_file)
                 "set(CMAKE_OSX_DEPLOYMENT_TARGET \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" CACHE STRING \"\")")
         endif()
 
-        if(UIKIT OR (MACOS AND QT_IS_MACOS_UNIVERSAL))
-            set(_qt_osx_architectures_escaped "${CMAKE_OSX_ARCHITECTURES}")
-            string(REPLACE ";" "LITERAL_SEMICOLON"
-                _qt_osx_architectures_escaped "${_qt_osx_architectures_escaped}")
+        # Save list of initial architectures Qt was configured with.
+        set(_qt_osx_architectures_escaped "${CMAKE_OSX_ARCHITECTURES}")
+        string(REPLACE ";" "LITERAL_SEMICOLON"
+            _qt_osx_architectures_escaped "${_qt_osx_architectures_escaped}")
+        set(docstring "List of architectures Qt was built with")
+        list(APPEND init_platform
+            "set(QT_OSX_ARCHITECTURES \"${_qt_osx_architectures_escaped}\" CACHE STRING \"${docstring}\")")
+        list(APPEND init_platform "")
+
+        # When building another qt repo, ensure the same list of architectures is used by default.
+        # Detection of a qt repo is done by checking for QT_REPO_MODULE_VERSION which is set in
+        # the repo's .cmake.conf file.
+        # Standalone tests will be not be built with multiple architectures to avoid issues in the
+        # CI when trying to run cmake build tests on VMs that do not have a universal macOS
+        # SDK.
+        list(APPEND init_platform "# Only build multiple architectures when building Qt itself")
+        list(APPEND init_platform "if((QT_REPO_MODULE_VERSION AND NOT QT_BUILD_STANDALONE_TESTS) OR QT_FORCE_QT_OSX_ARCHITECTURES)")
+        list(APPEND init_platform "    set(__qt_toolchain_building_qt_repo TRUE)")
+        list(APPEND init_platform "    set(CMAKE_OSX_ARCHITECTURES \"\${QT_OSX_ARCHITECTURES}\" CACHE STRING \"\")")
+        list(APPEND init_platform "endif()")
+        list(APPEND init_platform "")
+
+        # For macOS user projects, default to not specifying any architecture. This means CMake will
+        # not pass an -arch flag to the compiler and the compiler will choose the default
+        # architecture to build for.
+        # On Apple Silicon, CMake will introspect whether it's running under Rosetta and will
+        # pass the detected architecture (x86_64 under Rosetta or arm64 natively) to the compiler.
+        # This is line with default CMake behavior for user projects.
+        #
+        # For iOS, we provide a bit more convenience.
+        # When the user project is built using the Xcode generator, don't specify a default
+        # architecture and let Xcode and the developer handle it.
+        # When using the Ninja generator, specify the first architecture from QT_OSX_ARCHITECTURES
+        # (even with a simulator_and_device Qt build). This ensures that the default configuration
+        # at least tries to build something.
+        if(UIKIT)
+            qt_internal_get_first_osx_arch(osx_first_arch)
+            list(APPEND init_platform "if(NOT CMAKE_GENERATOR STREQUAL \"Xcode\" AND NOT __qt_toolchain_building_qt_repo)")
             list(APPEND init_platform
-                "set(CMAKE_OSX_ARCHITECTURES \"${_qt_osx_architectures_escaped}\" CACHE STRING \"\")")
+                "    set(CMAKE_OSX_ARCHITECTURES \"${osx_first_arch}\" CACHE STRING \"\")")
+            list(APPEND init_platform "endif()")
+            list(APPEND init_platform "")
         endif()
 
         if(UIKIT)