Add initial support for cross-building to iOS

Tested locally with the following configurations:
- iOS device builds (arm64)
- iOS simulator builds (x86_64)
- iOS simulator_and_device builds (fat arm64 and x86_64 archives)

All iOS builds currently require a custom vcpkg fork which contains
fixes for building the required 3rd party libraries.

qtsvg, qtdeclarative, qtgraphicaleffects and qtquickcontrols2
have also been tested to build successfully.

simulator_and_device builds are also supported, but require an umerged
patch in upstream CMake as well as further patches to vcpkg.

Task-number: QTBUG-75576
Change-Id: Icd29913fbbd52a60e07ea5253fd9c7af7f8ce44c
Reviewed-by: Cristian Adam <cristian.adam@qt.io>
Reviewed-by: Qt CMake Build Bot
Reviewed-by: Leander Beernaert <leander.beernaert@qt.io>

11 files changed, 332 insertions, 29 deletions

diff --git a/cmake/FindGLESv2.cmake b/cmake/FindGLESv2.cmake
index 02df910285..49e757ef55 100644
--- a/cmake/FindGLESv2.cmake
+++ b/cmake/FindGLESv2.cmake
@@ -5,8 +5,8 @@ include(CheckCXXSourceCompiles)
 if(EMSCRIPTEN)
     set(HAVE_GLESv2 ON)
 else()
-    find_library(GLESv2_LIBRARY NAMES GLESv2)
-    find_path(GLESv2_INCLUDE_DIR NAMES "GLES2/gl2.h" DOC "The OpenGLES 2 include path")
+    find_library(GLESv2_LIBRARY NAMES GLESv2 OpenGLES)
+    find_path(GLESv2_INCLUDE_DIR NAMES "GLES2/gl2.h" "OpenGLES/ES2/gl.h" DOC "The OpenGLES 2 include path")
     set(_libraries "${CMAKE_REQUIRED_LIBRARIES}")
     list(APPEND CMAKE_REQUIRED_LIBRARIES "${GLESv2_LIBRARY}")
     set(_includes "${CMAKE_REQUIRED_INCLUDES}")
@@ -32,6 +32,20 @@ int main(int argc, char *argv[]) {
     set(package_args GLESv2_INCLUDE_DIR GLESv2_LIBRARY HAVE_GLESv2)
 endif()
 
+# Framework handling partially inspired by FindGLUT.cmake.
+if(GLESv2_LIBRARY MATCHES "/([^/]+)\\.framework$")
+    # TODO: Might need to handle non .tbd suffixes, but didn't find an
+    # example like that.
+    # TODO: Might need to handle INTERFACE_INCLUDE_DIRECTORIES differently.
+    set(_library_imported_location "${GLESv2_LIBRARY}/${CMAKE_MATCH_1}.tbd")
+    if(NOT EXISTS "${_library_imported_location}")
+        set(_library_imported_location "")
+    endif()
+else()
+    set(_library_imported_location "${GLESv2_LIBRARY}")
+endif()
+set(GLESv2_LIBRARY "${_library_imported_location}")
+
 list(APPEND package_args HAVE_GLESv2)
 
 include(FindPackageHandleStandardArgs)
@@ -40,8 +54,15 @@ find_package_handle_standard_args(GLESv2 DEFAULT_MSG ${package_args})
 mark_as_advanced(${package_args})
 
 if(GLESv2_FOUND AND NOT TARGET GLESv2::GLESv2)
-    if(EMSCRIPTEN)
+    if(EMSCRIPTEN OR APPLE_UIKIT)
         add_library(GLESv2::GLESv2 INTERFACE IMPORTED)
+        if(APPLE_UIKIT)
+            # For simulator_and_device builds we can't specify the full library path, because
+            # it's specific to either the device or the simulator. Resort to passing a link
+            # flag instead.
+            set_target_properties(GLESv2::GLESv2 PROPERTIES
+                INTERFACE_LINK_LIBRARIES "-framework OpenGLES")
+        endif()
     else()
         add_library(GLESv2::GLESv2 UNKNOWN IMPORTED)
         set_target_properties(GLESv2::GLESv2 PROPERTIES
diff --git a/cmake/QtAutoDetect.cmake b/cmake/QtAutoDetect.cmake
index 7864d40501..1823d1e572 100644
--- a/cmake/QtAutoDetect.cmake
+++ b/cmake/QtAutoDetect.cmake
@@ -59,6 +59,103 @@ function(qt_auto_detect_vpckg)
     endif()
 endfunction()
 
+function(qt_auto_detect_ios)
+    if(CMAKE_SYSTEM_NAME STREQUAL iOS
+            OR CMAKE_SYSTEM_NAME STREQUAL watchOS
+            OR CMAKE_SYSTEM_NAME STREQUAL tvOS)
+        message(STATUS "Using internal CMake ${CMAKE_SYSTEM_NAME} toolchain file.")
 
+        # The QT_UIKIT_SDK check simulates the input.sdk condition for simulator_and_device in
+        # configure.json.
+        # If the variable is explicitly provided, assume simulator_and_device to be off.
+        if(QT_UIKIT_SDK)
+            set(simulator_and_device OFF)
+        elseif(QT_FORCE_SIMULATOR_AND_DEVICE)
+            # TODO: Once we get simulator_and_device support in upstream CMake, only then allow
+            # usage of simulator_and_device without forcing.
+            set(simulator_and_device ON)
+        else()
+            # If QT_UIKIT_SDK is not provided, default to simulator.
+            set(simulator_and_device OFF)
+            set(QT_UIKIT_SDK "iphonesimulator" CACHE "STRING" "Chosen uikit SDK.")
+        endif()
+
+        message(STATUS "simulator_and_device set to: \"${simulator_and_device}\".")
+
+        # Choose relevant architectures.
+        # Using a non xcode generator requires explicit setting of the
+        # architectures, otherwise compilation fails with unknown defines.
+        if(CMAKE_SYSTEM_NAME STREQUAL iOS)
+            if(simulator_and_device)
+                set(osx_architectures "arm64;x86_64")
+            elseif(QT_UIKIT_SDK STREQUAL "iphoneos")
+                set(osx_architectures "arm64")
+            elseif(QT_UIKIT_SDK STREQUAL "iphonesimulator")
+                set(osx_architectures "x86_64")
+            else()
+                if(NOT DEFINED QT_UIKIT_SDK)
+                    message(FATAL_ERROR "Please proviude a value for -DQT_UIKIT_SDK."
+                        " Possible values: iphoneos, iphonesimulator.")
+                else()
+                    message(FATAL_ERROR
+                            "Unknown SDK argument given to QT_UIKIT_SDK: ${QT_UIKIT_SDK}.")
+                endif()
+            endif()
+        elseif(CMAKE_SYSTEM_NAME STREQUAL tvOS)
+            if(simulator_and_device)
+                set(osx_architectures "arm64;x86_64")
+            elseif(QT_UIKIT_SDK STREQUAL "appletvos")
+                set(osx_architectures "arm64")
+            elseif(QT_UIKIT_SDK STREQUAL "appletvsimulator")
+                set(osx_architectures "x86_64")
+            else()
+                if(NOT DEFINED QT_UIKIT_SDK)
+                    message(FATAL_ERROR "Please proviude a value for -DQT_UIKIT_SDK."
+                        " Possible values: appletvos, appletvsimulator.")
+                else()
+                    message(FATAL_ERROR
+                            "Unknown SDK argument given to QT_UIKIT_SDK: ${QT_UIKIT_SDK}.")
+                endif()
+            endif()
+        elseif(CMAKE_SYSTEM_NAME STREQUAL watchOS)
+            if(simulator_and_device)
+                set(osx_architectures "armv7k;i386")
+            elseif(QT_UIKIT_SDK STREQUAL "watchos")
+                set(osx_architectures "armv7k")
+            elseif(QT_UIKIT_SDK STREQUAL "watchsimulator")
+                set(osx_architectures "i386")
+            else()
+                if(NOT DEFINED QT_UIKIT_SDK)
+                    message(FATAL_ERROR "Please proviude a value for -DQT_UIKIT_SDK."
+                        " Possible values: watchos, watchsimulator.")
+                else()
+                    message(FATAL_ERROR
+                            "Unknown SDK argument given to QT_UIKIT_SDK: ${QT_UIKIT_SDK}.")
+                endif()
+            endif()
+        endif()
+
+        # For non simulator_and_device builds, we need to explicitly set the SYSROOT aka the sdk
+        # value.
+        if(QT_UIKIT_SDK)
+            set(CMAKE_OSX_SYSROOT "${QT_UIKIT_SDK}" CACHE STRING "")
+        endif()
+        message(STATUS "CMAKE_OSX_SYSROOT set to: \"${CMAKE_OSX_SYSROOT}\".")
+
+        message(STATUS "CMAKE_OSX_ARCHITECTURES set to: \"${osx_architectures}\".")
+        set(CMAKE_OSX_ARCHITECTURES "${osx_architectures}" CACHE STRING "")
+
+        if(NOT DEFINED BUILD_SHARED_LIBS)
+            set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build Qt statically or dynamically" FORCE)
+        endif()
+
+        if(BUILD_SHARED_LIBS)
+            message(FATAL_ERROR
+                "Building Qt for ${CMAKE_SYSTEM_NAME} as shared libraries is not supported.")
+        endif()
+    endif()
+endfunction()
+
+qt_auto_detect_ios()
 qt_auto_detect_android()
 qt_auto_detect_vpckg()
diff --git a/cmake/QtBaseConfigureTests.cmake b/cmake/QtBaseConfigureTests.cmake
index 6b46ed26b2..777adb7b5f 100644
--- a/cmake/QtBaseConfigureTests.cmake
+++ b/cmake/QtBaseConfigureTests.cmake
@@ -1,27 +1,41 @@
 include(CheckCXXSourceCompiles)
+
 function(qt_run_config_test_architecture)
     set(QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT
         "" CACHE INTERNAL "Test variables that should be exported" FORCE)
-    # Test architecture
-    set(_arch_file "${CMAKE_CURRENT_BINARY_DIR}/architecture_test")
-    set(saved_executable_suffix "${CMAKE_EXECUTABLE_SUFFIX}")
 
-    # With emscripten the application entry point is a .js file (to be run with node for example), but the
-    # real "data" is in the .wasm file, so that's where we need to look for the ABI, etc. information.
-    if (EMSCRIPTEN)
-        set(CMAKE_EXECUTABLE_SUFFIX ".wasm")
-    endif()
+    # Compile test to find the target architecture and sub-architectures.
+    set(flags "")
+    qt_get_platform_try_compile_vars(platform_try_compile_vars)
+    list(APPEND flags ${platform_try_compile_vars})
 
-    try_compile(_arch_result "${CMAKE_CURRENT_BINARY_DIR}"
-        "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/arch/arch.cpp"
-        COPY_FILE "${_arch_file}")
-
-    set(CMAKE_EXECUTABLE_SUFFIX "${saved_executable_suffix}")
+    try_compile(
+        _arch_result
+        "${CMAKE_CURRENT_BINARY_DIR}/config.tests/arch"
+        "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/arch"
+        arch
+        CMAKE_FLAGS ${flags}
+        )
 
     if (NOT _arch_result)
         message(FATAL_ERROR "Failed to compile architecture detection file.")
     endif()
 
+    set(_arch_file_suffix "${CMAKE_EXECUTABLE_SUFFIX}")
+    # With emscripten the application entry point is a .js file (to be run with node for example),
+    # but the real "data" is in the .wasm file, so that's where we need to look for the ABI, etc.
+    # information.
+    if (EMSCRIPTEN)
+        set(_arch_file_suffix ".wasm")
+    endif()
+    set(_arch_file
+        "${CMAKE_CURRENT_BINARY_DIR}/config.tests/arch/architecture_test${_arch_file_suffix}")
+    if (NOT EXISTS "${_arch_file}")
+        message(FATAL_ERROR
+                "Failed to find compiled architecture detection executable at ${_arch_file}.")
+    endif()
+    message(STATUS "Extracting architecture info from ${_arch_file}.")
+
     file(STRINGS "${_arch_file}" _arch_lines LENGTH_MINIMUM 16 LENGTH_MAXIMUM 1024 ENCODING UTF-8)
 
     foreach (_line ${_arch_lines})
@@ -60,6 +74,9 @@ function(qt_run_config_test_architecture)
     set(TEST_buildAbi "${_build_abi}" CACHE INTERNAL "Target machine buildAbi")
     list(APPEND QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT TEST_buildAbi)
     set(QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT ${QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT} CACHE INTERNAL "Test variables that should be exported")
+
+    list(JOIN _sub_architecture " " subarch_summary)
+    message(STATUS "Building for: ${QT_QMAKE_TARGET_MKSPEC} (${TEST_architecture_arch}, CPU features: ${subarch_summary})")
 endfunction()
 
 
diff --git a/cmake/QtBaseGlobalTargets.cmake b/cmake/QtBaseGlobalTargets.cmake
index 66ec2c73e4..ad15207005 100644
--- a/cmake/QtBaseGlobalTargets.cmake
+++ b/cmake/QtBaseGlobalTargets.cmake
@@ -91,11 +91,27 @@ list(APPEND init_platform "set(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\" CACH
 list(APPEND init_platform "set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\" CACHE STRING \"\")")
 
 if(APPLE)
-    if(CMAKE_OSX_SYSROOT)
+    # For simulator_and_device build, we should not explicitly set the sysroot.
+    list(LENGTH CMAKE_OSX_ARCHITECTURES _qt_osx_architectures_count)
+    if(CMAKE_OSX_SYSROOT AND NOT _qt_osx_architectures_count GREATER 1 AND APPLE_UIKIT)
         list(APPEND init_platform "set(CMAKE_OSX_SYSROOT \"${CMAKE_OSX_SYSROOT}\" CACHE PATH \"\")")
     endif()
+    unset(_qt_osx_architectures_count)
+
     if(CMAKE_OSX_DEPLOYMENT_TARGET)
-        list(APPEND init_platform "set(CMAKE_OSX_DEPLOYMENT_TARGET \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" CACHE STRING \"\")")
+        list(APPEND init_platform
+            "set(CMAKE_OSX_DEPLOYMENT_TARGET \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" CACHE STRING \"\")")
+    endif()
+
+    if(APPLE_UIKIT)
+        list(APPEND init_platform
+            "set(CMAKE_SYSTEM_NAME \"${CMAKE_SYSTEM_NAME}\" CACHE STRING \"\")")
+        set(_qt_osx_architectures_escaped "${CMAKE_OSX_ARCHITECTURES}")
+        string(REPLACE ";" "LITERAL_SEMICOLON"
+            _qt_osx_architectures_escaped "${_qt_osx_architectures_escaped}")
+        list(APPEND init_platform
+            "set(CMAKE_OSX_ARCHITECTURES \"${_qt_osx_architectures_escaped}\" CACHE STRING \"\")")
+        unset(_qt_osx_architectures_escaped)
     endif()
 elseif(ANDROID)
     list(APPEND init_platform "set(ANDROID_NATIVE_API_LEVEL \"${ANDROID_NATIVE_API_LEVEL}\" CACHE STRING \"\")")
@@ -108,6 +124,7 @@ endif()
 
 string(REPLACE ";" "\n" init_vcpkg "${init_vcpkg}")
 string(REPLACE ";" "\n" init_platform "${init_platform}")
+string(REPLACE "LITERAL_SEMICOLON" ";" init_platform "${init_platform}")
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/qt.toolchain.cmake.in" "${__GlobalConfig_build_dir}/qt.toolchain.cmake" @ONLY)
 qt_install(FILES "${__GlobalConfig_build_dir}/qt.toolchain.cmake" DESTINATION "${__GlobalConfig_install_dir}" COMPONENT Devel)
 
@@ -135,6 +152,16 @@ qt_feature_module_begin(NO_MODULE
     PRIVATE_FILE src/corelib/global/qconfig_p.h
 )
 include("${CMAKE_CURRENT_SOURCE_DIR}/configure.cmake")
+
+# Do what mkspecs/features/uikit/default_pre.prf does, aka enable sse2 for
+# simulator_and_device_builds.
+if(APPLE_UIKIT AND NOT QT_UIKIT_SDK)
+    set(__QtFeature_custom_enabled_cache_variables
+        TEST_subarch_sse2
+        FEATURE_sse2
+        QT_FEATURE_sse2)
+endif()
+
 qt_feature_module_end(GlobalConfig OUT_VAR_PREFIX "__GlobalConfig_")
 
 qt_generate_global_config_pri_file()
diff --git a/cmake/QtBuild.cmake b/cmake/QtBuild.cmake
index 13e954cd57..a1b044b97d 100644
--- a/cmake/QtBuild.cmake
+++ b/cmake/QtBuild.cmake
@@ -1895,6 +1895,8 @@ function(qt_add_plugin target)
         "${ARGN}"
     )
 
+    qt_get_sanitized_plugin_type("${arg_TYPE}" arg_TYPE)
+
     set(output_directory_default "${QT_BUILD_DIR}/${INSTALL_PLUGINSDIR}/${arg_TYPE}")
     set(install_directory_default "${INSTALL_PLUGINSDIR}/${arg_TYPE}")
     set(archive_install_directory_default "${INSTALL_LIBDIR}/${arg_TYPE}")
@@ -2760,7 +2762,7 @@ function(qt_add_cmake_library target)
     ### Define Targets:
     if(${arg_INTERFACE})
         add_library("${target}" INTERFACE)
-    elseif(${arg_STATIC})
+    elseif(${arg_STATIC} OR (${arg_MODULE} AND NOT BUILD_SHARED_LIBS))
         add_library("${target}" STATIC)
     elseif(${arg_SHARED})
         add_library("${target}" SHARED)
@@ -3376,10 +3378,14 @@ endfunction()
 macro(qt_find_apple_system_frameworks)
     if(APPLE)
         find_library(FWAppKit AppKit)
+        find_library(FWAssetsLibrary AssetsLibrary)
+        find_library(FWAudioToolbox AudioToolbox)
         find_library(FWApplicationServices ApplicationServices)
         find_library(FWCarbon Carbon)
         find_library(FWCoreFoundation CoreFoundation)
         find_library(FWCoreServices CoreServices)
+        find_library(FWCoreGraphics CoreGraphics)
+        find_library(FWCoreText CoreText)
         find_library(FWCoreVideo CoreVideo)
         find_library(FWcups cups)
         find_library(FWDiskArbitration DiskArbitration)
diff --git a/cmake/QtCompilerOptimization.cmake b/cmake/QtCompilerOptimization.cmake
index 5ca28c4de4..f1ebafc009 100644
--- a/cmake/QtCompilerOptimization.cmake
+++ b/cmake/QtCompilerOptimization.cmake
@@ -62,7 +62,9 @@ if(GCC OR CLANG)
     set(QT_CFLAGS_AVX512VBMI "-mavx512vbmi")
     set(QT_CFLAGS_AESNI      "-maes")
     set(QT_CFLAGS_SHANI      "-msha")
-    set(QT_CFLAGS_NEON       "-mfpu=neon")
+    if(NOT APPLE_UIKIT)
+        set(QT_CFLAGS_NEON   "-mfpu=neon")
+    endif()
     set(QT_CFLAGS_MIPS_DSP   "-mdsp")
     set(QT_CFLAGS_MIPS_DSPR2 "-mdspr2")
 endif()
diff --git a/cmake/QtFeature.cmake b/cmake/QtFeature.cmake
index 9849390922..b3e5eb9b8a 100644
--- a/cmake/QtFeature.cmake
+++ b/cmake/QtFeature.cmake
@@ -360,6 +360,14 @@ function(qt_feature_module_end)
         qt_evaluate_feature(${feature})
     endforeach()
 
+    # Evaluate custom cache assignments.
+    foreach(cache_var_name ${__QtFeature_custom_enabled_cache_variables})
+        set(${cache_var_name} ON CACHE BOOL "Force enabled by platform." FORCE)
+    endforeach()
+    foreach(cache_var_name ${__QtFeature_custom_disabled_cache_variables})
+        set(${cache_var_name} OFF CACHE BOOL "Force disabled by platform." FORCE)
+    endforeach()
+
     set(enabled_public_features "")
     set(disabled_public_features "")
     set(enabled_private_features "")
@@ -445,6 +453,8 @@ function(qt_feature_module_end)
     unset(__QtFeature_public_extra PARENT_SCOPE)
 
     unset(__QtFeature_define_definitions PARENT_SCOPE)
+    unset(__QtFeature_custom_enabled_features PARENT_SCOPE)
+    unset(__QtFeature_custom_disabled_features PARENT_SCOPE)
 endfunction()
 
 function(qt_feature_copy_global_config_features_to_core target)
@@ -527,18 +537,65 @@ function(qt_config_compile_test name)
     set(TEST_${name} "${HAVE_${name}}" CACHE INTERNAL "${arg_LABEL}")
 endfunction()
 
+# This function should be used for passing required try compile platform variables to the
+# project-based try_compile() call.
+# out_var will be a list of -Dfoo=bar strings, suitable to pass to CMAKE_FLAGS.
+function(qt_get_platform_try_compile_vars out_var)
+    # Use the regular variables that are used for source-based try_compile() calls.
+    set(flags "${CMAKE_TRY_COMPILE_PLATFORM_VARIABLES}")
+
+    # Pass toolchain files.
+    if(CMAKE_TOOLCHAIN_FILE)
+        list(APPEND flags "CMAKE_TOOLCHAIN_FILE")
+    endif()
+    if(VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+        list(APPEND flags "VCPKG_CHAINLOAD_TOOLCHAIN_FILE")
+    endif()
+
+    # Assemble the list with regular options.
+    set(flags_cmd_line "")
+    foreach(flag ${flags})
+        if(${flag})
+            list(APPEND flags_cmd_line "-D${flag}=${${flag}}")
+        endif()
+    endforeach()
+
+    # Pass darwin specific options.
+    if(APPLE_UIKIT)
+        if(CMAKE_OSX_ARCHITECTURES)
+            list(GET CMAKE_OSX_ARCHITECTURES 0 osx_first_arch)
+
+            # Do what qmake does, aka when doing a simulator_and_device build, build the
+            # target architecture test only with the first given architecture, which should be the
+            # device architecture, aka some variation of "arm" (armv7, arm64).
+            list(APPEND flags_cmd_line "-DCMAKE_OSX_ARCHITECTURES:STRING=${osx_first_arch}")
+        endif()
+        # Also specify the sysroot, but only if not doing a simulator_and_device build.
+        # So keep the sysroot empty for simulator_and_device builds.
+        if(QT_UIKIT_SDK)
+            list(APPEND flags_cmd_line "-DCMAKE_OSX_SYSROOT:STRING=${QT_UIKIT_SDK}")
+        endif()
+    endif()
+
+    set("${out_var}" "${flags_cmd_line}" PARENT_SCOPE)
+endfunction()
+
 function(qt_config_compile_test_x86simd extension label)
     if (DEFINED TEST_X86SIMD_${extension})
         return()
     endif()
 
+    set(flags "-DSIMD:string=${extension}")
+
+    qt_get_platform_try_compile_vars(platform_try_compile_vars)
+    list(APPEND flags ${platform_try_compile_vars})
+
     message(STATUS "Performing SIMD Test ${label}")
     try_compile("TEST_X86SIMD_${extension}"
         "${CMAKE_CURRENT_BINARY_DIR}/config.tests/x86_simd_${extension}"
         "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/x86_simd"
         x86_simd
-        CMAKE_FLAGS "-DSIMD:string=${extension}")
-
+        CMAKE_FLAGS ${flags})
     if(${TEST_X86SIMD_${extension}})
         set(status_label "Success")
     else()
diff --git a/cmake/QtInternalTargets.cmake b/cmake/QtInternalTargets.cmake
index 2db065fbf5..54e7f4f50e 100644
--- a/cmake/QtInternalTargets.cmake
+++ b/cmake/QtInternalTargets.cmake
@@ -100,3 +100,15 @@ endif()
 if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
     target_compile_definitions(PlatformCommonInternal INTERFACE QT_NO_DEBUG)
 endif()
+
+if(APPLE_UIKIT)
+    # Do what mkspecs/features/uikit/default_pre.prf does, aka enable sse2 for
+    # simulator_and_device_builds.
+    if(FEATURE_simulator_and_device)
+        # Setting the definition on PlatformCommonInternal behaves slightly differently from what
+        # is done in qmake land. This way the define is not propagated to tests, examples, or
+        # user projects built with qmake, but only modules, plugins and tools.
+        # TODO: Figure out if this ok or not (sounds ok to me).
+        target_compile_definitions(PlatformCommonInternal INTERFACE QT_COMPILER_SUPPORTS_SSE2)
+    endif()
+endif()
diff --git a/cmake/QtPlatformSupport.cmake b/cmake/QtPlatformSupport.cmake
index ac8e8f6ad2..b54d52eba4 100644
--- a/cmake/QtPlatformSupport.cmake
+++ b/cmake/QtPlatformSupport.cmake
@@ -22,11 +22,11 @@ qt_set01(BSD APPLE OR OPENBSD OR FREEBSD OR NETBSD)
 
 qt_set01(WINRT WIN32 AND CMAKE_VS_PLATFORM_TOOSLET STREQUAL "winrt") # FIXME: How to identify this?
 
-qt_set01(APPLE_OSX APPLE) # FIXME: How to identify this? For now assume that always building for macOS.
-qt_set01(APPLE_UIKIT APPLE AND CMAKE_XCODE_PLATFORM_TOOLSET STREQUAL "uikit") # FIXME: How to identify this?
-qt_set01(APPLE_IOS APPLE AND CMAKE_XCODE_PLATFORM_TOOLSET STREQUAL "ios") # FIXME: How to identify this?
-qt_set01(APPLE_TVOS APPLE AND CMAKE_XCODE_PLATFORM_TOOLSET STREQUAL "tvos") # FIXME: How to identify this?
-qt_set01(APPLE_WATCHOS APPLE AND CMAKE_XCODE_PLATFORM_TOOLSET STREQUAL "watchos") # FIXME: How to identify this?
+qt_set01(APPLE_IOS APPLE AND CMAKE_SYSTEM_NAME STREQUAL "iOS")
+qt_set01(APPLE_TVOS APPLE AND CMAKE_SYSTEM_NAME STREQUAL "tvOS")
+qt_set01(APPLE_WATCHOS APPLE AND CMAKE_SYSTEM_NAME STREQUAL "watchOS")
+qt_set01(APPLE_UIKIT APPLE AND (APPLE_IOS OR APPLE_TVOS OR APPLE_WATCHOS))
+qt_set01(APPLE_OSX APPLE AND NOT APPLE_UIKIT)
 
 qt_set01(GCC CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 qt_set01(CLANG CMAKE_CXX_COMPILER_ID MATCHES "Clang")
diff --git a/cmake/QtSetup.cmake b/cmake/QtSetup.cmake
index 1f209e8076..65bd5b9a21 100644
--- a/cmake/QtSetup.cmake
+++ b/cmake/QtSetup.cmake
@@ -75,6 +75,12 @@ if(FEATURE_developer_build)
     set(QT_BUILD_TESTING ON)
     set(__build_benchmarks ON)
 
+    # Tests are not built by default with qmake for iOS and friends, and thus the overall build
+    # tends to fail. Disable them by default when targeting uikit.
+    if(APPLE_UIKIT)
+        set(QT_BUILD_TESTING OFF)
+    endif()
+
     # Disable benchmarks for single configuration generators which do not build
     # with release configuration.
     if (CMAKE_BUILD_TYPE AND NOT CMAKE_BUILD_TYPE STREQUAL Release)
@@ -104,7 +110,14 @@ include(CTest)
 enable_testing()
 
 # Set up building of examples.
-option(BUILD_EXAMPLES "Build Qt examples" ON)
+set(QT_BUILD_EXAMPLES ON)
+# Examples are not built by default with qmake for iOS and friends, and thus the overall build
+# tends to fail. Disable them by default when targeting uikit.
+if(APPLE_UIKIT)
+    set(QT_BUILD_EXAMPLES OFF)
+endif()
+
+option(BUILD_EXAMPLES "Build Qt examples" ${QT_BUILD_EXAMPLES})
 option(QT_NO_MAKE_EXAMPLES "Should examples be built as part of the default 'all' target." OFF)
 
 # Build Benchmarks
diff --git a/cmake/README.md b/cmake/README.md
index 5739b900f7..6c27bc9300 100644
--- a/cmake/README.md
+++ b/cmake/README.md
@@ -201,7 +201,7 @@ When running cmake in qtbase, pass
 ``-DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake -DQT_HOST_PATH=/path/to/your/host/build -DANDROID_SDK_ROOT=$ANDROID_SDK_HOME -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH``
 
 If you don't supply the configuration argument ``-DANDROID_ABI=...``, it will default to
-``armeabi-v7a``. To target other architectures, use on of the following values:
+``armeabi-v7a``. To target other architectures, use one of the following values:
   * arm64: ``-DANDROID_ABI=arm64-v8``
   * x86: ``-DANDROID_ABI=x86``
   * x86_64: ``-DANDROID_ABI=x86_64``
@@ -209,6 +209,57 @@ If you don't supply the configuration argument ``-DANDROID_ABI=...``, it will de
 By default we set the android API level to 21. Should you need to change this supply the following
 configuration argument to the above CMake call: ``-DANDROID_NATIVE_API_LEVEL=${API_LEVEL}``
 
+### Cross compiling for iOS
+
+In order to cross-compile Qt to iOS, you need a host macOS build.
+In addition, it is necessary to install a custom version of vcpkg. Vcpkg is
+needed to supply third-party libraries that Qt requires, but that are not part of the iOS SDK.
+
+Vcpkg for iOS can be set up using the following steps:
+
+  * ```git clone -b qt https://github.com/alcroito/vcpkg```
+  * Run ```bootstrap-vcpkg.sh```
+  * Set the ``VCPKG_DEFAULT_TRIPLET`` environment variable to one of the following values:
+    * ``x64-ios``   (simulator x86_64)
+    * ``x86-ios``   (simulator i386)
+    * ``arm64-ios`` (device arm64)
+    * ``arm-ios``   (device armv7)
+    * ``fat-ios``   (simulator_and_device x86_64 and arm64* - special considedrations)
+  * Set the ``VCPKG_ROOT`` environment variable to the path where you cloned vcpkg
+  * Build Qt dependencies:  ``vcpkg install @qt-packages-ios.txt``
+
+When running cmake in qtbase, pass
+``-DCMAKE_SYSTEM_NAME=iOS -DQT_HOST_PATH=/path/to/your/host/build -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH``
+
+If you don't supply the configuration argument ``-DQT_UIKIT_SDK=...``, it will default to
+``iphonesimulator``. To target another SDK / device type, use one of the following values:
+  * iphonesimulator: ``-DQT_UIKIT_SDK=iphonesimulator``
+  * iphoneos: ``-DQT_UIKIT_SDK=iphoneos``
+  * simulator_and_device: ``-DQT_FORCE_SIMULATOR_AND_DEVICE=ON -DQT_UIKIT_SDK=``
+
+Depending on what value you pass to ``-DQT_UIKIT_SDK=`` a list of target architectures is chosen
+by default:
+  * iphonesimulator: ``x86_64``
+  * iphoneos: ``arm64``
+  * simulator_and_device: ``arm64;x86_64``
+
+You can try choosing a different list of architectures by passing
+``-DCMAKE_OSX_ARCHITECTURES=x86_64;i386``.
+Note that if you choose different architectures compared to the default ones, the build might fail.
+Only do it if you know what you are doing.
+
+####  simulator_and_device special considerations
+To do a simulator_and_device build, a custom version of CMake is required in addition to the vcpkg
+fork. The merge request can be found here:
+https://gitlab.kitware.com/cmake/cmake/merge_requests/3617
+
+After you build your own copy of CMake using this merge request, you need to use it for both
+vcpkg and Qt.
+
+Note that vcpkg prefers its own version of CMake when building packages.
+Make sure to put your custom built CMake in PATH, and force vcpkg to use this CMake by running
+``export VCPKG_FORCE_SYSTEM_BINARIES=1`` in your shell.
+
 # Debugging CMake files
 
 CMake allows specifying the ``--trace`` and ``--trace-expand`` options, which work like