CMake: Introduce Qt6::Startup target

Add an abstraction over Qt::WinMain (aka qtmain.lib) and
iOS's runtime linker entry point (_qt_main_wrapper).

The Core target will now link against the Startup target on all
platforms, instead of just WinMain on Windows.

The creation and linkage interface definition of the Startup target
is done at find_package(Qt6Core) time via the private call of
_qt_internal_setup_startup_target().

This will add automatic linkage of WinMain to executables marked with
the WIN32_EXECUTABLE property on Windows.
As well as the addition of the '-Wl,-e,_qt_main_wrapper' linker flag
when linking iOS executables.

Qt users can opt out of this behavior by either setting the
QT_NO_LINK_QTMAIN property or variable. This is in line with
Qt 5 behavior.

Task-number: QTBUG-87060
Change-Id: I7d5e9f1be0e402cf8e67e6f55bfd285f9e6b04f4
Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>

7 files changed, 135 insertions, 8 deletions

diff --git a/cmake/QtBaseGlobalTargets.cmake b/cmake/QtBaseGlobalTargets.cmake
index dae6cb5d13..b317d191b9 100644
--- a/cmake/QtBaseGlobalTargets.cmake
+++ b/cmake/QtBaseGlobalTargets.cmake
@@ -460,6 +460,7 @@ qt_copy_or_install(FILES
                    cmake/QtSeparateDebugInfo.cmake
                    cmake/QtSetup.cmake
                    cmake/QtSimdHelpers.cmake
+                   cmake/QtStartupHelpers.cmake
                    cmake/QtStandaloneTestsConfig.cmake.in
                    cmake/QtSyncQtHelpers.cmake
                    cmake/QtTargetHelpers.cmake
diff --git a/cmake/QtBuild.cmake b/cmake/QtBuild.cmake
index e0cad89cb9..bd186c28b9 100644
--- a/cmake/QtBuild.cmake
+++ b/cmake/QtBuild.cmake
@@ -478,6 +478,7 @@ include(QtRpathHelpers)
 include(QtSanitizerHelpers)
 include(QtScopeFinalizerHelpers)
 include(QtSimdHelpers)
+include(QtStartupHelpers)
 include(QtSyncQtHelpers)
 include(QtTargetHelpers)
 include(QtTestHelpers)
diff --git a/cmake/QtPrlHelpers.cmake b/cmake/QtPrlHelpers.cmake
index 7977afd030..932565f318 100644
--- a/cmake/QtPrlHelpers.cmake
+++ b/cmake/QtPrlHelpers.cmake
@@ -29,6 +29,16 @@ function(qt_internal_walk_libs target out_var dict_name operation)
         return()
     endif()
     list(APPEND collected ${target})
+
+    if(target STREQUAL "${QT_CMAKE_EXPORT_NAMESPACE}::Startup")
+        # We can't (and don't need to) process Startup, because it contains $<TARGET_PROPERTY:prop>
+        # genexes which get replaced with $<TARGET_PROPERTY:Startup,prop> genexes in the code below
+        # and that causes 'INTERFACE_LIBRARY targets may only have whitelisted properties.' errors
+        # with CMake versions equal to or lower than 3.18. These errors are super unintuitive to
+        # debug because there's no mention that it's happening during a file(GENERATE) call.
+        return()
+    endif()
+
     if(NOT TARGET ${dict_name})
         add_library(${dict_name} INTERFACE IMPORTED GLOBAL)
     endif()
diff --git a/cmake/QtStartupHelpers.cmake b/cmake/QtStartupHelpers.cmake
new file mode 100644
index 0000000000..0e7288e9cf
--- /dev/null
+++ b/cmake/QtStartupHelpers.cmake
@@ -0,0 +1,16 @@
+# Set up some internal requirements for the Startup target.
+#
+# The creation of the Startup target and its linkage setup happens in 2 places:
+# - in src/corelib/CMakeLists.txt when building qtbase.
+# - at find_package(Qt6Core) time.
+#
+# See _qt_internal_setup_startup_target() in Qt6CoreMacros.cmake for the implementation of that.
+function(qt_internal_setup_startup_target)
+    set(dependent_target "Core")
+
+    # On windows, find_package(Qt6Core) should call find_package(Qt6WinMain) so that Startup can
+    # link against WinMain.
+    if(WIN32)
+        qt_record_extra_qt_package_dependency("${dependent_target}" WinMain "${PROJECT_VERSION}")
+    endif()
+endfunction()
diff --git a/src/corelib/CMakeLists.txt b/src/corelib/CMakeLists.txt
index b6802a6fb5..061032fad7 100644
--- a/src/corelib/CMakeLists.txt
+++ b/src/corelib/CMakeLists.txt
@@ -1293,15 +1293,12 @@ endif()
 
 qt_internal_apply_gc_binaries_conditional(Core PUBLIC)
 
-if(WIN32)
-    set(isExe $<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>)
-    set(isWin32 $<BOOL:$<TARGET_PROPERTY:WIN32_EXECUTABLE>>)
-    set(isNotExcluded $<NOT:$<BOOL:$<TARGET_PROPERTY:Qt5_NO_LINK_QTMAIN>>>)
-    set(isPolicyNEW $<TARGET_POLICY:CMP0020>)
+# Run some required internal code before creating the Startup target.
+qt_internal_setup_startup_target()
 
-    target_link_libraries(Core INTERFACE $<$<AND:${isExe},${isWin32},${isNotExcluded},${isPolicyNEW}>:Qt::WinMain>)
-    qt_record_extra_qt_package_dependency(Core WinMain "${PROJECT_VERSION}")
-endif()
+# Create the Startup target and set flags on it, so that they are already
+# available at Core build time.
+_qt_internal_setup_startup_target()
 
 # Record darwin minimum deployment target.
 if(APPLE AND CMAKE_OSX_DEPLOYMENT_TARGET)
diff --git a/src/corelib/Qt6CoreConfigExtras.cmake.in b/src/corelib/Qt6CoreConfigExtras.cmake.in
index c43e4f772e..6e56a20b29 100644
--- a/src/corelib/Qt6CoreConfigExtras.cmake.in
+++ b/src/corelib/Qt6CoreConfigExtras.cmake.in
@@ -47,6 +47,8 @@ set(QT@PROJECT_VERSION_MAJOR@_IS_SHARED_LIBS_BUILD "@BUILD_SHARED_LIBS@")
 get_filename_component(_Qt6CoreConfigDir ${CMAKE_CURRENT_LIST_FILE} PATH)
 set(_Qt6CTestMacros "${_Qt6CoreConfigDir}/Qt6CTestMacros.cmake")
 
+_qt_internal_setup_startup_target()
+
 if(ANDROID_PLATFORM)
     include("${CMAKE_CURRENT_LIST_DIR}/@QT_CMAKE_EXPORT_NAMESPACE@AndroidMacros.cmake")
 endif()
diff --git a/src/corelib/Qt6CoreMacros.cmake b/src/corelib/Qt6CoreMacros.cmake
index b1c9661dca..a9f76cc99e 100644
--- a/src/corelib/Qt6CoreMacros.cmake
+++ b/src/corelib/Qt6CoreMacros.cmake
@@ -1317,3 +1317,103 @@ function(_qt_internal_apply_strict_cpp target)
         endif()
     endif()
 endfunction()
+
+# Sets up auto-linkage of platform-specific entry points.
+#
+# See qt_internal_setup_startup_target() in qtbase/cmake/QtStartupHelpers.cmake for the internal
+# implementation counterpart.
+#
+# A project that uses Qt can opt-out of this auto-linking behavior by either setting the
+# QT_NO_LINK_QTMAIN property to TRUE on a target, or by setting the
+# QT_NO_LINK_QTMAIN variable to TRUE before the find_package(Qt6) call.
+#
+# QT_NO_LINK_QTMAIN replaces the old Qt5_NO_LINK_QTMAIN name for both the property and variable
+#name.
+#
+# This function is called by Qt6CoreConfigExtras.cmake at find_package(Qt6Core) time.
+# The reason the linkage is done at find_package() time instead of Qt build time is to allow
+# opting out via a variable. This ensures compatibility with Qt5 behavior.
+# If it was done at build time, opt-out could only be achieved via the property.
+function(_qt_internal_setup_startup_target)
+    set(target "${QT_CMAKE_EXPORT_NAMESPACE}::Startup")
+    set(dependent_target "${QT_CMAKE_EXPORT_NAMESPACE}::Core")
+
+    # Get actual Core target name.
+    get_target_property(dependent_aliased_target "${dependent_target}" ALIASED_TARGET)
+    if(dependent_aliased_target)
+        set(dependent_target "${dependent_aliased_target}")
+    endif()
+
+    # Check if Core is being built as part of current CMake invocation.
+    # If it is, that means the Core target scope is global and the same scope should be set for the
+    # to-be-created Startup target, to avoid creating 100s of local IMPORTED Startup targets
+    # when building with -DBUILD_TESTING=ON and -DBUILD_EXAMPLES=ON due to multiple
+    # find_package(Qt6Core) calls.
+    get_target_property(core_imported "${dependent_target}" IMPORTED)
+    set(create_global "")
+    if(NOT core_imported)
+        set(create_global "GLOBAL")
+    endif()
+
+    # Create Startup only if it's not available in the current scope.
+    # Guards against multiple find_package(Qt6Core) calls.
+    if(NOT TARGET "${target}")
+        add_library("${target}" INTERFACE IMPORTED ${create_global})
+    endif()
+
+    # Allow variable opt-out. Has to be after target creation, because Core always links against
+    # Startup.
+    if(QT_NO_LINK_QTMAIN)
+        return()
+    endif()
+
+    # find_package(Qt6Core) can be called multiple times, but we only want to set the flags once.
+    set(initialized_prop "_qt_startup_target_initialized")
+    get_target_property(initialized "${target}" "${initialized_prop}")
+    if(initialized)
+        return()
+    else()
+        set_target_properties("${target}" PROPERTIES "${initialized_prop}" TRUE)
+    endif()
+
+    # On Windows this enables automatic linkage to WinMain.
+    # On iOS this enables automatic passing of a linker flag that will change the default
+    # entry point of the linked executable.
+    set(isExe "$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>")
+    set(isNotExcluded "$<NOT:$<BOOL:$<TARGET_PROPERTY:QT_NO_LINK_QTMAIN>>>")
+    if(WIN32)
+        set(isWin32 "$<BOOL:$<TARGET_PROPERTY:WIN32_EXECUTABLE>>")
+        set(isPolicyNEW "$<TARGET_POLICY:CMP0020>")
+        set(finalGenex "$<$<AND:${isExe},${isWin32},${isNotExcluded},${isPolicyNEW}>:Qt::WinMain>")
+
+        # Use set_target_properties instead of target_link_libraries because the latter has some
+        # weird additional behavior of checking which project the target belongs to, and might
+        # error out when called multiple times from different scopes.
+        set_target_properties("${target}" PROPERTIES INTERFACE_LINK_LIBRARIES "${finalGenex}")
+    elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+        set(flag "-Wl,-e,_qt_main_wrapper")
+        set(finalGenex "$<$<AND:${isExe},${isNotExcluded}>:${flag}>")
+
+        set_target_properties("${target}" PROPERTIES INTERFACE_LINK_OPTIONS "${finalGenex}")
+    endif()
+
+    # Set up the dependency on Startup for the local Core target, if it hasn't been set yet.
+    set(initialized_prop "_qt_core_startup_dependency_initialized")
+    get_target_property(initialized "${dependent_target}" "${initialized_prop}")
+    if(initialized)
+        get_target_property(thelibs "${dependent_target}" INTERFACE_LINK_LIBRARIES)
+        return()
+    else()
+        set_target_properties("${dependent_target}" PROPERTIES "${initialized_prop}" TRUE)
+
+        # Export the initialized property on Core, to ensure that Core links against Startup
+        # only once in a non-qtbase project.
+        if(NOT core_imported)
+            set_property(TARGET "${dependent_target}" APPEND PROPERTY
+                                 EXPORT_PROPERTIES "${initialized_prop}")
+        endif()
+    endif()
+
+    target_link_libraries("${dependent_target}" INTERFACE "${target}")
+    get_target_property(thelibs "${dependent_target}" INTERFACE_LINK_LIBRARIES)
+endfunction()