echo/CMake
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge topic 'link-feature-attributes-stabilization' into release-3.30

Browse Source 
576567f028 Link feature attributes: stabilization
5617c34c31 Libraries processing: update configuration wording

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !9607
This commit is contained in:
Brad King 2024-06-24 13:21:59 +00:00 committed by Kitware Robot
commit c3046ea289
58 changed files with 268 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Help/manual/cmake-variables.7.rst
View File

@ -467,7 +467,7 @@ Variables that Control the Build
/variable/CMAKE_LANG_INCLUDE_WHAT_YOU_USE /variable/CMAKE_LANG_INCLUDE_WHAT_YOU_USE
/variable/CMAKE_LANG_LINK_GROUP_USING_FEATURE /variable/CMAKE_LANG_LINK_GROUP_USING_FEATURE
/variable/CMAKE_LANG_LINK_GROUP_USING_FEATURE_SUPPORTED /variable/CMAKE_LANG_LINK_GROUP_USING_FEATURE_SUPPORTED
/variable/CMAKE_LANG_LINK_LIBRARY_FEATURE_PROPERTIES /variable/CMAKE_LANG_LINK_LIBRARY_FEATURE_ATTRIBUTES
/variable/CMAKE_LANG_LINK_LIBRARY_FILE_FLAG /variable/CMAKE_LANG_LINK_LIBRARY_FILE_FLAG
/variable/CMAKE_LANG_LINK_LIBRARY_FLAG /variable/CMAKE_LANG_LINK_LIBRARY_FLAG
/variable/CMAKE_LANG_LINK_LIBRARY_USING_FEATURE /variable/CMAKE_LANG_LINK_LIBRARY_USING_FEATURE
@ -486,7 +486,7 @@ Variables that Control the Build
/variable/CMAKE_LINK_GROUP_USING_FEATURE /variable/CMAKE_LINK_GROUP_USING_FEATURE
/variable/CMAKE_LINK_GROUP_USING_FEATURE_SUPPORTED /variable/CMAKE_LINK_GROUP_USING_FEATURE_SUPPORTED
/variable/CMAKE_LINK_INTERFACE_LIBRARIES /variable/CMAKE_LINK_INTERFACE_LIBRARIES
/variable/CMAKE_LINK_LIBRARY_FEATURE_PROPERTIES /variable/CMAKE_LINK_LIBRARY_FEATURE_ATTRIBUTES
/variable/CMAKE_LINK_LIBRARY_FILE_FLAG /variable/CMAKE_LINK_LIBRARY_FILE_FLAG
/variable/CMAKE_LINK_LIBRARY_FLAG /variable/CMAKE_LINK_LIBRARY_FLAG
/variable/CMAKE_LINK_LIBRARY_USING_FEATURE /variable/CMAKE_LINK_LIBRARY_USING_FEATURE

6
Help/release/3.30.rst
View File

@ -148,9 +148,9 @@ Generator Expressions
associated :variable:`CMAKE_<LANG>_COMPILER_FRONTEND_VARIANT` variables. associated :variable:`CMAKE_<LANG>_COMPILER_FRONTEND_VARIANT` variables.
* Link features, as used with the :genex:`LINK_LIBRARY` generator expression, * Link features, as used with the :genex:`LINK_LIBRARY` generator expression,
gained the ability to have properties that describe their behavior by gained the ability to have attributes that describe their behavior by
specifying the :variable:`CMAKE_LINK_LIBRARY_<FEATURE>_PROPERTIES` or specifying the :variable:`CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` or
:variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_PROPERTIES` variables. :variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` variables.
* The :genex:`QUOTE` generator expression was added to evaluate to ``"``. * The :genex:`QUOTE` generator expression was added to evaluate to ``"``.

6
Help/variable/CMAKE_LANG_LINK_LIBRARY_FEATURE_PROPERTIES.rst → Help/variable/CMAKE_LANG_LINK_LIBRARY_FEATURE_ATTRIBUTES.rst
View File

@ -1,10 +1,10 @@
CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_PROPERTIES CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_ATTRIBUTES
---------------------------------------------- ----------------------------------------------
.. versionadded:: 3.30 .. versionadded:: 3.30
This variable defines the semantics of the specified link library ``<FEATURE>`` This variable defines the semantics of the specified link library ``<FEATURE>``
when linking with the link language ``<LANG>``. It takes precedence over when linking with the link language ``<LANG>``. It takes precedence over
:variable:`CMAKE_LINK_LIBRARY_<FEATURE>_PROPERTIES` if that variable is also :variable:`CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` if that variable is also
defined for the same ``<FEATURE>``, but otherwise has similar effects. defined for the same ``<FEATURE>``, but otherwise has similar effects.
See :variable:`CMAKE_LINK_LIBRARY_<FEATURE>_PROPERTIES` for further details. See :variable:`CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` for further details.

37
Help/variable/CMAKE_LINK_LIBRARY_FEATURE_PROPERTIES.rst → Help/variable/CMAKE_LINK_LIBRARY_FEATURE_ATTRIBUTES.rst
View File

@ -1,4 +1,4 @@
CMAKE_LINK_LIBRARY_<FEATURE>_PROPERTIES CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES
--------------------------------------- ---------------------------------------
.. versionadded:: 3.30 .. versionadded:: 3.30
@ -17,28 +17,29 @@ The :variable:`CMAKE_<LANG>_LINK_LIBRARY_USING_<FEATURE>_SUPPORTED` and
control whether the ``<FEATURE>`` is available at all. control whether the ``<FEATURE>`` is available at all.
When linking for a particular language ``<LANG>``, When linking for a particular language ``<LANG>``,
``CMAKE_LINK_LIBRARY_<FEATURE>_PROPERTIES`` is ignored if the ``CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES`` is ignored if the
:variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_PROPERTIES` variable is also :variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` variable is also
defined for the same ``<FEATURE>``. defined for the same ``<FEATURE>``.
The value of ``CMAKE_LINK_LIBRARY_<FEATURE>_PROPERTIES`` and The value of ``CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES`` and
:variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_PROPERTIES` at the end of the :variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` at the end of the
directory scope in which a target is defined is what matters. directory scope in which a target is defined is what matters.
Feature Properties Definition Feature Attributes Definition
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
A feature properties definition is a A feature attributes definition is a
:ref:`semicolon-separated list <CMake Language Lists>` of ``property=value(s)`` :ref:`semicolon-separated list <CMake Language Lists>` of
items. If a property has multiple values, those values must be comma-separated. ``attribute=value(s)`` items. If an attribute has multiple values, those values
must be comma-separated.
The following properties are supported: The following attributes are supported:
``LIBRARY_TYPE=<library-type-list>`` ``LIBRARY_TYPE=<library-type-list>``
Specify the library types supported by the feature. Supported values are: Specify the library types supported by the feature. Supported values are:
``STATIC``, ``SHARED``, ``MODULE``, and ``EXECUTABLE``. ``STATIC``, ``SHARED``, ``MODULE``, and ``EXECUTABLE``.
If this property is not specified, the default is If this attribute is not specified, the default is
``LIBRARY_TYPE=STATIC,SHARED,MODULE,EXECUTABLE``. ``LIBRARY_TYPE=STATIC,SHARED,MODULE,EXECUTABLE``.
If the feature is used with an unsupported library type, CMake will emit a If the feature is used with an unsupported library type, CMake will emit a
@ -51,9 +52,9 @@ The following properties are supported:
:prop_tgt:`LINK_LIBRARY_OVERRIDE_<LIBRARY>` target property definitions, :prop_tgt:`LINK_LIBRARY_OVERRIDE_<LIBRARY>` target property definitions,
if defined. if defined.
If this property is not specified, the default is an empty list. If this attribute is not specified, the default is an empty list.
``UNICITY=YES|NO|DEFAULT`` ``DEDUPLICATION=YES|NO|DEFAULT``
Specify the de-duplication strategy for a library using this feature. Specify the de-duplication strategy for a library using this feature.
``YES`` ``YES``
@ -67,7 +68,7 @@ The following properties are supported:
``DEFAULT`` ``DEFAULT``
Let CMake determine a de-duplication strategy automatically. Let CMake determine a de-duplication strategy automatically.
If this property is not specified, ``DEFAULT`` will be used. If this attribute is not specified, ``DEFAULT`` will be used.
Example Example
^^^^^^^ ^^^^^^^
@ -75,14 +76,14 @@ Example
A common need is the loading of a full archive as part of the creation of a A common need is the loading of a full archive as part of the creation of a
shared library. The built-in ``WHOLE_ARCHIVE`` feature can be used for that shared library. The built-in ``WHOLE_ARCHIVE`` feature can be used for that
purpose. The implementation of that built-in feature sets the following purpose. The implementation of that built-in feature sets the following
link library feature properties: link library feature attributes:
.. code-block:: cmake .. code-block:: cmake
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES
LIBRARY_TYPE=STATIC LIBRARY_TYPE=STATIC
OVERRIDE=DEFAULT OVERRIDE=DEFAULT
UNICITY=YES DEDUPLICATION=YES
) )
``LIBRARY_TYPE=STATIC`` ``LIBRARY_TYPE=STATIC``
@ -92,7 +93,7 @@ link library feature properties:
because they are compatible and enhance the user's experience: standard because they are compatible and enhance the user's experience: standard
library specification and ``$<LINK_LIBRARY:WHOLE_ARCHIVE>`` can be used library specification and ``$<LINK_LIBRARY:WHOLE_ARCHIVE>`` can be used
freely. freely.
``UNICITY=YES`` ``DEDUPLICATION=YES``
When this feature is used, the linker loads all symbols from the static When this feature is used, the linker loads all symbols from the static
library, so there is no need to repeat the library on the linker library, so there is no need to repeat the library on the linker
command line. command line.

4
Help/variable/CMAKE_LINK_LIBRARY_USING_FEATURE.txt
View File

@ -3,8 +3,8 @@ and underscores. Feature names defined in all uppercase are reserved for
CMake's own built-in features (see `Predefined Features`_ further below). CMake's own built-in features (see `Predefined Features`_ further below).
Some aspects of feature behavior can be defined by the Some aspects of feature behavior can be defined by the
:variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_PROPERTIES` and :variable:`CMAKE_<LANG>_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` and
:variable:`CMAKE_LINK_LIBRARY_<FEATURE>_PROPERTIES` variables. :variable:`CMAKE_LINK_LIBRARY_<FEATURE>_ATTRIBUTES` variables.
Feature Definitions Feature Definitions
^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^

2
Modules/Platform/AIX-GNU.cmake
View File

@ -17,7 +17,7 @@ macro(__aix_compiler_gnu lang)
set(CMAKE_${lang}_VERBOSE_LINK_FLAG "-Wl,-v") set(CMAKE_${lang}_VERBOSE_LINK_FLAG "-Wl,-v")
set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath") set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath")
set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE UNICITY=ALL) set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE DEDUPLICATION=ALL)
if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 7 OR CMAKE_SYSTEM_VERSION VERSION_LESS 7.1) if(CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 7 OR CMAKE_SYSTEM_VERSION VERSION_LESS 7.1)
unset(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY) unset(CMAKE_${lang}_COMPILE_OPTIONS_VISIBILITY)

2
Modules/Platform/AIX-XL.cmake
View File

@ -17,7 +17,7 @@ macro(__aix_compiler_xl lang)
set(CMAKE_SHARED_MODULE_${lang}_FLAGS " ") set(CMAKE_SHARED_MODULE_${lang}_FLAGS " ")
set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath") set(CMAKE_${lang}_LINK_FLAGS "-Wl,-bnoipath")
set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE UNICITY=ALL) set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE DEDUPLICATION=ALL)
set(_OBJECTS " <OBJECTS>") set(_OBJECTS " <OBJECTS>")
if(DEFINED CMAKE_XL_CreateExportList AND CMAKE_XL_CreateExportList STREQUAL "") if(DEFINED CMAKE_XL_CreateExportList AND CMAKE_XL_CreateExportList STREQUAL "")

4
Modules/Platform/Apple-Clang.cmake
View File

@ -15,11 +15,11 @@ macro(__apple_compiler_clang lang)
set(CMAKE_${lang}_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ") set(CMAKE_${lang}_SYSTEM_FRAMEWORK_SEARCH_FLAG "-iframework ")
endif() endif()
set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE UNICITY=ALL) set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE DEDUPLICATION=ALL)
set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK "-framework <LIBRARY>") set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK "-framework <LIBRARY>")
set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE) set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE)
set(CMAKE_${lang}_LINK_LIBRARY_FRAMEWORK_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_${lang}_LINK_LIBRARY_FRAMEWORK_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
# linker selection # linker selection
set(CMAKE_${lang}_USING_LINKER_SYSTEM "-fuse-ld=ld") set(CMAKE_${lang}_USING_LINKER_SYSTEM "-fuse-ld=ld")

2
Modules/Platform/Apple-GNU.cmake
View File

@ -17,7 +17,7 @@ macro(__apple_compiler_gnu lang)
set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK "-framework <LIBRARY>") set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK "-framework <LIBRARY>")
set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE) set(CMAKE_${lang}_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_FRAMEWORK_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_FRAMEWORK_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
set(CMAKE_${lang}_USING_LINKER_SYSTEM "") set(CMAKE_${lang}_USING_LINKER_SYSTEM "")
set(CMAKE_${lang}_USING_LINKER_APPLE_CLASSIC "LINKER:-ld_classic") set(CMAKE_${lang}_USING_LINKER_APPLE_CLASSIC "LINKER:-ld_classic")

2
Modules/Platform/CYGWIN-GNU.cmake
View File

@ -40,7 +40,7 @@ else()
"LINKER:--no-whole-archive") "LINKER:--no-whole-archive")
endif() endif()
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
macro(__cygwin_compiler_gnu lang) macro(__cygwin_compiler_gnu lang)

16
Modules/Platform/Darwin.cmake
View File

@ -114,37 +114,37 @@ set(CMAKE_CREATE_TEXT_STUBS "<CMAKE_TAPI> stubify -isysroot <CMAKE_OSX_SYSROOT>
# Defines LINK_LIBRARY features for frameworks # Defines LINK_LIBRARY features for frameworks
set(CMAKE_LINK_LIBRARY_USING_FRAMEWORK "LINKER:-framework,<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_FRAMEWORK "LINKER:-framework,<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_FRAMEWORK_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_FRAMEWORK_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_FRAMEWORK_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
set(CMAKE_LINK_LIBRARY_USING_NEEDED_FRAMEWORK "LINKER:-needed_framework,<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_NEEDED_FRAMEWORK "LINKER:-needed_framework,<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_NEEDED_FRAMEWORK_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_NEEDED_FRAMEWORK_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_NEEDED_FRAMEWORK_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_NEEDED_FRAMEWORK_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
set(CMAKE_LINK_LIBRARY_USING_REEXPORT_FRAMEWORK "LINKER:-reexport_framework,<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_REEXPORT_FRAMEWORK "LINKER:-reexport_framework,<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_REEXPORT_FRAMEWORK_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_REEXPORT_FRAMEWORK_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_REEXPORT_FRAMEWORK_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_REEXPORT_FRAMEWORK_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
set(CMAKE_LINK_LIBRARY_USING_WEAK_FRAMEWORK "LINKER:-weak_framework,<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_WEAK_FRAMEWORK "LINKER:-weak_framework,<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_WEAK_FRAMEWORK_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WEAK_FRAMEWORK_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WEAK_FRAMEWORK_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WEAK_FRAMEWORK_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
# Defines LINK_LIBRARY features for libraries # Defines LINK_LIBRARY features for libraries
set(CMAKE_LINK_LIBRARY_USING_NEEDED_LIBRARY "PATH{LINKER:-needed_library,<LIBRARY>}NAME{LINKER:-needed-l<LIBRARY>}") set(CMAKE_LINK_LIBRARY_USING_NEEDED_LIBRARY "PATH{LINKER:-needed_library,<LIBRARY>}NAME{LINKER:-needed-l<LIBRARY>}")
set(CMAKE_LINK_LIBRARY_USING_NEEDED_LIBRARY_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_NEEDED_LIBRARY_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_NEEDED_LIBRARY_PROPERTIES LIBRARY_TYPE=SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_NEEDED_LIBRARY_ATTRIBUTES LIBRARY_TYPE=SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
set(CMAKE_LINK_LIBRARY_USING_REEXPORT_LIBRARY "PATH{LINKER:-reexport_library,<LIBRARY>}NAME{LINKER:-reexport-l<LIBRARY>}") set(CMAKE_LINK_LIBRARY_USING_REEXPORT_LIBRARY "PATH{LINKER:-reexport_library,<LIBRARY>}NAME{LINKER:-reexport-l<LIBRARY>}")
set(CMAKE_LINK_LIBRARY_USING_REEXPORT_LIBRARY_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_REEXPORT_LIBRARY_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_REEXPORT_LIBRARY_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_REEXPORT_LIBRARY_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
set(CMAKE_LINK_LIBRARY_USING_WEAK_LIBRARY "PATH{LINKER:-weak_library,<LIBRARY>}NAME{LINKER:-weak-l<LIBRARY>}") set(CMAKE_LINK_LIBRARY_USING_WEAK_LIBRARY "PATH{LINKER:-weak_library,<LIBRARY>}NAME{LINKER:-weak-l<LIBRARY>}")
set(CMAKE_LINK_LIBRARY_USING_WEAK_LIBRARY_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WEAK_LIBRARY_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WEAK_LIBRARY_PROPERTIES LIBRARY_TYPE=STATIC,SHARED UNICITY=DEFAULT OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WEAK_LIBRARY_ATTRIBUTES LIBRARY_TYPE=STATIC,SHARED DEDUPLICATION=DEFAULT OVERRIDE=DEFAULT)
# Defines LINK_LIBRARY feature to Force loading of all members of an archive # Defines LINK_LIBRARY feature to Force loading of all members of an archive
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:-force_load,<LIB_ITEM>") set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:-force_load,<LIB_ITEM>")
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
# default to searching for frameworks first # default to searching for frameworks first
if(NOT DEFINED CMAKE_FIND_FRAMEWORK) if(NOT DEFINED CMAKE_FIND_FRAMEWORK)

2
Modules/Platform/FreeBSD.cmake
View File

@ -51,7 +51,7 @@ else()
"LINKER:--no-whole-archive") "LINKER:--no-whole-archive")
endif() endif()
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
# Features for LINK_GROUP generator expression # Features for LINK_GROUP generator expression

2
Modules/Platform/Linux.cmake
View File

@ -44,7 +44,7 @@ else()
"LINKER:--no-whole-archive") "LINKER:--no-whole-archive")
endif() endif()
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
# Features for LINK_GROUP generator expression # Features for LINK_GROUP generator expression
## RESCAN: request the linker to rescan static libraries until there is ## RESCAN: request the linker to rescan static libraries until there is

2
Modules/Platform/NetBSD.cmake
View File

@ -37,7 +37,7 @@ else()
"LINKER:--no-whole-archive") "LINKER:--no-whole-archive")
endif() endif()
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
# Features for LINK_GROUP generator expression # Features for LINK_GROUP generator expression

2
Modules/Platform/SunOS.cmake
View File

@ -20,7 +20,7 @@ else()
"LINKER:-z,defaultextract") "LINKER:-z,defaultextract")
endif() endif()
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
# Features for LINK_GROUP generator expression # Features for LINK_GROUP generator expression

4
Modules/Platform/Windows-Clang.cmake
View File

@ -55,7 +55,7 @@ macro(__windows_compiler_clang_gnu lang)
set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "") set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "")
set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared") set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared")
set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=FORWARD UNICITY=ALL) set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=FORWARD DEDUPLICATION=ALL)
# linker selection # linker selection
set(CMAKE_${lang}_USING_LINKER_DEFAULT "-fuse-ld=lld-link") set(CMAKE_${lang}_USING_LINKER_DEFAULT "-fuse-ld=lld-link")
@ -140,7 +140,7 @@ macro(__windows_compiler_clang_gnu lang)
## WHOLE_ARCHIVE: Force loading all members of an archive ## WHOLE_ARCHIVE: Force loading all members of an archive
set(CMAKE_${lang}_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:/WHOLEARCHIVE:<LIBRARY>") set(CMAKE_${lang}_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:/WHOLEARCHIVE:<LIBRARY>")
set(CMAKE_${lang}_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_${lang}_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_${lang}_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_${lang}_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
endif() endif()
enable_language(RC) enable_language(RC)

2
Modules/Platform/Windows-GNU.cmake
View File

@ -88,7 +88,7 @@ else()
"LINKER:--no-whole-archive") "LINKER:--no-whole-archive")
endif() endif()
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
# Features for LINK_GROUP generator expression # Features for LINK_GROUP generator expression
## RESCAN: request the linker to rescan static libraries until there is ## RESCAN: request the linker to rescan static libraries until there is

2
Modules/Platform/Windows-IntelLLVM.cmake
View File

@ -37,7 +37,7 @@ macro(__windows_compiler_intel lang)
## WHOLE_ARCHIVE: Force loading all members of an archive ## WHOLE_ARCHIVE: Force loading all members of an archive
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:/WHOLEARCHIVE:<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "LINKER:/WHOLEARCHIVE:<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
endif() endif()
set(CMAKE_${lang}_LINK_EXECUTABLE set(CMAKE_${lang}_LINK_EXECUTABLE

4
Modules/Platform/Windows-MSVC.cmake
View File

@ -358,7 +358,7 @@ if(MSVC_VERSION GREATER "1900")
## WHOLE_ARCHIVE: Force loading all members of an archive ## WHOLE_ARCHIVE: Force loading all members of an archive
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "/WHOLEARCHIVE:<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE "/WHOLEARCHIVE:<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_WHOLE_ARCHIVE_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_PROPERTIES LIBRARY_TYPE=STATIC UNICITY=YES OVERRIDE=DEFAULT) set(CMAKE_LINK_LIBRARY_WHOLE_ARCHIVE_ATTRIBUTES LIBRARY_TYPE=STATIC DEDUPLICATION=YES OVERRIDE=DEFAULT)
endif() endif()
@ -514,7 +514,7 @@ macro(__windows_compiler_msvc lang)
set(CMAKE_${lang}_DEPFILE_FORMAT msvc) set(CMAKE_${lang}_DEPFILE_FORMAT msvc)
endif() endif()
set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=FORWARD UNICITY=ALL) set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=FORWARD DEDUPLICATION=ALL)
# linker selection # linker selection
set(CMAKE_${lang}_USING_LINKER_SYSTEM "${CMAKE_LINKER_LINK}") set(CMAKE_${lang}_USING_LINKER_SYSTEM "${CMAKE_LINKER_LINK}")

216
Source/cmComputeLinkDepends.cxx
View File

@ -202,8 +202,8 @@ bool IsFeatureSupported(cmMakefile* makefile, std::string const& linkLanguage,
return makefile->GetDefinition(featureSupported).IsOn(); return makefile->GetDefinition(featureSupported).IsOn();
} }
// LINK_LIBRARY feature properties management // LINK_LIBRARY feature attributes management
struct LinkLibraryFeaturePropertySet struct LinkLibraryFeatureAttributeSet
{ {
std::set<cmStateEnums::TargetType> LibraryTypes = { std::set<cmStateEnums::TargetType> LibraryTypes = {
cmStateEnums::EXECUTABLE, cmStateEnums::STATIC_LIBRARY, cmStateEnums::EXECUTABLE, cmStateEnums::STATIC_LIBRARY,
@ -212,84 +212,88 @@ struct LinkLibraryFeaturePropertySet
}; };
std::set<std::string> Override; std::set<std::string> Override;
enum UnicityKind enum DeduplicationKind
{ {
Default, Default,
Yes, Yes,
No No
}; };
UnicityKind Unicity = Default; DeduplicationKind Deduplication = Default;
}; };
std::map<std::string, LinkLibraryFeaturePropertySet> std::map<std::string, LinkLibraryFeatureAttributeSet>
LinkLibraryFeatureProperties; LinkLibraryFeatureAttributes;
const LinkLibraryFeaturePropertySet& GetLinkLibraryFeatureProperties( const LinkLibraryFeatureAttributeSet& GetLinkLibraryFeatureAttributes(
cmMakefile* makefile, std::string const& linkLanguage, cmMakefile* makefile, std::string const& linkLanguage,
const std::string& feature) const std::string& feature)
{ {
auto it = LinkLibraryFeatureProperties.find(feature); auto it = LinkLibraryFeatureAttributes.find(feature);
if (it != LinkLibraryFeatureProperties.end()) { if (it != LinkLibraryFeatureAttributes.end()) {
return it->second; return it->second;
} }
auto featurePropertiesVariable = auto featureAttributesVariable =
cmStrCat("CMAKE_", linkLanguage, "_LINK_LIBRARY_", feature, "_PROPERTIES"); cmStrCat("CMAKE_", linkLanguage, "_LINK_LIBRARY_", feature, "_ATTRIBUTES");
auto featurePropertiesValues = auto featureAttributesValues =
makefile->GetDefinition(featurePropertiesVariable); makefile->GetDefinition(featureAttributesVariable);
if (featurePropertiesValues.IsEmpty()) { if (featureAttributesValues.IsEmpty()) {
// try language agnostic definition // try language agnostic definition
featurePropertiesVariable = featureAttributesVariable =
cmStrCat("CMAKE_LINK_LIBRARY_", feature, "_PROPERTIES"); cmStrCat("CMAKE_LINK_LIBRARY_", feature, "_ATTRIBUTES");
featurePropertiesValues = featureAttributesValues =
makefile->GetDefinition(featurePropertiesVariable); makefile->GetDefinition(featureAttributesVariable);
} }
if (!featurePropertiesValues.IsEmpty()) { if (!featureAttributesValues.IsEmpty()) {
LinkLibraryFeaturePropertySet featureProperties; LinkLibraryFeatureAttributeSet featureAttributes;
cmsys::RegularExpression processingOption{ cmsys::RegularExpression processingOption{
"^(LIBRARY_TYPE|UNICITY|OVERRIDE)=((STATIC|SHARED|MODULE|EXECUTABLE)(,(" "^(LIBRARY_TYPE|DEDUPLICATION|OVERRIDE)=((STATIC|SHARED|MODULE|"
"EXECUTABLE)(,("
"STATIC|" "STATIC|"
"SHARED|MODULE|EXECUTABLE)" "SHARED|MODULE|EXECUTABLE)"
")*|YES|NO|DEFAULT|[A-Za-z0-9_]+(,[A-Za-z0-9_]+)*)$" ")*|YES|NO|DEFAULT|[A-Za-z0-9_]+(,[A-Za-z0-9_]+)*)$"
}; };
std::string errorMessage; std::string errorMessage;
for (auto const& option : cmList{ featurePropertiesValues }) { for (auto const& option : cmList{ featureAttributesValues }) {
if (processingOption.find(option)) { if (processingOption.find(option)) {
if (processingOption.match(1) == "LIBRARY_TYPE") { if (processingOption.match(1) == "LIBRARY_TYPE") {
featureProperties.LibraryTypes.clear(); featureAttributes.LibraryTypes.clear();
for (auto const& value : for (auto const& value :
cmTokenize(processingOption.match(2), ","_s)) { cmTokenize(processingOption.match(2), ","_s)) {
if (value == "STATIC") { if (value == "STATIC") {
featureProperties.LibraryTypes.emplace( featureAttributes.LibraryTypes.emplace(
cmStateEnums::STATIC_LIBRARY); cmStateEnums::STATIC_LIBRARY);
} else if (value == "SHARED") { } else if (value == "SHARED") {
featureProperties.LibraryTypes.emplace( featureAttributes.LibraryTypes.emplace(
cmStateEnums::SHARED_LIBRARY); cmStateEnums::SHARED_LIBRARY);
} else if (value == "MODULE") { } else if (value == "MODULE") {
featureProperties.LibraryTypes.emplace( featureAttributes.LibraryTypes.emplace(
cmStateEnums::MODULE_LIBRARY); cmStateEnums::MODULE_LIBRARY);
} else if (value == "EXECUTABLE") { } else if (value == "EXECUTABLE") {
featureProperties.LibraryTypes.emplace(cmStateEnums::EXECUTABLE); featureAttributes.LibraryTypes.emplace(cmStateEnums::EXECUTABLE);
} else { } else {
errorMessage += cmStrCat(" ", option, '\n'); errorMessage += cmStrCat(" ", option, '\n');
break; break;
} }
} }
// Always add UNKNOWN type // Always add UNKNOWN type
featureProperties.LibraryTypes.emplace( featureAttributes.LibraryTypes.emplace(
cmStateEnums::UNKNOWN_LIBRARY); cmStateEnums::UNKNOWN_LIBRARY);
} else if (processingOption.match(1) == "UNICITY") { } else if (processingOption.match(1) == "DEDUPLICATION") {
if (processingOption.match(2) == "YES") { if (processingOption.match(2) == "YES") {
featureProperties.Unicity = LinkLibraryFeaturePropertySet::Yes; featureAttributes.Deduplication =
LinkLibraryFeatureAttributeSet::Yes;
} else if (processingOption.match(2) == "NO") { } else if (processingOption.match(2) == "NO") {
featureProperties.Unicity = LinkLibraryFeaturePropertySet::No; featureAttributes.Deduplication =
LinkLibraryFeatureAttributeSet::No;
} else if (processingOption.match(2) == "DEFAULT") { } else if (processingOption.match(2) == "DEFAULT") {
featureProperties.Unicity = LinkLibraryFeaturePropertySet::Default; featureAttributes.Deduplication =
LinkLibraryFeatureAttributeSet::Default;
} else { } else {
errorMessage += cmStrCat(" ", option, '\n'); errorMessage += cmStrCat(" ", option, '\n');
} }
} else if (processingOption.match(1) == "OVERRIDE") { } else if (processingOption.match(1) == "OVERRIDE") {
featureProperties.Override.clear(); featureAttributes.Override.clear();
auto values = cmTokenize(processingOption.match(2), ","_s); auto values = cmTokenize(processingOption.match(2), ","_s);
featureProperties.Override.insert(values.begin(), values.end()); featureAttributes.Override.insert(values.begin(), values.end());
} }
} else { } else {
errorMessage += cmStrCat(" ", option, '\n'); errorMessage += cmStrCat(" ", option, '\n');
@ -298,14 +302,14 @@ const LinkLibraryFeaturePropertySet& GetLinkLibraryFeatureProperties(
if (!errorMessage.empty()) { if (!errorMessage.empty()) {
makefile->GetCMakeInstance()->IssueMessage( makefile->GetCMakeInstance()->IssueMessage(
MessageType::FATAL_ERROR, MessageType::FATAL_ERROR,
cmStrCat("Erroneous option(s) for '", featurePropertiesVariable, cmStrCat("Erroneous option(s) for '", featureAttributesVariable,
"':\n", errorMessage)); "':\n", errorMessage));
} }
return LinkLibraryFeatureProperties.emplace(feature, featureProperties) return LinkLibraryFeatureAttributes.emplace(feature, featureAttributes)
.first->second; .first->second;
} }
return LinkLibraryFeatureProperties return LinkLibraryFeatureAttributes
.emplace(feature, LinkLibraryFeaturePropertySet{}) .emplace(feature, LinkLibraryFeatureAttributeSet{})
.first->second; .first->second;
} }
@ -376,8 +380,10 @@ public:
case cmPolicies::NEW: { case cmPolicies::NEW: {
if (auto libProcessing = makefile->GetDefinition(cmStrCat( if (auto libProcessing = makefile->GetDefinition(cmStrCat(
"CMAKE_", linkLanguage, "_LINK_LIBRARIES_PROCESSING"))) { "CMAKE_", linkLanguage, "_LINK_LIBRARIES_PROCESSING"))) {
// UNICITY keyword is just for compatibility with previous
// implementation
cmsys::RegularExpression processingOption{ cmsys::RegularExpression processingOption{
"^(ORDER|UNICITY)=(FORWARD|REVERSE|ALL|NONE|SHARED)$" "^(ORDER|UNICITY|DEDUPLICATION)=(FORWARD|REVERSE|ALL|NONE|SHARED)$"
}; };
std::string errorMessage; std::string errorMessage;
for (auto const& option : cmList{ libProcessing }) { for (auto const& option : cmList{ libProcessing }) {
@ -390,13 +396,14 @@ public:
} else { } else {
errorMessage += cmStrCat(" ", option, '\n'); errorMessage += cmStrCat(" ", option, '\n');
} }
} else if (processingOption.match(1) == "UNICITY") { } else if (processingOption.match(1) == "UNICITY" ||
processingOption.match(1) == "DEDUPLICATION") {
if (processingOption.match(2) == "ALL") { if (processingOption.match(2) == "ALL") {
this->Unicity = All; this->Deduplication = All;
} else if (processingOption.match(2) == "NONE") { } else if (processingOption.match(2) == "NONE") {
this->Unicity = None; this->Deduplication = None;
} else if (processingOption.match(2) == "SHARED") { } else if (processingOption.match(2) == "SHARED") {
this->Unicity = Shared; this->Deduplication = Shared;
} else { } else {
errorMessage += cmStrCat(" ", option, '\n'); errorMessage += cmStrCat(" ", option, '\n');
} }
@ -499,7 +506,7 @@ private:
Reverse Reverse
}; };
enum UnicityKind enum DeduplicationKind
{ {
None, None,
Shared, Shared,
@ -509,22 +516,23 @@ private:
bool IncludeEntry(LinkEntry const& entry) const bool IncludeEntry(LinkEntry const& entry) const
{ {
if (entry.Feature != cmComputeLinkDepends::LinkEntry::DEFAULT) { if (entry.Feature != cmComputeLinkDepends::LinkEntry::DEFAULT) {
auto const& featureProperties = GetLinkLibraryFeatureProperties( auto const& featureAttributes = GetLinkLibraryFeatureAttributes(
this->Target->Makefile, this->LinkLanguage, entry.Feature); this->Target->Makefile, this->LinkLanguage, entry.Feature);
if ((entry.Target == nullptr || if ((entry.Target == nullptr ||
featureProperties.LibraryTypes.find(entry.Target->GetType()) != featureAttributes.LibraryTypes.find(entry.Target->GetType()) !=
featureProperties.LibraryTypes.end()) && featureAttributes.LibraryTypes.end()) &&
featureProperties.Unicity != featureAttributes.Deduplication !=
LinkLibraryFeaturePropertySet::Default) { LinkLibraryFeatureAttributeSet::Default) {
return featureProperties.Unicity == LinkLibraryFeaturePropertySet::No; return featureAttributes.Deduplication ==
LinkLibraryFeatureAttributeSet::No;
} }
} }
return this->Unicity == None || return this->Deduplication == None ||
(this->Unicity == Shared && (this->Deduplication == Shared &&
(entry.Target == nullptr || (entry.Target == nullptr ||
entry.Target->GetType() != cmStateEnums::SHARED_LIBRARY)) || entry.Target->GetType() != cmStateEnums::SHARED_LIBRARY)) ||
(this->Unicity == All && entry.Kind != LinkEntry::Library); (this->Deduplication == All && entry.Kind != LinkEntry::Library);
} }
template <typename Range> template <typename Range>
@ -539,7 +547,7 @@ private:
} }
OrderKind Order = Reverse; OrderKind Order = Reverse;
UnicityKind Unicity = Shared; DeduplicationKind Deduplication = Shared;
const cmGeneratorTarget* Target; const cmGeneratorTarget* Target;
const std::string& LinkLanguage; const std::string& LinkLanguage;
EntryVector& Entries; EntryVector& Entries;
@ -1121,27 +1129,29 @@ void cmComputeLinkDepends::AddLinkEntries(size_t depender_index,
" library '", entry.Item.Value, "'."), " library '", entry.Item.Value, "'."),
this->Target->GetBacktrace()); this->Target->GetBacktrace());
} }
// check if feature is applicable to this item
if (itemFeature != LinkEntry::DEFAULT && entry.Target != nullptr) {
auto const& featureAttributes = GetLinkLibraryFeatureAttributes(
this->Makefile, this->LinkLanguage, itemFeature);
if (featureAttributes.LibraryTypes.find(entry.Target->GetType()) ==
featureAttributes.LibraryTypes.end()) {
supportedItem = false;
this->CMakeInstance->IssueMessage(
MessageType::AUTHOR_WARNING,
cmStrCat("The feature '", itemFeature,
"', specified as part of a generator-expression "
"'$<LINK_LIBRARY:",
itemFeature, ">', will not be applied to the ",
cmState::GetTargetTypeName(entry.Target->GetType()), " '",
entry.Item.Value, "'."),
this->Target->GetBacktrace());
}
}
if (ale.second) { if (ale.second) {
// current item not yet defined // current item not yet defined
entry.Feature = itemFeature; entry.Feature = itemFeature;
if (!supportedItem) {
if (itemFeature != LinkEntry::DEFAULT && entry.Target != nullptr) { entry.Feature = LinkEntry::DEFAULT;
auto const& featureProperties = GetLinkLibraryFeatureProperties(
this->Makefile, this->LinkLanguage, itemFeature);
if (featureProperties.LibraryTypes.find(entry.Target->GetType()) ==
featureProperties.LibraryTypes.end()) {
supportedItem = false;
entry.Feature = LinkEntry::DEFAULT;
this->CMakeInstance->IssueMessage(
MessageType::AUTHOR_WARNING,
cmStrCat("The feature '", itemFeature,
"', specified as part of a generator-expression "
"'$<LINK_LIBRARY:",
itemFeature, ">', will not be applied to the ",
cmState::GetTargetTypeName(entry.Target->GetType()), " '",
entry.Item.Value, "'."),
this->Target->GetBacktrace());
}
} }
} }
@ -1170,38 +1180,50 @@ void cmComputeLinkDepends::AddLinkEntries(size_t depender_index,
if (entry.Feature != itemFeature) { if (entry.Feature != itemFeature) {
bool incompatibleFeatures = true; bool incompatibleFeatures = true;
// check if an override is possible // check if an override is possible
auto const& entryFeatureProperties = GetLinkLibraryFeatureProperties( auto const& entryFeatureAttributes = GetLinkLibraryFeatureAttributes(
this->Makefile, this->LinkLanguage, entry.Feature); this->Makefile, this->LinkLanguage, entry.Feature);
auto const& itemFeatureProperties = GetLinkLibraryFeatureProperties( auto const& itemFeatureAttributes = GetLinkLibraryFeatureAttributes(
this->Makefile, this->LinkLanguage, itemFeature); this->Makefile, this->LinkLanguage, itemFeature);
if (entryFeatureProperties.Override.empty() && if (itemFeatureAttributes.Override.find(entry.Feature) !=
!itemFeatureProperties.Override.empty() && itemFeatureAttributes.Override.end() &&
itemFeatureProperties.Override.find(entry.Feature) != entryFeatureAttributes.Override.find(itemFeature) !=
itemFeatureProperties.Override.end()) { entryFeatureAttributes.Override.end()) {
entry.Feature = itemFeature; // features override each other
incompatibleFeatures = false;
} else if (!entryFeatureProperties.Override.empty() &&
itemFeatureProperties.Override.empty() &&
entryFeatureProperties.Override.find(itemFeature) !=
entryFeatureProperties.Override.end()) {
incompatibleFeatures = false;
}
if (incompatibleFeatures) {
// incompatibles features occurred
this->CMakeInstance->IssueMessage( this->CMakeInstance->IssueMessage(
MessageType::FATAL_ERROR, MessageType::FATAL_ERROR,
cmStrCat("Impossible to link target '", this->Target->GetName(), cmStrCat("Impossible to link target '", this->Target->GetName(),
"' because the link item '", entry.Item.Value, "' because the link item '", entry.Item.Value,
"', specified ", "' is specified with the features '", itemFeature,
(itemFeature == LinkEntry::DEFAULT "' and '", entry.Feature, "'",
? "without any feature or 'DEFAULT' feature" ", and both have an 'OVERRIDE' attribute that overrides "
: cmStrCat("with the feature '", itemFeature, '\'')), "the other. Such cycles are not allowed."),
", has already occurred ",
(entry.Feature == LinkEntry::DEFAULT
? "without any feature or 'DEFAULT' feature"
: cmStrCat("with the feature '", entry.Feature, '\'')),
", which is not allowed."),
this->Target->GetBacktrace()); this->Target->GetBacktrace());
} else {
if (itemFeatureAttributes.Override.find(entry.Feature) !=
itemFeatureAttributes.Override.end()) {
entry.Feature = itemFeature;
incompatibleFeatures = false;
} else if (entryFeatureAttributes.Override.find(itemFeature) !=
entryFeatureAttributes.Override.end()) {
incompatibleFeatures = false;
}
if (incompatibleFeatures) {
// incompatibles features occurred
this->CMakeInstance->IssueMessage(
MessageType::FATAL_ERROR,
cmStrCat(
"Impossible to link target '", this->Target->GetName(),
"' because the link item '", entry.Item.Value, "', specified ",
(itemFeature == LinkEntry::DEFAULT
? "without any feature or 'DEFAULT' feature"
: cmStrCat("with the feature '", itemFeature, '\'')),
", has already occurred ",
(entry.Feature == LinkEntry::DEFAULT
? "without any feature or 'DEFAULT' feature"
: cmStrCat("with the feature '", entry.Feature, '\'')),
", which is not allowed."),
this->Target->GetBacktrace());
}
} }
} }
} }

15
Tests/RunCMake/GenEx-LINK_LIBRARY/RunCMakeTest.cmake
View File

@ -36,9 +36,12 @@ run_cmake(override-features3)
run_cmake(override-features4) run_cmake(override-features4)
run_cmake(override-features5) run_cmake(override-features5)
# testing feature properties specification # testing feature attributes specification
run_cmake(bad-feature-properties1) run_cmake(bad-feature-attributes1)
run_cmake(bad-feature-properties2) run_cmake(bad-feature-attributes2)
run_cmake(bad-feature-properties3) run_cmake(bad-feature-attributes3)
run_cmake(bad-feature-properties4) run_cmake(bad-feature-attributes4)
run_cmake(bad-feature-properties5) run_cmake(bad-feature-attributes5)
run_cmake(unsupported-library_type)
run_cmake(cyclic-override)
run_cmake(multiple-override)

0
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties1-result.txt → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes1-result.txt
View File

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes1-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_ATTRIBUTES':
BAD_ATTRIBUTE=XXX

2
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties5.cmake → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes1.cmake
View File

@ -2,7 +2,7 @@ enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature_PROPERTIES UNICITY=YES,NO) set(CMAKE_LINK_LIBRARY_feature_ATTRIBUTES BAD_ATTRIBUTE=XXX)
add_library(dep SHARED empty.c) add_library(dep SHARED empty.c)

0
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties2-result.txt → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes2-result.txt
View File

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes2-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_ATTRIBUTES':
BAD_ATTRIBUTE=XXX

2
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties2.cmake → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes2.cmake
View File

@ -2,7 +2,7 @@ enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature_PROPERTIES LIBRARY_TYPE=STATIC BAD_PROPERTY=XXX UNICITY=YES) set(CMAKE_LINK_LIBRARY_feature_ATTRIBUTES LIBRARY_TYPE=STATIC BAD_ATTRIBUTE=XXX DEDUPLICATION=YES)
add_library(dep SHARED empty.c) add_library(dep SHARED empty.c)

0
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties3-result.txt → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes3-result.txt
View File

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes3-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_ATTRIBUTES':
LIBRARY_TYPE=STATIC,BAD_TYPE

2
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties3.cmake → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes3.cmake
View File

@ -2,7 +2,7 @@ enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature_PROPERTIES LIBRARY_TYPE=STATIC,BAD_TYPE) set(CMAKE_LINK_LIBRARY_feature_ATTRIBUTES LIBRARY_TYPE=STATIC,BAD_TYPE)
add_library(dep SHARED empty.c) add_library(dep SHARED empty.c)

0
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties4-result.txt → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes4-result.txt
View File

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes4-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_ATTRIBUTES':
LIBRARY_TYPE=STATIC,BAD_TYPE

10
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes4.cmake Normal file
View File

@ -0,0 +1,10 @@
enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature_ATTRIBUTES DEDUPLICATION=YES LIBRARY_TYPE=STATIC,BAD_TYPE)
add_library(dep SHARED empty.c)
add_library(lib SHARED empty.c)
target_link_libraries(lib PRIVATE "$<LINK_LIBRARY:feature,dep>")

0
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties5-result.txt → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes5-result.txt
View File

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes5-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_ATTRIBUTES':
DEDUPLICATION=YES,NO

2
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties4.cmake → Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-attributes5.cmake
View File

@ -2,7 +2,7 @@ enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature_PROPERTIES UNICITY=YES LIBRARY_TYPE=STATIC,BAD_TYPE) set(CMAKE_LINK_LIBRARY_feature_ATTRIBUTES DEDUPLICATION=YES,NO)
add_library(dep SHARED empty.c) add_library(dep SHARED empty.c)

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties1-stderr.txt
View File

@ -1,4 +0,0 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_PROPERTIES':
BAD_PROPERTY=XXX

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties2-stderr.txt
View File

@ -1,4 +0,0 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_PROPERTIES':
BAD_PROPERTY=XXX

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties3-stderr.txt
View File

@ -1,4 +0,0 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_PROPERTIES':
LIBRARY_TYPE=STATIC,BAD_TYPE

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties4-stderr.txt
View File

@ -1,4 +0,0 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_PROPERTIES':
LIBRARY_TYPE=STATIC,BAD_TYPE

4
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties5-stderr.txt
View File

@ -1,4 +0,0 @@
CMake Error:
Erroneous option\(s\) for 'CMAKE_LINK_LIBRARY_feature_PROPERTIES':
UNICITY=YES,NO

0
Tests/RunCMake/LinkLibrariesProcessing/Invalid_UNICITY-result.txt → Tests/RunCMake/GenEx-LINK_LIBRARY/cyclic-override-result.txt
View File

6
Tests/RunCMake/GenEx-LINK_LIBRARY/cyclic-override-stderr.txt Normal file
View File

@ -0,0 +1,6 @@
CMake Error at cyclic-override.cmake:[0-9]+ \(add_library\):
Impossible to link target 'lib' because the link item 'dep' is specified
with the features 'feature2' and 'feature1', and both have an 'OVERRIDE'
attribute that overrides the other. Such cycles are not allowed.
Call Stack \(most recent call first\):
CMakeLists.txt:[0-9]+ \(include\)

14
Tests/RunCMake/GenEx-LINK_LIBRARY/cyclic-override.cmake Normal file
View File

@ -0,0 +1,14 @@
enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature1 "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature1_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature1_ATTRIBUTES OVERRIDE=feature2)
set(CMAKE_LINK_LIBRARY_USING_feature2 "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature2_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature2_ATTRIBUTES OVERRIDE=feature1)
add_library(dep SHARED empty.c)
add_library(lib SHARED empty.c)
target_link_libraries(lib PRIVATE "$<LINK_LIBRARY:feature1,dep>" "$<LINK_LIBRARY:feature2,dep>")

2
Tests/RunCMake/GenEx-LINK_LIBRARY/library-ignored.cmake
View File

@ -2,7 +2,7 @@ enable_language(C)
set(CMAKE_C_LINK_LIBRARY_USING_feat_SUPPORTED TRUE) set(CMAKE_C_LINK_LIBRARY_USING_feat_SUPPORTED TRUE)
set(CMAKE_C_LINK_LIBRARY_USING_feat "<LIBRARY>") set(CMAKE_C_LINK_LIBRARY_USING_feat "<LIBRARY>")
set(CMAKE_C_LINK_LIBRARY_feat_PROPERTIES "LIBRARY_TYPE=STATIC") set(CMAKE_C_LINK_LIBRARY_feat_ATTRIBUTES "LIBRARY_TYPE=STATIC")
add_library(dep OBJECT empty.c) add_library(dep OBJECT empty.c)

14
Tests/RunCMake/GenEx-LINK_LIBRARY/multiple-override.cmake Normal file
View File

@ -0,0 +1,14 @@
enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature1 "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature1_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature1_ATTRIBUTES OVERRIDE=feature2)
set(CMAKE_LINK_LIBRARY_USING_feature2 "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature2_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature2_ATTRIBUTES OVERRIDE=feature3)
add_library(dep SHARED empty.c)
add_library(lib SHARED empty.c)
target_link_libraries(lib PRIVATE "$<LINK_LIBRARY:feature1,dep>" "$<LINK_LIBRARY:feature2,dep>")

6
Tests/RunCMake/GenEx-LINK_LIBRARY/unsupported-library_type-stderr.txt Normal file
View File

@ -0,0 +1,6 @@
CMake Warning \(dev\) at unsupported-library_type.cmake:[0-9]+ \(add_library\):
The feature 'feature', specified as part of a generator-expression
'\$<LINK_LIBRARY:feature>', will not be applied to the SHARED_LIBRARY 'dep'.
Call Stack \(most recent call first\):
CMakeLists.txt:[0-9]+ \(include\)
This warning is for project developers. Use -Wno-dev to suppress it.

2
Tests/RunCMake/GenEx-LINK_LIBRARY/bad-feature-properties1.cmake → Tests/RunCMake/GenEx-LINK_LIBRARY/unsupported-library_type.cmake
View File

@ -2,7 +2,7 @@ enable_language(C)
set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>") set(CMAKE_LINK_LIBRARY_USING_feature "<LIBRARY>")
set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE) set(CMAKE_LINK_LIBRARY_USING_feature_SUPPORTED TRUE)
set(CMAKE_LINK_LIBRARY_feature_PROPERTIES BAD_PROPERTY=XXX) set(CMAKE_LINK_LIBRARY_feature_ATTRIBUTES LIBRARY_TYPE=STATIC)
add_library(dep SHARED empty.c) add_library(dep SHARED empty.c)

2
Tests/RunCMake/LinkLibrariesProcessing/InvalidConfiguration1.cmake
View File

@ -1,7 +1,7 @@
enable_language(C) enable_language(C)
set(CMAKE_C_LINK_LIBRARIES_PROCESSING ORDER= UNICITY=ALL) set(CMAKE_C_LINK_LIBRARIES_PROCESSING ORDER= DEDUPLICATION=ALL)
add_library(lib STATIC lib.c) add_library(lib STATIC lib.c)

2
Tests/RunCMake/LinkLibrariesProcessing/InvalidConfiguration2.cmake
View File

@ -1,7 +1,7 @@
enable_language(C) enable_language(C)
set(CMAKE_C_LINK_LIBRARIES_PROCESSING UNICITY=ALL ORDER) set(CMAKE_C_LINK_LIBRARIES_PROCESSING DEDUPLICATION=ALL ORDER)
add_library(lib STATIC lib.c) add_library(lib STATIC lib.c)

2
Tests/RunCMake/LinkLibrariesProcessing/InvalidConfiguration3.cmake
View File

@ -1,7 +1,7 @@
enable_language(C) enable_language(C)
set(CMAKE_C_LINK_LIBRARIES_PROCESSING WRONG=REVERSE UNICITY=ALL) set(CMAKE_C_LINK_LIBRARIES_PROCESSING WRONG=REVERSE DEDUPLICATION=ALL)
add_library(lib STATIC lib.c) add_library(lib STATIC lib.c)

2
Tests/RunCMake/LinkLibrariesProcessing/InvalidConfiguration4-stderr.txt
View File

@ -2,7 +2,7 @@ CMake Error at InvalidConfiguration4.cmake:[0-9]+ \(add_executable\):
Erroneous option\(s\) for 'CMAKE_C_LINK_LIBRARIES_PROCESSING': Erroneous option\(s\) for 'CMAKE_C_LINK_LIBRARIES_PROCESSING':
WRONG=REVERSE WRONG=REVERSE
UNICITY=WRONG DEDUPLICATION=WRONG
Call Stack \(most recent call first\): Call Stack \(most recent call first\):
CMakeLists.txt:[0-9]+ \(include\) CMakeLists.txt:[0-9]+ \(include\)

2
Tests/RunCMake/LinkLibrariesProcessing/InvalidConfiguration4.cmake
View File

@ -1,7 +1,7 @@
enable_language(C) enable_language(C)
set(CMAKE_C_LINK_LIBRARIES_PROCESSING WRONG=REVERSE UNICITY=WRONG) set(CMAKE_C_LINK_LIBRARIES_PROCESSING WRONG=REVERSE DEDUPLICATION=WRONG)
add_library(lib STATIC lib.c) add_library(lib STATIC lib.c)

1
Tests/RunCMake/LinkLibrariesProcessing/Invalid_DEDUPLICATION-result.txt Normal file
View File

@ -0,0 +1 @@
1

4
Tests/RunCMake/LinkLibrariesProcessing/Invalid_UNICITY-stderr.txt → Tests/RunCMake/LinkLibrariesProcessing/Invalid_DEDUPLICATION-stderr.txt
View File

@ -1,7 +1,7 @@
CMake Error at Invalid_UNICITY.cmake:[0-9]+ \(add_executable\): CMake Error at Invalid_DEDUPLICATION.cmake:[0-9]+ \(add_executable\):
Erroneous option\(s\) for 'CMAKE_C_LINK_LIBRARIES_PROCESSING': Erroneous option\(s\) for 'CMAKE_C_LINK_LIBRARIES_PROCESSING':
UNICITY=WRONG DEDUPLICATION=WRONG
Call Stack \(most recent call first\): Call Stack \(most recent call first\):
CMakeLists.txt:[0-9]+ \(include\) CMakeLists.txt:[0-9]+ \(include\)

2
Tests/RunCMake/LinkLibrariesProcessing/Invalid_UNICITY.cmake → Tests/RunCMake/LinkLibrariesProcessing/Invalid_DEDUPLICATION.cmake
View File

@ -1,7 +1,7 @@
enable_language(C) enable_language(C)
set(CMAKE_C_LINK_LIBRARIES_PROCESSING ORDER=REVERSE UNICITY=WRONG) set(CMAKE_C_LINK_LIBRARIES_PROCESSING ORDER=REVERSE DEDUPLICATION=WRONG)
add_library(lib STATIC lib.c) add_library(lib STATIC lib.c)

2
Tests/RunCMake/LinkLibrariesProcessing/Invalid_ORDER.cmake
View File

@ -1,7 +1,7 @@
enable_language(C) enable_language(C)
set(CMAKE_C_LINK_LIBRARIES_PROCESSING ORDER=WRONG UNICITY=ALL) set(CMAKE_C_LINK_LIBRARIES_PROCESSING ORDER=WRONG DEDUPLICATION=ALL)
add_library(lib STATIC lib.c) add_library(lib STATIC lib.c)

2
Tests/RunCMake/LinkLibrariesProcessing/RunCMakeTest.cmake
View File

@ -1,7 +1,7 @@
include(RunCMake) include(RunCMake)
run_cmake(Invalid_ORDER) run_cmake(Invalid_ORDER)
run_cmake(Invalid_UNICITY) run_cmake(Invalid_DEDUPLICATION)
run_cmake(InvalidConfiguration1) run_cmake(InvalidConfiguration1)
run_cmake(InvalidConfiguration2) run_cmake(InvalidConfiguration2)
run_cmake(InvalidConfiguration3) run_cmake(InvalidConfiguration3)