1CMAKE-POLICIES(7) CMake CMAKE-POLICIES(7)
2
6 cmake-policies - CMake Policies Reference
7
9 Policies in CMake are used to preserve backward compatible behavior
10 across multiple releases. When a new policy is introduced, newer CMake
11 versions will begin to warn about the backward compatible behavior. It
12 is possible to disable the warning by explicitly requesting the OLD, or
13 backward compatible behavior using the cmake_policy() command. It is
14 also possible to request NEW, or non-backward compatible behavior for a
15 policy, also avoiding the warning. Each policy can also be set to
16 either NEW or OLD behavior explicitly on the command line with the
17 CMAKE_POLICY_DEFAULT_CMP<NNNN> variable.
18 A policy is a deprecation mechanism and not a reliable feature toggle.
20 A policy should almost never be set to OLD, except to silence warnings
21 in an otherwise frozen or stable codebase, or temporarily as part of a
22 larger migration path. The OLD behavior of each policy is undesirable
23 and will be replaced with an error condition in a future release.
24 The cmake_minimum_required() command does more than report an error if
26 a too-old version of CMake is used to build a project. It also sets
27 all policies introduced in that CMake version or earlier to NEW behav‐
28 ior. To manage policies without increasing the minimum required CMake
29 version, the if(POLICY) command may be used:
30 if(POLICY CMP0990)
32 cmake_policy(SET CMP0990 NEW)
33 endif()
34 This has the effect of using the NEW behavior with newer CMake releases
36 which users may be using and not issuing a compatibility warning.
37 The setting of a policy is confined in some cases to not propagate to
39 the parent scope. For example, if the files read by the include() com‐
40 mand or the find_package() command contain a use of cmake_policy(),
41 that policy setting will not affect the caller by default. Both com‐
42 mands accept an optional NO_POLICY_SCOPE keyword to control this behav‐
43 ior.
44 The CMAKE_MINIMUM_REQUIRED_VERSION variable may also be used to deter‐
46 mine whether to report an error on use of deprecated macros or func‐
47 tions.
48
50 CMP0102
51 The mark_as_advanced() command no longer creates a cache entry if one
52 does not already exist.
53 In CMake 3.16 and below, if a variable was not defined at all or just
55 defined locally, the mark_as_advanced() command would create a new
56 cache entry with an UNINITIALIZED type and no value. When a find_path()
57 (or other similar find_ command) would next run, it would find this
58 undefined cache entry and set it up with an empty string value. This
59 process would end up deleting the local variable in the process (due to
60 the way the cache works), effectively clearing any stored find_ results
61 that were only available in the local scope.
62 The OLD behavior for this policy is to create the empty cache defini‐
64 tion. The NEW behavior of this policy is to ignore variables which do
65 not already exist in the cache.
66 This policy was introduced in CMake version 3.17. Use the cmake_pol‐
68 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
69 cies, CMake version 3.17.2 does not warn when this policy is not set
70 and simply uses OLD behavior.
71 NOTE:
73 The OLD behavior of a policy is deprecated by definition and may be
74 removed in a future version of CMake.
75 CMP0101
77 target_compile_options() now honors BEFORE keyword in all scopes.
78 In CMake 3.16 and below the target_compile_options() ignores the BEFORE
80 keyword in private scope. CMake 3.17 and later honors BEFORE keyword in
81 all scopes. This policy provides compatibility for projects that have
82 not been updated to expect the new behavior.
83 The OLD behavior for this policy is to not honor BEFORE keyword in pri‐
85 vate scope. The NEW behavior of this policy is to honor BEFORE keyword
86 in all scopes.
87 This policy was introduced in CMake version 3.17. Use the cmake_pol‐
89 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
90 cies, CMake version 3.17.2 does not warn when this policy is not set
91 and simply uses OLD behavior.
92 NOTE:
94 The OLD behavior of a policy is deprecated by definition and may be
95 removed in a future version of CMake.
96 CMP0100
98 Let AUTOMOC and AUTOUIC process header files that end with a .hh exten‐
99 sion.
100 Since version 3.17, CMake processes header files that end with a .hh
102 extension in AUTOMOC and AUTOUIC. In earlier CMake versions, these
103 header files were ignored by AUTOMOC and AUTOUIC.
104 This policy affects how header files that end with a .hh extension get
106 treated in AUTOMOC and AUTOUIC.
107 The OLD behavior for this policy is to ignore .hh header files in AUTO‐
109 MOC and AUTOUIC.
110 The NEW behavior for this policy is to process .hh header files in
112 AUTOMOC and AUTOUIC just like other header files.
113 NOTE:
115 To silence the CMP0100 warning source files can be excluded from
116 AUTOMOC and AUTOUIC processing by setting the source file properties
117 SKIP_AUTOMOC, SKIP_AUTOUIC or SKIP_AUTOGEN.
118 # Source skip example:
120 set_property(SOURCE /path/to/file1.hh PROPERTY SKIP_AUTOMOC ON)
121 set_property(SOURCE /path/to/file2.hh PROPERTY SKIP_AUTOUIC ON)
122 set_property(SOURCE /path/to/file3.hh PROPERTY SKIP_AUTOGEN ON)
123 This policy was introduced in CMake version 3.17.0. CMake version
125 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
126 cmake_policy() command to set it to OLD or NEW explicitly.
127 NOTE:
129 The OLD behavior of a policy is deprecated by definition and may be
130 removed in a future version of CMake.
131 CMP0099
133 Target link properties INTERFACE_LINK_OPTIONS, INTERFACE_LINK_DIRECTO‐
134 RIES and INTERFACE_LINK_DEPENDS are now transitive over private depen‐
135 dencies of static libraries.
136 In CMake 3.16 and below the interface link properties attached to
138 libraries are not propagated for private dependencies of static
139 libraries. Only the libraries themselves are propagated to link the
140 dependent binary. CMake 3.17 and later prefer to propagate all inter‐
141 face link properties. This policy provides compatibility for projects
142 that have not been updated to expect the new behavior.
143 The OLD behavior for this policy is to not propagate interface link
145 properties. The NEW behavior of this policy is to propagate interface
146 link properties.
147 This policy was introduced in CMake version 3.17. Use the cmake_pol‐
149 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
150 cies, CMake version 3.17.2 does not warn when this policy is not set
151 and simply uses OLD behavior.
152 NOTE:
154 The OLD behavior of a policy is deprecated by definition and may be
155 removed in a future version of CMake.
156 CMP0098
158 FindFLEX runs flex in directory CMAKE_CURRENT_BINARY_DIR when execut‐
159 ing.
160 The module provides a FLEX_TARGET macro which generates FLEX output.
162 In CMake 3.16 and below the macro would generate a custom command that
163 runs flex in the current source directory. CMake 3.17 and later prefer
164 to run it in the build directory and use CMAKE_CURRENT_BINARY_DIR as
165 the WORKING_DIRECTORY of its add_custom_command() invocation. This
166 ensures that any implicitly generated file is written relative to the
167 build tree rather than the source tree, unless the generated file is
168 provided as absolute path.
169 This policy provides compatibility for projects that have not been
171 updated to expect the new behavior.
172 The OLD behavior for this policy is for FLEX_TARGET to use the current
174 source directory for the WORKING_DIRECTORY and where to generate
175 implicit files. The NEW behavior of this policy is to use the current
176 binary directory for the WORKING_DIRECTORY relative to which implicit
177 files are generated unless provided as absolute path.
178 This policy was introduced in CMake version 3.17. Use the cmake_pol‐
180 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
181 cies, CMake version 3.17.2 does not warn when this policy is not set
182 and simply uses OLD behavior.
183 NOTE:
185 The OLD behavior of a policy is deprecated by definition and may be
186 removed in a future version of CMake.
187
189 CMP0097
190 ExternalProject_Add() with GIT_SUBMODULES "" initializes no submodules.
191 The module provides a GIT_SUBMODULES option which controls what submod‐
193 ules to initialize and update. Starting with CMake 3.16, explicitly
194 setting GIT_SUBMODULES to an empty string means no submodules will be
195 initialized or updated.
196 This policy provides compatibility for projects that have not been
198 updated to expect the new behavior.
199 The OLD behavior for this policy is for GIT_SUBMODULES when set to an
201 empty string to initialize and update all git submodules. The NEW
202 behavior for this policy is for GIT_SUBMODULES when set to an empty
203 string to initialize and update no git submodules.
204 This policy was introduced in CMake version 3.16. Use the cmake_pol‐
206 icy() command to set it to OLD or NEW explicitly. Unlike most poli‐
207 cies, CMake version 3.17.2 does not warn when this policy is not set
208 and simply uses OLD behavior.
209 CMP0096
211 The project() command preserves leading zeros in version components.
212 When a VERSION <major>[.<minor>[.<patch>[.<tweak>]]]] argument is given
214 to the project() command, it stores the version string in the
215 PROJECT_VERSION variable and stores individual integer version compo‐
216 nents in PROJECT_VERSION_{MAJOR,MINOR,PATCH,TWEAK} variables (see pol‐
217 icy CMP0048). CMake 3.15 and below dropped leading zeros from each
218 component. CMake 3.16 and higher prefer to preserve leading zeros.
219 This policy provides compatibility for projects that have not been
220 updated to expect the new behavior.
221 The OLD behavior of this policy drops leading zeros in all components,
223 e.g. such that version 1.07.06 becomes 1.7.6. The NEW behavior of
224 this policy preserves the leading zeros in all components, such that
225 version 1.07.06 remains unchanged.
226 This policy was introduced in CMake version 3.16. Unlike many poli‐
228 cies, CMake version 3.17.2 does not warn when this policy is not set
229 and simply uses the OLD behavior. Use the cmake_policy() command to
230 set it to OLD or NEW explicitly.
231 NOTE:
233 The OLD behavior of a policy is deprecated by definition and may be
234 removed in a future version of CMake.
235 CMP0095
237 RPATH entries are properly escaped in the intermediary CMake install
238 script.
239 In CMake 3.15 and earlier, RPATH entries set via CMAKE_INSTALL_RPATH or
241 via INSTALL_RPATH have not been escaped before being inserted into the
242 cmake_install.cmake script. Dynamic linkers on ELF-based systems (e.g.
243 Linux and FreeBSD) allow certain keywords in RPATH entries, such as
244 ${ORIGIN} (More details are available in the ld.so man pages on those
245 systems). The syntax of these keywords can match CMake’s variable syn‐
246 tax. In order to not be substituted (usually to an empty string)
247 already by the intermediary cmake_install.cmake script, the user had to
248 double-escape such RPATH keywords, e.g. set(CMAKE_INSTALL_RPATH
249 "\\\${ORIGIN}/../lib"). Since the intermediary cmake_install.cmake
250 script is an implementation detail of CMake, CMake 3.16 and later will
251 make sure RPATH entries are inserted literally by escaping any coinci‐
252 dental CMake syntax.
253 The OLD behavior of this policy is to not escape RPATH entries in the
255 intermediary cmake_install.cmake script. The NEW behavior is to prop‐
256 erly escape coincidental CMake syntax in RPATH entries when generating
257 the intermediary cmake_install.cmake script.
258 This policy was introduced in CMake version 3.16. CMake version 3.17.2
260 warns when the policy is not set and detected usage of CMake-like syn‐
261 tax and uses OLD behavior. Use the cmake_policy() command to set it to
262 OLD or NEW explicitly.
263 NOTE:
265 The OLD behavior of a policy is deprecated by definition and may be
266 removed in a future version of CMake.
267
269 CMP0094
270 Modules FindPython3, FindPython2 and FindPython use LOCATION for lookup
271 strategy.
272 Starting with CMake 3.15, Modules FindPython3, FindPython2 and Find‐
274 Python set value LOCATION for, respectively, variables
275 Python3_FIND_STRATEGY, Python2_FIND_STRATEGY and Python_FIND_STRATEGY.
276 This policy provides compatibility with projects that expect the legacy
277 behavior.
278 The OLD behavior for this policy set value VERSION for variables
280 Python3_FIND_STRATEGY, Python2_FIND_STRATEGY and Python_FIND_STRATEGY.
281 This policy was introduced in CMake version 3.15. Use the cmake_pol‐
283 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
284 cies, CMake version 3.17.2 does not warn when this policy is not set
285 and simply uses the OLD behavior.
286 NOTE:
288 The OLD behavior of a policy is deprecated by definition and may be
289 removed in a future version of CMake.
290 CMP0093
292 FindBoost reports Boost_VERSION in x.y.z format.
293 In CMake 3.14 and below the module would report the Boost version num‐
295 ber as specified in the preprocessor definition BOOST_VERSION in the
296 boost/version.hpp file. In CMake 3.15 and later it is preferred that
297 the reported version number matches the x.y.z format reported by the
298 CMake package shipped with Boost 1.70.0 and later. The macro value is
299 still reported in the Boost_VERSION_MACRO variable.
300 The OLD behavior for this policy is for FindBoost to report Boost_VER‐
302 SION as specified in the preprocessor definition BOOST_VERSION in
303 boost/version.hpp. The NEW behavior for this policy is for FindBoost to
304 report Boost_VERSION in x.y.z format.
305 This policy was introduced in CMake version 3.15. Use the cmake_pol‐
307 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
308 cies, CMake version 3.17.2 does not warn when this policy is not set
309 and simply uses the OLD behavior.
310 NOTE:
312 The OLD behavior of a policy is deprecated by definition and may be
313 removed in a future version of CMake.
314 CMP0092
316 MSVC warning flags are not in CMAKE_<LANG>_FLAGS by default.
317 When using MSVC-like compilers in CMake 3.14 and below, warning flags
319 like /W3 are added to CMAKE_<LANG>_FLAGS by default. This is problem‐
320 atic for projects that want to choose a different warning level pro‐
321 grammatically. In particular, it requires string editing of the
322 CMAKE_<LANG>_FLAGS variables with knowledge of the CMake builtin
323 defaults so they can be replaced.
324 CMake 3.15 and above prefer to leave out warning flags from the value
326 of CMAKE_<LANG>_FLAGS by default.
327 This policy provides compatibility with projects that have not been
329 updated to expect the lack of warning flags. The policy setting takes
330 effect as of the first project() or enable_language() command that ini‐
331 tializes CMAKE_<LANG>_FLAGS for a given lanuage <LANG>.
332 NOTE:
334 Once the policy has taken effect at the top of a project for a given
335 language, that choice must be used throughout the tree for that lan‐
336 guage. In projects that have nested projects in subdirectories, be
337 sure to convert everything together.
338 The OLD behavior for this policy is to place MSVC warning flags in the
340 default CMAKE_<LANG>_FLAGS cache entries. The NEW behavior for this
341 policy is to not place MSVC warning flags in the default cache entries.
342 This policy was introduced in CMake version 3.15. Use the cmake_pol‐
344 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
345 cies, CMake version 3.17.2 does not warn when this policy is not set
346 and simply uses OLD behavior.
347 NOTE:
349 The OLD behavior of a policy is deprecated by definition and may be
350 removed in a future version of CMake.
351 CMP0091
353 MSVC runtime library flags are selected by an abstraction.
354 Compilers targeting the MSVC ABI have flags to select the MSVC runtime
356 library. Runtime library selection typically varies with build config‐
357 uration because there is a separate runtime library for Debug builds.
358 In CMake 3.14 and below, MSVC runtime library selection flags are added
360 to the default CMAKE_<LANG>_FLAGS_<CONFIG> cache entries by CMake auto‐
361 matically. This allows users to edit their cache entries to adjust the
362 flags. However, the presence of such default flags is problematic for
363 projects that want to choose a different runtime library programmati‐
364 cally. In particular, it requires string editing of the
365 CMAKE_<LANG>_FLAGS_<CONFIG> variables with knowledge of the CMake
366 builtin defaults so they can be replaced.
367 CMake 3.15 and above prefer to leave the MSVC runtime library selection
369 flags out of the default CMAKE_<LANG>_FLAGS_<CONFIG> values and instead
370 offer a first-class abstraction. The CMAKE_MSVC_RUNTIME_LIBRARY vari‐
371 able and MSVC_RUNTIME_LIBRARY target property may be set to select the
372 MSVC runtime library. If they are not set then CMake uses the default
373 value MultiThreaded$<$<CONFIG:Debug>:Debug>DLL which is equivalent to
374 the original flags.
375 This policy provides compatibility with projects that have not been
377 updated to be aware of the abstraction. The policy setting takes
378 effect as of the first project() or enable_language() command that
379 enables a language whose compiler targets the MSVC ABI.
380 NOTE:
382 Once the policy has taken effect at the top of a project, that
383 choice must be used throughout the tree. In projects that have
384 nested projects in subdirectories, be sure to convert everything
385 together.
386 The OLD behavior for this policy is to place MSVC runtime library flags
388 in the default CMAKE_<LANG>_FLAGS_<CONFIG> cache entries and ignore the
389 CMAKE_MSVC_RUNTIME_LIBRARY abstraction. The NEW behavior for this pol‐
390 icy is to not place MSVC runtime library flags in the default cache
391 entries and use the abstraction instead.
392 This policy was introduced in CMake version 3.15. Use the cmake_pol‐
394 icy() command to set it to OLD or NEW explicitly. Unlike many poli‐
395 cies, CMake version 3.17.2 does not warn when this policy is not set
396 and simply uses OLD behavior.
397 NOTE:
399 The OLD behavior of a policy is deprecated by definition and may be
400 removed in a future version of CMake.
401 CMP0090
403 export(PACKAGE) does not populate package registry by default.
404 In CMake 3.14 and below the export(PACKAGE) command populated the user
406 package registry by default and users needed to set the
407 CMAKE_EXPORT_NO_PACKAGE_REGISTRY to disable it, e.g. in automated build
408 and packaging environments. Since the user package registry is stored
409 outside the build tree, this side effect should not be enabled by
410 default. Therefore CMake 3.15 and above prefer that export(PACKAGE)
411 does nothing unless an explicit CMAKE_EXPORT_PACKAGE_REGISTRY variable
412 is set to enable it. This policy provides compatibility with projects
413 that have not been updated.
414 The OLD behavior for this policy is for export(PACKAGE) command to pop‐
416 ulate the user package registry unless CMAKE_EXPORT_NO_PACKAGE_REGISTRY
417 is enabled. The NEW behavior is for export(PACKAGE) command to do
418 nothing unless the CMAKE_EXPORT_PACKAGE_REGISTRY is enabled.
419 This policy was introduced in CMake version 3.15. Use the cmake_pol‐
421 icy() command to set it to OLD or NEW explicitly. Unlike most poli‐
422 cies, CMake version 3.17.2 does not warn when this policy is not set
423 and simply uses OLD behavior.
424 NOTE:
426 The OLD behavior of a policy is deprecated by definition and may be
427 removed in a future version of CMake.
428 CMP0089
430 Compiler id for IBM Clang-based XL compilers is now XLClang.
431 CMake 3.15 and above recognize that IBM’s Clang-based XL compilers that
433 define __ibmxl__ are a new front-end distinct from xlc with a different
434 command line and set of capabilities. CMake now prefers to present
435 this to projects by setting the CMAKE_<LANG>_COMPILER_ID variable to
436 XLClang instead of XL. However, existing projects may assume the com‐
437 piler id for Clang-based XL is just XL as it was in CMake versions
438 prior to 3.15. Therefore this policy determines for Clang-based XL
439 compilers which compiler id to report in the CMAKE_<LANG>_COMPILER_ID
440 variable after language <LANG> is enabled by the project() or
441 enable_language() command. The policy must be set prior to the invoca‐
442 tion of either command.
443 The OLD behavior for this policy is to use compiler id XL. The NEW
445 behavior for this policy is to use compiler id XLClang.
446 This policy was introduced in CMake version 3.15. Use the cmake_pol‐
448 icy() command to set this policy to OLD or NEW explicitly. Unlike most
449 policies, CMake version 3.17.2 does not warn by default when this pol‐
450 icy is not set and simply uses OLD behavior. See documentation of the
451 CMAKE_POLICY_WARNING_CMP0089 variable to control the warning.
452 NOTE:
454 The OLD behavior of a policy is deprecated by definition and may be
455 removed in a future version of CMake.
456
458 CMP0088
459 FindBISON runs bison in CMAKE_CURRENT_BINARY_DIR when executing.
460 The module provides a BISON_TARGET macro which generates BISON output.
462 In CMake 3.13 and below the macro would generate a custom command that
463 runs bison in the source directory. CMake 3.14 and later prefer to run
464 it in the build directory and use CMAKE_CURRENT_BINARY_DIR as the WORK‐
465 ING_DIRECTORY of its add_custom_command() invocation. This ensures
466 that any implicitly generated file is written to the build tree rather
467 than the source.
468 This policy provides compatibility for projects that have not been
470 updated to expect the new behavior.
471 The OLD behavior for this policy is for BISON_TARGET to use the current
473 source directory for the WORKING_DIRECTORY and where to generate
474 implicit files. The NEW behavior of this policy is to use the current
475 binary directory for the WORKING_DIRECTORY and where to generate
476 implicit files.
477 This policy was introduced in CMake version 3.14. Use the cmake_pol‐
479 icy() command to set it to OLD or NEW explicitly. Unlike most poli‐
480 cies, CMake version 3.17.2 does not warn when this policy is not set
481 and simply uses OLD behavior.
482 NOTE:
484 The OLD behavior of a policy is deprecated by definition and may be
485 removed in a future version of CMake.
486 CMP0087
488 install(CODE) and install(SCRIPT) support generator expressions.
489 In CMake 3.13 and earlier, install(CODE) and install(SCRIPT) did not
491 evaluate generator expressions. CMake 3.14 and later will evaluate
492 generator expressions for install(CODE) and install(SCRIPT).
493 The OLD behavior of this policy is for install(CODE) and
495 install(SCRIPT) to not evaluate generator expressions. The NEW behav‐
496 ior is to evaluate generator expressions for install(CODE) and
497 install(SCRIPT).
498 Note that it is the value of this policy setting at the end of the
500 directory scope that is important, not its setting at the time of the
501 call to install(CODE) or install(SCRIPT). This has implications for
502 calling these commands from places that have their own policy scope but
503 not their own directory scope (e.g. from files brought in via include()
504 rather than add_subdirectory()).
505 This policy was introduced in CMake version 3.14. CMake version 3.17.2
507 warns when the policy is not set and uses OLD behavior. Use the
508 cmake_policy() command to set it to OLD or NEW explicitly.
509 NOTE:
511 The OLD behavior of a policy is deprecated by definition and may be
512 removed in a future version of CMake.
513 CMP0086
515 UseSWIG honors SWIG_MODULE_NAME via -module flag.
516 Starting with CMake 3.14, UseSWIG passes option -module <module_name>
518 to SWIG compiler if the file property SWIG_MODULE_NAME is specified.
519 This policy provides compatibility with projects that expect the legacy
520 behavior.
521 The OLD behavior for this policy is to never pass -module option. The
523 NEW behavior is to pass -module option to SWIG compiler if SWIG_MOD‐
524 ULE_NAME is specified.
525 This policy was introduced in CMake version 3.14. CMake version 3.17.2
527 warns when the policy is not set and uses OLD behavior. Use the
528 cmake_policy() command to set it to OLD or NEW explicitly.
529 NOTE:
531 The OLD behavior of a policy is deprecated by definition and may be
532 removed in a future version of CMake.
533 CMP0085
535 $<IN_LIST:...> handles empty list items.
536 In CMake 3.13 and lower, the $<IN_LIST:...> generator expression always
538 returned 0 if the first argument was empty, even if the list contained
539 an empty item. This behavior is inconsistent with the IN_LIST behavior
540 of if(), which this generator expression is meant to emulate. CMake
541 3.14 and later handles this case correctly.
542 The OLD behavior of this policy is for $<IN_LIST:...> to always return
544 0 if the first argument is empty. The NEW behavior is to return 1 if
545 the first argument is empty and the list contains an empty item.
546 This policy was introduced in CMake version 3.14. CMake version 3.17.2
548 warns when the policy is not set and uses OLD behavior. Use the
549 cmake_policy() command to set it to OLD or NEW explicitly.
550 NOTE:
552 The OLD behavior of a policy is deprecated by definition and may be
553 removed in a future version of CMake.
554 CMP0084
556 The FindQt module does not exist for find_package().
557 The existence of FindQt means that for Qt upstream to provide package
559 config files that can be found by find_package(Qt), the consuming
560 project has to explicitly specify find_package(Qt CONFIG). Removing
561 this module gives Qt a path forward for exporting its own config files
562 which can easily be found by consuming projects.
563 This policy pretends that CMake’s internal FindQt module does not exist
565 for find_package(). If a project really wants to use Qt 3 or 4, it can
566 call find_package(Qt[34]), include(FindQt), or add FindQt to their
567 CMAKE_MODULE_PATH.
568 The OLD behavior of this policy is for FindQt to exist for find_pack‐
570 age(). The NEW behavior is to pretend that it doesn’t exist for
571 find_package().
572 This policy was introduced in CMake version 3.14. CMake version 3.17.2
574 warns when the policy is not set and uses OLD behavior. Use the
575 cmake_policy() command to set it to OLD or NEW explicitly.
576 NOTE:
578 The OLD behavior of a policy is deprecated by definition and may be
579 removed in a future version of CMake.
580 CMP0083
582 To control generation of Position Independent Executable (PIE) or not,
583 some flags are required at link time.
584 CMake 3.13 and lower did not add these link flags when POSITION_INDE‐
586 PENDENT_CODE is set.
587 The OLD behavior for this policy is to not manage PIE link flags. The
589 NEW behavior is to add link flags if POSITION_INDEPENDENT_CODE is set:
590 · Set to TRUE: flags to produce a position independent executable are
592 passed to the linker step. For example -pie for GCC.
593 · Set to FALSE: flags not to produce a position independent executable
595 are passed to the linker step. For example -no-pie for GCC.
596 · Not set: no flags are passed to the linker step.
598 Since a given linker may not support PIE flags in all environments in
600 which it is used, it is the project’s responsibility to use the Check‐
601 PIESupported module to check for support to ensure that the POSI‐
602 TION_INDEPENDENT_CODE target property for executables will be honored
603 at link time.
604 This policy was introduced in CMake version 3.14. Use the cmake_pol‐
606 icy() command to set it to OLD or NEW explicitly. Unlike most poli‐
607 cies, CMake version 3.17.2 does not warn when this policy is not set
608 and simply uses OLD behavior.
609 NOTE:
611 Android platform has a special handling of PIE so it is not required
612 to use the CheckPIESupported module to ensure flags are passed to
613 the linker.
614 NOTE:
616 The OLD behavior of a policy is deprecated by definition and may be
617 removed in a future version of CMake.
618 Examples
620 Behave like CMake 3.13 and do not apply any PIE flags at link stage.
621 cmake_minimum_required(VERSION 3.13)
623 project(foo)
624 # ...
626 add_executable(foo ...)
628 set_property(TARGET foo PROPERTY POSITION_INDEPENDENT_CODE TRUE)
629 Use the CheckPIESupported module to detect whether PIE is supported by
631 the current linker and environment. Apply PIE flags only if the linker
632 supports them.
633 cmake_minimum_required(VERSION 3.14) # CMP0083 NEW
635 project(foo)
636 include(CheckPIESupported)
638 check_pie_supported()
639 # ...
641 add_executable(foo ...)
643 set_property(TARGET foo PROPERTY POSITION_INDEPENDENT_CODE TRUE)
644 CMP0082
646 Install rules from add_subdirectory() calls are interleaved with those
647 in caller.
648 CMake 3.13 and lower ran the install rules from add_subdirectory()
650 after all other install rules, even if add_subdirectory() was called
651 before the other install rules. CMake 3.14 and above prefer to inter‐
652 leave these add_subdirectory() install rules with the others so that
653 they are run in the order they are declared. This policy provides com‐
654 patibility for projects that have not been updated to expect the new
655 behavior.
656 The OLD behavior for this policy is to run the install rules from
658 add_subdirectory() after the other install rules. The NEW behavior for
659 this policy is to run all install rules in the order they are declared.
660 This policy was introduced in CMake version 3.14. Unlike most poli‐
662 cies, CMake version 3.17.2 does not warn by default when this policy is
663 not set and simply uses OLD behavior. See documentation of the
664 CMAKE_POLICY_WARNING_CMP0082 variable to control the warning.
665 NOTE:
667 The OLD behavior of a policy is deprecated by definition and may be
668 removed in a future version of CMake.
669
671 CMP0081
672 Relative paths not allowed in LINK_DIRECTORIES target property.
673 CMake 3.12 and lower allowed the LINK_DIRECTORIES directory property to
675 contain relative paths. The base path for such relative entries is not
676 well defined. CMake 3.13 and later will issue a FATAL_ERROR if the
677 LINK_DIRECTORIES target property (which is initialized by the
678 LINK_DIRECTORIES directory property) contains a relative path.
679 The OLD behavior for this policy is not to warn about relative paths in
681 the LINK_DIRECTORIES target property. The NEW behavior for this policy
682 is to issue a FATAL_ERROR if LINK_DIRECTORIES contains a relative path.
683 This policy was introduced in CMake version 3.13. CMake version 3.17.2
685 warns when the policy is not set and uses OLD behavior. Use the
686 cmake_policy() command to set it to OLD or NEW explicitly.
687 NOTE:
689 The OLD behavior of a policy is deprecated by definition and may be
690 removed in a future version of CMake.
691 CMP0080
693 BundleUtilities cannot be included at configure time.
694 The macros provided by BundleUtilities are intended to be invoked at
696 install time rather than at configure time, because they depend on the
697 listed targets already existing at the time they are invoked. If they
698 are invoked at configure time, the targets haven’t been built yet, and
699 the commands will fail.
700 This policy restricts the inclusion of BundleUtilities to cmake -P
702 style scripts and install rules. Specifically, it looks for the pres‐
703 ence of CMAKE_GENERATOR and throws a fatal error if it exists.
704 The OLD behavior of this policy is to allow BundleUtilities to be
706 included at configure time. The NEW behavior of this policy is to dis‐
707 allow such inclusion.
708 This policy was introduced in CMake version 3.13. CMake version 3.17.2
710 warns when the policy is not set and uses OLD behavior. Use the
711 cmake_policy() command to set it to OLD or NEW explicitly.
712 NOTE:
714 The OLD behavior of a policy is deprecated by definition and may be
715 removed in a future version of CMake.
716 CMP0079
718 target_link_libraries() allows use with targets in other directories.
719 Prior to CMake 3.13 the target_link_libraries() command did not accept
721 targets not created in the calling directory as its first argument for
722 calls that update the LINK_LIBRARIES of the target itself. It did
723 accidentally accept targets from other directories on calls that only
724 update the INTERFACE_LINK_LIBRARIES, but would simply add entries to
725 the property as if the call were made in the original directory. Thus
726 link interface libraries specified this way were always looked up by
727 generators in the scope of the original target rather than in the scope
728 that called target_link_libraries().
729 CMake 3.13 now allows the target_link_libraries() command to be called
731 from any directory to add link dependencies and link interface
732 libraries to targets created in other directories. The entries are
733 added to LINK_LIBRARIES and INTERFACE_LINK_LIBRARIES using a special
734 (internal) suffix to tell the generators to look up the names in the
735 calling scope rather than the scope that created the target.
736 This policy provides compatibility with projects that already use tar‐
738 get_link_libraries() with the INTERFACE keyword on a target in another
739 directory to add INTERFACE_LINK_LIBRARIES entries to be looked up in
740 the target’s directory. Such projects should be updated to be aware of
741 the new scoping rules in that case.
742 The OLD behavior of this policy is to disallow target_link_libraries()
744 calls naming targets from another directory except in the previously
745 accidentally allowed case of using the INTERFACE keyword only. The NEW
746 behavior of this policy is to allow all such calls but use the new
747 scoping rules.
748 This policy was introduced in CMake version 3.13. CMake version 3.17.2
750 warns when the policy is not set and uses OLD behavior. Use the
751 cmake_policy() command to set it to OLD or NEW explicitly.
752 NOTE:
754 The OLD behavior of a policy is deprecated by definition and may be
755 removed in a future version of CMake.
756 CMP0078
758 UseSWIG generates standard target names.
759 Starting with CMake 3.13, UseSWIG generates now standard target names.
761 This policy provides compatibility with projects that expect the legacy
762 behavior.
763 The OLD behavior for this policy relies on UseSWIG_TARGET_NAME_PREFER‐
765 ENCE variable that can be used to specify an explicit preference. The
766 value may be one of:
767 · LEGACY: legacy strategy is applied. Variable SWIG_MOD‐
769 ULE_<name>_REAL_NAME must be used to get real target name. This is
770 the default if not specified.
771 · STANDARD: target name matches specified name.
773 This policy was introduced in CMake version 3.13. CMake version 3.17.2
775 warns when the policy is not set and uses OLD behavior. Use the
776 cmake_policy() command to set it to OLD or NEW explicitly.
777 NOTE:
779 The OLD behavior of a policy is deprecated by definition and may be
780 removed in a future version of CMake.
781 CMP0077
783 option() honors normal variables.
784 The option() command is typically used to create a cache entry to allow
786 users to set the option. However, there are cases in which a normal
787 (non-cached) variable of the same name as the option may be defined by
788 the project prior to calling the option() command. For example, a
789 project that embeds another project as a subdirectory may want to
790 hard-code options of the subproject to build the way it needs.
791 For historical reasons in CMake 3.12 and below the option() command
793 removes a normal (non-cached) variable of the same name when:
794 · a cache entry of the specified name does not exist at all, or
796 · a cache entry of the specified name exists but has not been given a
798 type (e.g. via -D<name>=ON on the command line).
799 In both of these cases (typically on the first run in a new build
801 tree), the option() command gives the cache entry type BOOL and removes
802 any normal (non-cached) variable of the same name. In the remaining
803 case that the cache entry of the specified name already exists and has
804 a type (typically on later runs in a build tree), the option() command
805 changes nothing and any normal variable of the same name remains set.
806 In CMake 3.13 and above the option() command prefers to do nothing when
808 a normal variable of the given name already exists. It does not create
809 or update a cache entry or remove the normal variable. The new behav‐
810 ior is consistent between the first and later runs in a build tree.
811 This policy provides compatibility with projects that have not been
812 updated to expect the new behavior.
813 When the option() command sees a normal variable of the given name:
815 · The OLD behavior for this policy is to proceed even when a normal
817 variable of the same name exists. If the cache entry does not
818 already exist and have a type then it is created and/or given a type
819 and the normal variable is removed.
820 · The NEW behavior for this policy is to do nothing when a normal vari‐
822 able of the same name exists. The normal variable is not removed.
823 The cache entry is not created or updated and is ignored if it
824 exists.
825 This policy was introduced in CMake version 3.13. CMake version 3.17.2
827 warns when the policy is not set and uses OLD behavior. Use the
828 cmake_policy() command to set it to OLD or NEW explicitly.
829 NOTE:
831 The OLD behavior of a policy is deprecated by definition and may be
832 removed in a future version of CMake.
833 CMP0076
835 The target_sources() command converts relative paths to absolute.
836 In CMake 3.13 and above, the target_sources() command now converts rel‐
838 ative source file paths to absolute paths in the following cases:
839 · Source files are added to the target’s INTERFACE_SOURCES property.
841 · The target’s SOURCE_DIR property differs from CMAKE_CUR‐
843 RENT_SOURCE_DIR.
844 A path that begins with a generator expression is always left unmodi‐
846 fied.
847 This policy provides compatibility with projects that have not been
849 updated to expect this behavior. The OLD behavior for this policy is
850 to leave all relative source file paths unmodified. The NEW behavior
851 of this policy is to convert relative paths to absolute according to
852 above rules.
853 This policy was introduced in CMake version 3.13. CMake version 3.17.2
855 warns when the policy is not set and uses OLD behavior. Use the
856 cmake_policy() command to set it to OLD or NEW explicitly.
857 NOTE:
859 The OLD behavior of a policy is deprecated by definition and may be
860 removed in a future version of CMake.
861
863 CMP0075
864 Include file check macros honor CMAKE_REQUIRED_LIBRARIES.
865 In CMake 3.12 and above, the
867 · check_include_file macro in the CheckIncludeFile module, the
869 · check_include_file_cxx macro in the CheckIncludeFileCXX module, and
871 the
872 · check_include_files macro in the CheckIncludeFiles module
874 now prefer to link the check executable to the libraries listed in the
876 CMAKE_REQUIRED_LIBRARIES variable. This policy provides compatibility
877 with projects that have not been updated to expect this behavior.
878 The OLD behavior for this policy is to ignore CMAKE_REQUIRED_LIBRARIES
880 in the include file check macros. The NEW behavior of this policy is
881 to honor CMAKE_REQUIRED_LIBRARIES in the include file check macros.
882 This policy was introduced in CMake version 3.12. CMake version 3.17.2
884 warns when the policy is not set and uses OLD behavior. Use the
885 cmake_policy() command to set it to OLD or NEW explicitly.
886 NOTE:
888 The OLD behavior of a policy is deprecated by definition and may be
889 removed in a future version of CMake.
890 CMP0074
892 find_package() uses <PackageName>_ROOT variables.
893 In CMake 3.12 and above the find_package(<PackageName>) command now
895 searches prefixes specified by the <PackageName>_ROOT CMake variable
896 and the <PackageName>_ROOT environment variable. Package roots are
897 maintained as a stack so nested calls to all find_* commands inside
898 find modules and config packages also search the roots as prefixes.
899 This policy provides compatibility with projects that have not been
900 updated to avoid using <PackageName>_ROOT variables for other purposes.
901 The OLD behavior for this policy is to ignore <PackageName>_ROOT vari‐
903 ables. The NEW behavior for this policy is to use <PackageName>_ROOT
904 variables.
905 This policy was introduced in CMake version 3.12. CMake version 3.17.2
907 warns when the policy is not set and uses OLD behavior. Use the
908 cmake_policy() command to set it to OLD or NEW explicitly.
909 NOTE:
911 The OLD behavior of a policy is deprecated by definition and may be
912 removed in a future version of CMake.
913 CMP0073
915 Do not produce legacy _LIB_DEPENDS cache entries.
916 Ancient CMake versions once used <tgt>_LIB_DEPENDS cache entries to
918 propagate library link dependencies. This has long been done by other
919 means, leaving the export_library_dependencies() command as the only
920 user of these values. That command has long been disallowed by policy
921 CMP0033, but the <tgt>_LIB_DEPENDS cache entries were left for compati‐
922 bility with possible non-standard uses by projects.
923 CMake 3.12 and above now prefer to not produce these cache entries at
925 all. This policy provides compatibility with projects that have not
926 been updated to avoid using them.
927 The OLD behavior for this policy is to set <tgt>_LIB_DEPENDS cache
929 entries. The NEW behavior for this policy is to not set them.
930 This policy was introduced in CMake version 3.12. Use the cmake_pol‐
932 icy() command to set it to OLD or NEW explicitly. Unlike most poli‐
933 cies, CMake version 3.17.2 does not warn when this policy is not set
934 and simply uses OLD behavior.
935 NOTE:
937 The OLD behavior of a policy is deprecated by definition and may be
938 removed in a future version of CMake.
939
941 CMP0072
942 FindOpenGL prefers GLVND by default when available.
943 The FindOpenGL module provides an OpenGL::GL target and an
945 OPENGL_LIBRARIES variable for projects to use for legacy GL interfaces.
946 When both a legacy GL library (e.g. libGL.so) and GLVND libraries for
947 OpenGL and GLX (e.g. libOpenGL.so and libGLX.so) are available, the
948 module must choose between them. It documents an OpenGL_GL_PREFERENCE
949 variable that can be used to specify an explicit preference. When no
950 such preference is set, the module must choose a default preference.
951 CMake 3.11 and above prefer to choose GLVND libraries. This policy
953 provides compatibility with projects that expect the legacy GL library
954 to be used.
955 The OLD behavior for this policy is to set OpenGL_GL_PREFERENCE to
957 LEGACY. The NEW behavior for this policy is to set OpenGL_GL_PREFER‐
958 ENCE to GLVND.
959 This policy was introduced in CMake version 3.11. CMake version 3.17.2
961 warns when the policy is not set and uses OLD behavior. Use the
962 cmake_policy() command to set it to OLD or NEW explicitly.
963 NOTE:
965 The OLD behavior of a policy is deprecated by definition and may be
966 removed in a future version of CMake.
967
969 CMP0071
970 Let AUTOMOC and AUTOUIC process GENERATED files.
971 Since version 3.10, CMake processes regular and GENERATED source files
973 in AUTOMOC and AUTOUIC. In earlier CMake versions, only regular source
974 files were processed. GENERATED source files were ignored silently.
975 This policy affects how source files that are GENERATED get treated in
977 AUTOMOC and AUTOUIC.
978 The OLD behavior for this policy is to ignore GENERATED source files in
980 AUTOMOC and AUTOUIC.
981 The NEW behavior for this policy is to process GENERATED source files
983 in AUTOMOC and AUTOUIC just like regular source files.
984 NOTE:
986 To silence the CMP0071 warning source files can be excluded from
987 AUTOMOC and AUTOUIC processing by setting the source file properties
988 SKIP_AUTOMOC, SKIP_AUTOUIC or SKIP_AUTOGEN.
989 Source skip example:
991 # ...
993 set_property(SOURCE /path/to/file1.h PROPERTY SKIP_AUTOMOC ON)
994 set_property(SOURCE /path/to/file2.h PROPERTY SKIP_AUTOUIC ON)
995 set_property(SOURCE /path/to/file3.h PROPERTY SKIP_AUTOGEN ON)
996 # ...
997 This policy was introduced in CMake version 3.10. CMake version 3.17.2
999 warns when the policy is not set and uses OLD behavior. Use the
1000 cmake_policy() command to set it to OLD or NEW explicitly.
1001 NOTE:
1003 The OLD behavior of a policy is deprecated by definition and may be
1004 removed in a future version of CMake.
1005 CMP0070
1007 Define file(GENERATE) behavior for relative paths.
1008 CMake 3.10 and newer define that relative paths given to INPUT and OUT‐
1010 PUT arguments of file(GENERATE) are interpreted relative to the current
1011 source and binary directories, respectively. CMake 3.9 and lower did
1012 not define any behavior for relative paths but did not diagnose them
1013 either and accidentally treated them relative to the process working
1014 directory. Policy CMP0070 provides compatibility with projects that
1015 used the old undefined behavior.
1016 This policy affects behavior of relative paths given to file(GENERATE).
1018 The OLD behavior for this policy is to treat the paths relative to the
1019 working directory of CMake. The NEW behavior for this policy is to
1020 interpret relative paths with respect to the current source or binary
1021 directory of the caller.
1022 This policy was introduced in CMake version 3.10. CMake version 3.17.2
1024 warns when the policy is not set and uses OLD behavior. Use the
1025 cmake_policy() command to set it to OLD or NEW explicitly.
1026 NOTE:
1028 The OLD behavior of a policy is deprecated by definition and may be
1029 removed in a future version of CMake.
1030
1032 CMP0069
1033 INTERPROCEDURAL_OPTIMIZATION is enforced when enabled.
1034 CMake 3.9 and newer prefer to add IPO flags whenever the INTERPROCEDU‐
1036 RAL_OPTIMIZATION target property is enabled and produce an error if
1037 flags are not known to CMake for the current compiler. Since a given
1038 compiler may not support IPO flags in all environments in which it is
1039 used, it is now the project’s responsibility to use the CheckIPOSup‐
1040 ported module to check for support before enabling the INTERPROCEDU‐
1041 RAL_OPTIMIZATION target property. This approach allows a project to
1042 conditionally activate IPO when supported. It also allows an end user
1043 to set the CMAKE_INTERPROCEDURAL_OPTIMIZATION variable in an environ‐
1044 ment known to support IPO even if the project does not enable the prop‐
1045 erty.
1046 Since CMake 3.8 and lower only honored INTERPROCEDURAL_OPTIMIZATION for
1048 the Intel compiler on Linux, some projects may unconditionally enable
1049 the target property. Policy CMP0069 provides compatibility with such
1050 projects.
1051 This policy takes effect whenever the IPO property is enabled. The OLD
1053 behavior for this policy is to add IPO flags only for Intel compiler on
1054 Linux. The NEW behavior for this policy is to add IPO flags for the
1055 current compiler or produce an error if CMake does not know the flags.
1056 This policy was introduced in CMake version 3.9. CMake version 3.17.2
1058 warns when the policy is not set and uses OLD behavior. Use the
1059 cmake_policy() command to set it to OLD or NEW explicitly.
1060 NOTE:
1062 The OLD behavior of a policy is deprecated by definition and may be
1063 removed in a future version of CMake.
1064 Examples
1066 Behave like CMake 3.8 and do not apply any IPO flags except for Intel
1067 compiler on Linux:
1068 cmake_minimum_required(VERSION 3.8)
1070 project(foo)
1071 # ...
1073 set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
1075 Use the CheckIPOSupported module to detect whether IPO is supported by
1077 the current compiler, environment, and CMake version. Produce a fatal
1078 error if support is not available:
1079 cmake_minimum_required(VERSION 3.9) # CMP0069 NEW
1081 project(foo)
1082 include(CheckIPOSupported)
1084 check_ipo_supported()
1085 # ...
1087 set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
1089 Apply IPO flags only if compiler supports it:
1091 cmake_minimum_required(VERSION 3.9) # CMP0069 NEW
1093 project(foo)
1094 include(CheckIPOSupported)
1096 # ...
1098 check_ipo_supported(RESULT result)
1100 if(result)
1101 set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
1102 endif()
1103 Apply IPO flags without any checks. This may lead to build errors if
1105 IPO is not supported by the compiler in the current environment. Pro‐
1106 duce an error if CMake does not know IPO flags for the current com‐
1107 piler:
1108 cmake_minimum_required(VERSION 3.9) # CMP0069 NEW
1110 project(foo)
1111 # ...
1113 set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
1115 CMP0068
1117 RPATH settings on macOS do not affect install_name.
1118 CMake 3.9 and newer remove any effect the following settings may have
1120 on the install_name of a target on macOS:
1121 · BUILD_WITH_INSTALL_RPATH target property
1123 · SKIP_BUILD_RPATH target property
1125 · CMAKE_SKIP_RPATH variable
1127 · CMAKE_SKIP_INSTALL_RPATH variable
1129 Previously, setting BUILD_WITH_INSTALL_RPATH had the effect of setting
1131 both the install_name of a target to INSTALL_NAME_DIR and the RPATH to
1132 INSTALL_RPATH. In CMake 3.9, it only affects setting of RPATH. How‐
1133 ever, if one wants INSTALL_NAME_DIR to apply to the target in the build
1134 tree, one may set BUILD_WITH_INSTALL_NAME_DIR.
1135 If SKIP_BUILD_RPATH, CMAKE_SKIP_RPATH or CMAKE_SKIP_INSTALL_RPATH were
1137 used to strip the directory portion of the install_name of a target,
1138 one may set INSTALL_NAME_DIR="" instead.
1139 The OLD behavior of this policy is to use the RPATH settings for
1141 install_name on macOS. The NEW behavior of this policy is to ignore
1142 the RPATH settings for install_name on macOS.
1143 This policy was introduced in CMake version 3.9. CMake version 3.17.2
1145 warns when the policy is not set and uses OLD behavior. Use the
1146 cmake_policy() command to set it to OLD or NEW explicitly.
1147 NOTE:
1149 The OLD behavior of a policy is deprecated by definition and may be
1150 removed in a future version of CMake.
1151
1153 CMP0067
1154 Honor language standard in try_compile() source-file signature.
1155 The try_compile() source file signature is intended to allow callers to
1157 check whether they will be able to compile a given source file with the
1158 current toolchain. In order to match compiler behavior, any language
1159 standard mode should match. However, CMake 3.7 and below did not do
1160 this. CMake 3.8 and above prefer to honor the language standard set‐
1161 tings for C, CXX (C++), and CUDA using the values of the variables:
1162 · CMAKE_C_STANDARD
1164 · CMAKE_C_STANDARD_REQUIRED
1166 · CMAKE_C_EXTENSIONS
1168 · CMAKE_CXX_STANDARD
1170 · CMAKE_CXX_STANDARD_REQUIRED
1172 · CMAKE_CXX_EXTENSIONS
1174 · CMAKE_CUDA_STANDARD
1176 · CMAKE_CUDA_STANDARD_REQUIRED
1178 · CMAKE_CUDA_EXTENSIONS
1180 This policy provides compatibility for projects that do not expect the
1182 language standard settings to be used automatically.
1183 The OLD behavior of this policy is to ignore language standard setting
1185 variables when generating the try_compile test project. The NEW behav‐
1186 ior of this policy is to honor language standard setting variables.
1187 This policy was introduced in CMake version 3.8. Unlike most policies,
1189 CMake version 3.17.2 does not warn by default when this policy is not
1190 set and simply uses OLD behavior. See documentation of the CMAKE_POL‐
1191 ICY_WARNING_CMP0067 variable to control the warning.
1192 NOTE:
1194 The OLD behavior of a policy is deprecated by definition and may be
1195 removed in a future version of CMake.
1196
1198 CMP0066
1199 Honor per-config flags in try_compile() source-file signature.
1200 The source file signature of the try_compile() command uses the value
1202 of the CMAKE_<LANG>_FLAGS variable in the test project so that the test
1203 compilation works as it would in the main project. However, CMake 3.6
1204 and below do not also honor config-specific compiler flags such as
1205 those in the CMAKE_<LANG>_FLAGS_DEBUG variable. CMake 3.7 and above
1206 prefer to honor config-specific compiler flags too. This policy pro‐
1207 vides compatibility for projects that do not expect config-specific
1208 compiler flags to be used.
1209 The OLD behavior of this policy is to ignore config-specific flag vari‐
1211 ables like CMAKE_<LANG>_FLAGS_DEBUG and only use CMake’s built-in
1212 defaults for the current compiler and platform.
1213 The NEW behavior of this policy is to honor config-specific flag vari‐
1215 abldes like CMAKE_<LANG>_FLAGS_DEBUG.
1216 This policy was introduced in CMake version 3.7. Unlike most policies,
1218 CMake version 3.17.2 does not warn by default when this policy is not
1219 set and simply uses OLD behavior. See documentation of the CMAKE_POL‐
1220 ICY_WARNING_CMP0066 variable to control the warning.
1221 NOTE:
1223 The OLD behavior of a policy is deprecated by definition and may be
1224 removed in a future version of CMake.
1225
1227 CMP0065
1228 Do not add flags to export symbols from executables without the
1229 ENABLE_EXPORTS target property.
1230 CMake 3.3 and below, for historical reasons, always linked executables
1232 on some platforms with flags like -rdynamic to export symbols from the
1233 executables for use by any plugins they may load via dlopen. CMake 3.4
1234 and above prefer to do this only for executables that are explicitly
1235 marked with the ENABLE_EXPORTS target property.
1236 The OLD behavior of this policy is to always use the additional link
1238 flags when linking executables regardless of the value of the
1239 ENABLE_EXPORTS target property.
1240 The NEW behavior of this policy is to only use the additional link
1242 flags when linking executables if the ENABLE_EXPORTS target property is
1243 set to True.
1244 This policy was introduced in CMake version 3.4. Unlike most policies,
1246 CMake version 3.17.2 does not warn by default when this policy is not
1247 set and simply uses OLD behavior. See documentation of the CMAKE_POL‐
1248 ICY_WARNING_CMP0065 variable to control the warning.
1249 NOTE:
1251 The OLD behavior of a policy is deprecated by definition and may be
1252 removed in a future version of CMake.
1253 CMP0064
1255 Recognize TEST as a operator for the if() command.
1256 The TEST operator was added to the if() command to determine if a given
1258 test name was created by the add_test() command.
1259 The OLD behavior for this policy is to ignore the TEST operator. The
1261 NEW behavior is to interpret the TEST operator.
1262 This policy was introduced in CMake version 3.4. CMake version 3.17.2
1264 warns when the policy is not set and uses OLD behavior. Use the
1265 cmake_policy() command to set it to OLD or NEW explicitly.
1266 NOTE:
1268 The OLD behavior of a policy is deprecated by definition and may be
1269 removed in a future version of CMake.
1270
1272 CMP0063
1273 Honor visibility properties for all target types.
1274 The <LANG>_VISIBILITY_PRESET and VISIBILITY_INLINES_HIDDEN target prop‐
1276 erties affect visibility of symbols during dynamic linking. When first
1277 introduced these properties affected compilation of sources only in
1278 shared libraries, module libraries, and executables with the
1279 ENABLE_EXPORTS property set. This was sufficient for the basic use
1280 cases of shared libraries and executables with plugins. However, some
1281 sources may be compiled as part of static libraries or object libraries
1282 and then linked into a shared library later. CMake 3.3 and above pre‐
1283 fer to honor these properties for sources compiled in all target types.
1284 This policy preserves compatibility for projects expecting the proper‐
1285 ties to work only for some target types.
1286 The OLD behavior for this policy is to ignore the visibility properties
1288 for static libraries, object libraries, and executables without
1289 exports. The NEW behavior for this policy is to honor the visibility
1290 properties for all target types.
1291 This policy was introduced in CMake version 3.3. CMake version 3.17.2
1293 warns when the policy is not set and uses OLD behavior. Use the
1294 cmake_policy() command to set it to OLD or NEW explicitly.
1295 NOTE:
1297 The OLD behavior of a policy is deprecated by definition and may be
1298 removed in a future version of CMake.
1299 CMP0062
1301 Disallow install() of export() result.
1302 The export() command generates a file containing Imported Targets,
1304 which is suitable for use from the build directory. It is not suitable
1305 for installation because it contains absolute paths to buildsystem
1306 locations, and is particular to a single build configuration.
1307 The install(EXPORT) generates and installs files which contain Imported
1309 Targets. These files are generated with relative paths (unless the
1310 user specifies absolute paths), and are designed for multi-configura‐
1311 tion use. See Creating Packages for more.
1312 CMake 3.3 no longer allows the use of the install(FILES) command with
1314 the result of the export() command.
1315 The OLD behavior for this policy is to allow installing the result of
1317 an export() command. The NEW behavior for this policy is not to allow
1318 installing the result of an export() command.
1319 This policy was introduced in CMake version 3.3. CMake version 3.17.2
1321 warns when the policy is not set and uses OLD behavior. Use the
1322 cmake_policy() command to set it to OLD or NEW explicitly.
1323 NOTE:
1325 The OLD behavior of a policy is deprecated by definition and may be
1326 removed in a future version of CMake.
1327 CMP0061
1329 CTest does not by default tell make to ignore errors (-i).
1330 The ctest_build() and build_command() commands no longer generate build
1332 commands for Makefile Generators with the -i option. Previously this
1333 was done to help build as much of tested projects as possible. How‐
1334 ever, this behavior is not consistent with other generators and also
1335 causes the return code of the make tool to be meaningless.
1336 Of course users may still add this option manually by setting
1338 CTEST_BUILD_COMMAND or the MAKECOMMAND cache entry. See the CTest
1339 Build Step MakeCommand setting documentation for their effects.
1340 The OLD behavior for this policy is to add -i to make calls in CTest.
1342 The NEW behavior for this policy is to not add -i.
1343 This policy was introduced in CMake version 3.3. Unlike most policies,
1345 CMake version 3.17.2 does not warn when this policy is not set and sim‐
1346 ply uses OLD behavior.
1347 NOTE:
1349 The OLD behavior of a policy is deprecated by definition and may be
1350 removed in a future version of CMake.
1351 CMP0060
1353 Link libraries by full path even in implicit directories.
1354 Policy CMP0003 was introduced with the intention of always linking
1356 library files by full path when a full path is given to the tar‐
1357 get_link_libraries() command. However, on some platforms (e.g. HP-UX)
1358 the compiler front-end adds alternative library search paths for the
1359 current architecture (e.g. /usr/lib/<arch> has alternatives to
1360 libraries in /usr/lib for the current architecture). On such platforms
1361 the find_library() may find a library such as /usr/lib/libfoo.so that
1362 does not belong to the current architecture.
1363 Prior to policy CMP0003 projects would still build in such cases
1365 because the incorrect library path would be converted to -lfoo on the
1366 link line and the linker would find the proper library in the arch-spe‐
1367 cific search path provided by the compiler front-end implicitly. At
1368 the time we chose to remain compatible with such projects by always
1369 converting library files found in implicit link directories to -lfoo
1370 flags to ask the linker to search for them. This approach allowed
1371 existing projects to continue to build while still linking to libraries
1372 outside implicit link directories via full path (such as those in the
1373 build tree).
1374 CMake does allow projects to override this behavior by using an
1376 IMPORTED library target with its IMPORTED_LOCATION property set to the
1377 desired full path to a library file. In fact, many Find Modules are
1378 learning to provide Imported Targets instead of just the traditional
1379 Foo_LIBRARIES variable listing library files. However, this makes the
1380 link line generated for a library found by a Find Module depend on
1381 whether it is linked through an imported target or not, which is incon‐
1382 sistent. Furthermore, this behavior has been a source of confusion
1383 because the generated link line for a library file depends on its loca‐
1384 tion. It is also problematic for projects trying to link statically
1385 because flags like -Wl,-Bstatic -lfoo -Wl,-Bdynamic may be used to help
1386 the linker select libfoo.a instead of libfoo.so but then leak dynamic
1387 linking to following libraries. (See the LINK_SEARCH_END_STATIC target
1388 property for a solution typically used for that problem.)
1389 When the special case for libraries in implicit link directories was
1391 first introduced the list of implicit link directories was simply
1392 hard-coded (e.g. /lib, /usr/lib, and a few others). Since that time,
1393 CMake has learned to detect the implicit link directories used by the
1394 compiler front-end. If necessary, the find_library() command could be
1395 taught to use this information to help find libraries of the proper
1396 architecture.
1397 For these reasons, CMake 3.3 and above prefer to drop the special case
1399 and link libraries by full path even when they are in implicit link
1400 directories. Policy CMP0060 provides compatibility for existing
1401 projects.
1402 The OLD behavior for this policy is to ask the linker to search for
1404 libraries whose full paths are known to be in implicit link directo‐
1405 ries. The NEW behavior for this policy is to link libraries by full
1406 path even if they are in implicit link directories.
1407 This policy was introduced in CMake version 3.3. Unlike most policies,
1409 CMake version 3.17.2 does not warn by default when this policy is not
1410 set and simply uses OLD behavior. See documentation of the CMAKE_POL‐
1411 ICY_WARNING_CMP0060 variable to control the warning.
1412 NOTE:
1414 The OLD behavior of a policy is deprecated by definition and may be
1415 removed in a future version of CMake.
1416 CMP0059
1418 Do not treat DEFINITIONS as a built-in directory property.
1419 CMake 3.3 and above no longer make a list of definitions available
1421 through the DEFINITIONS directory property. The COMPILE_DEFINITIONS
1422 directory property may be used instead.
1423 The OLD behavior for this policy is to provide the list of flags given
1425 so far to the add_definitions() command. The NEW behavior is to behave
1426 as a normal user-defined directory property.
1427 This policy was introduced in CMake version 3.3. CMake version 3.17.2
1429 warns when the policy is not set and uses OLD behavior. Use the
1430 cmake_policy() command to set it to OLD or NEW explicitly.
1431 NOTE:
1433 The OLD behavior of a policy is deprecated by definition and may be
1434 removed in a future version of CMake.
1435 CMP0058
1437 Ninja requires custom command byproducts to be explicit.
1438 When an intermediate file generated during the build is consumed by an
1440 expensive operation or a large tree of dependents, one may reduce the
1441 work needed for an incremental rebuild by updating the file timestamp
1442 only when its content changes. With this approach the generation rule
1443 must have a separate output file that is always updated with a new
1444 timestamp that is newer than any dependencies of the rule so that the
1445 build tool re-runs the rule only when the input changes. We refer to
1446 the separate output file as a rule’s witness and the generated file as
1447 a rule’s byproduct.
1448 Byproducts may not be listed as outputs because their timestamps are
1450 allowed to be older than the inputs. No build tools (like make) that
1451 existed when CMake was designed have a way to express byproducts.
1452 Therefore CMake versions prior to 3.2 had no way to specify them.
1453 Projects typically left byproducts undeclared in the rules that gener‐
1454 ate them. For example:
1455 add_custom_command(
1457 OUTPUT witness.txt
1458 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1459 ${CMAKE_CURRENT_SOURCE_DIR}/input.txt
1460 byproduct.txt # timestamp may not change
1461 COMMAND ${CMAKE_COMMAND} -E touch witness.txt
1462 DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/input.txt
1463 )
1464 add_custom_target(Provider DEPENDS witness.txt)
1465 add_custom_command(
1466 OUTPUT generated.c
1467 COMMAND expensive-task -i byproduct.txt -o generated.c
1468 DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/byproduct.txt
1469 )
1470 add_library(Consumer generated.c)
1471 add_dependencies(Consumer Provider)
1472 This works well for all generators except Ninja. The Ninja build tool
1474 sees a rule listing byproduct.txt as a dependency and no rule listing
1475 it as an output. Ninja then complains that there is no way to satisfy
1476 the dependency and stops building even though there are order-only
1477 dependencies that ensure byproduct.txt will exist before its consumers
1478 need it. See discussion of this problem in Ninja Issue 760 for further
1479 details on why Ninja works this way.
1480 Instead of leaving byproducts undeclared in the rules that generate
1482 them, Ninja expects byproducts to be listed along with other outputs.
1483 Such rules may be marked with a restat option that tells Ninja to check
1484 the timestamps of outputs after the rules run. This prevents byprod‐
1485 ucts whose timestamps do not change from causing their dependents to
1486 re-build unnecessarily.
1487 Since the above approach does not tell CMake what custom command gener‐
1489 ates byproduct.txt, the Ninja generator does not have enough informa‐
1490 tion to add the byproduct as an output of any rule. CMake 2.8.12 and
1491 above work around this problem and allow projects using the above
1492 approach to build by generating phony build rules to tell Ninja to tol‐
1493 erate such missing files. However, this workaround prevents Ninja from
1494 diagnosing a dependency that is really missing. It also works poorly
1495 in in-source builds where every custom command dependency, even on
1496 source files, needs to be treated this way because CMake does not have
1497 enough information to know which files are generated as byproducts of
1498 custom commands.
1499 CMake 3.2 introduced the BYPRODUCTS option to the add_custom_command()
1501 and add_custom_target() commands. This option allows byproducts to be
1502 specified explicitly:
1503 add_custom_command(
1505 OUTPUT witness.txt
1506 BYPRODUCTS byproduct.txt # explicit byproduct specification
1507 COMMAND ${CMAKE_COMMAND} -E copy_if_different
1508 ${CMAKE_CURRENT_SOURCE_DIR}/input.txt
1509 byproduct.txt # timestamp may not change
1510 ...
1511 The BYPRODUCTS option is used by the Ninja generator to list byproducts
1513 among the outputs of the custom commands that generate them, and is
1514 ignored by other generators.
1515 CMake 3.3 and above prefer to require projects to specify custom com‐
1517 mand byproducts explicitly so that it can avoid using the phony rule
1518 workaround altogether. Policy CMP0058 was introduced to provide com‐
1519 patibility with existing projects that still need the workaround.
1520 This policy has no effect on generators other than Ninja. The OLD
1522 behavior for this policy is to generate Ninja phony rules for unknown
1523 dependencies in the build tree. The NEW behavior for this policy is to
1524 not generate these and instead require projects to specify custom com‐
1525 mand BYPRODUCTS explicitly.
1526 This policy was introduced in CMake version 3.3. CMake version 3.17.2
1528 warns when it sees unknown dependencies in out-of-source build trees if
1529 the policy is not set and then uses OLD behavior. Use the cmake_pol‐
1530 icy() command to set the policy to OLD or NEW explicitly. The policy
1531 setting must be in scope at the end of the top-level CMakeLists.txt
1532 file of the project and has global effect.
1533 NOTE:
1535 The OLD behavior of a policy is deprecated by definition and may be
1536 removed in a future version of CMake.
1537 CMP0057
1539 Support new if() IN_LIST operator.
1540 CMake 3.3 adds support for the new IN_LIST operator.
1542 The OLD behavior for this policy is to ignore the IN_LIST operator.
1544 The NEW behavior is to interpret the IN_LIST operator.
1545 This policy was introduced in CMake version 3.3. CMake version 3.17.2
1547 warns when the policy is not set and uses OLD behavior. Use the
1548 cmake_policy() command to set it to OLD or NEW explicitly.
1549 NOTE:
1551 The OLD behavior of a policy is deprecated by definition and may be
1552 removed in a future version of CMake.
1553
1555 CMP0056
1556 Honor link flags in try_compile() source-file signature.
1557 The try_compile() command source-file signature generates a CMake‐
1559 Lists.txt file to build the source file into an executable. In order
1560 to compile the source the same way as it might be compiled by the call‐
1561 ing project, the generated project sets the value of the
1562 CMAKE_<LANG>_FLAGS variable to that in the calling project. The value
1563 of the CMAKE_EXE_LINKER_FLAGS variable may be needed in some cases too,
1564 but CMake 3.1 and lower did not set it in the generated project. CMake
1565 3.2 and above prefer to set it so that linker flags are honored as well
1566 as compiler flags. This policy provides compatibility with the pre-3.2
1567 behavior.
1568 The OLD behavior for this policy is to not set the value of the
1570 CMAKE_EXE_LINKER_FLAGS variable in the generated test project. The NEW
1571 behavior for this policy is to set the value of the
1572 CMAKE_EXE_LINKER_FLAGS variable in the test project to the same as it
1573 is in the calling project.
1574 If the project code does not set the policy explicitly, users may set
1576 it on the command line by defining the CMAKE_POLICY_DEFAULT_CMP0056
1577 variable in the cache.
1578 This policy was introduced in CMake version 3.2. Unlike most policies,
1580 CMake version 3.17.2 does not warn by default when this policy is not
1581 set and simply uses OLD behavior. See documentation of the CMAKE_POL‐
1582 ICY_WARNING_CMP0056 variable to control the warning.
1583 NOTE:
1585 The OLD behavior of a policy is deprecated by definition and may be
1586 removed in a future version of CMake.
1587 CMP0055
1589 Strict checking for the break() command.
1590 CMake 3.1 and lower allowed calls to the break() command outside of a
1592 loop context and also ignored any given arguments. This was undefined
1593 behavior.
1594 The OLD behavior for this policy is to allow break() to be placed out‐
1596 side of loop contexts and ignores any arguments. The NEW behavior for
1597 this policy is to issue an error if a misplaced break or any arguments
1598 are found.
1599 This policy was introduced in CMake version 3.2. CMake version 3.17.2
1601 warns when the policy is not set and uses OLD behavior. Use the
1602 cmake_policy() command to set it to OLD or NEW explicitly.
1603 NOTE:
1605 The OLD behavior of a policy is deprecated by definition and may be
1606 removed in a future version of CMake.
1607
1609 CMP0054
1610 Only interpret if() arguments as variables or keywords when unquoted.
1611 CMake 3.1 and above no longer implicitly dereference variables or
1613 interpret keywords in an if() command argument when it is a Quoted
1614 Argument or a Bracket Argument.
1615 The OLD behavior for this policy is to dereference variables and inter‐
1617 pret keywords even if they are quoted or bracketed. The NEW behavior
1618 is to not dereference variables or interpret keywords that have been
1619 quoted or bracketed.
1620 Given the following partial example:
1622 set(A E)
1624 set(E "")
1625 if("${A}" STREQUAL "")
1627 message("Result is TRUE before CMake 3.1 or when CMP0054 is OLD")
1628 else()
1629 message("Result is FALSE in CMake 3.1 and above if CMP0054 is NEW")
1630 endif()
1631 After explicit expansion of variables this gives:
1633 if("E" STREQUAL "")
1635 With the policy set to OLD implicit expansion reduces this semantically
1637 to:
1638 if("" STREQUAL "")
1640 With the policy set to NEW the quoted arguments will not be further
1642 dereferenced:
1643 if("E" STREQUAL "")
1645 This policy was introduced in CMake version 3.1. CMake version 3.17.2
1647 warns when the policy is not set and uses OLD behavior. Use the
1648 cmake_policy() command to set it to OLD or NEW explicitly.
1649 NOTE:
1651 The OLD behavior of a policy is deprecated by definition and may be
1652 removed in a future version of CMake.
1653 CMP0053
1655 Simplify variable reference and escape sequence evaluation.
1656 CMake 3.1 introduced a much faster implementation of evaluation of the
1658 Variable References and Escape Sequences documented in the cmake-lan‐
1659 guage(7) manual. While the behavior is identical to the legacy imple‐
1660 mentation in most cases, some corner cases were cleaned up to simplify
1661 the behavior. Specifically:
1662 · Expansion of @VAR@ reference syntax defined by the configure_file()
1664 and string(CONFIGURE) commands is no longer performed in other con‐
1665 texts.
1666 · Literal ${VAR} reference syntax may contain only alphanumeric charac‐
1668 ters (A-Z, a-z, 0-9) and the characters _, ., /, -, and +. Note that
1669 $ is technically allowed in the NEW behavior, but is invalid for OLD
1670 behavior. This is due to an oversight during the implementation of
1671 CMP0053 and its use as a literal variable reference is discouraged
1672 for this reason. Variables with other characters in their name may
1673 still be referenced indirectly, e.g.
1674 set(varname "otherwise & disallowed $ characters")
1676 message("${${varname}}")
1677 · The setting of policy CMP0010 is not considered, so improper variable
1679 reference syntax is always an error.
1680 · More characters are allowed to be escaped in variable names. Previ‐
1682 ously, only ()#" \@^ were valid characters to escape. Now any
1683 non-alphanumeric, non-semicolon, non-NUL character may be escaped
1684 following the escape_identity production in the Escape Sequences sec‐
1685 tion of the cmake-language(7) manual.
1686 The OLD behavior for this policy is to honor the legacy behavior for
1688 variable references and escape sequences. The NEW behavior is to use
1689 the simpler variable expansion and escape sequence evaluation rules.
1690 This policy was introduced in CMake version 3.1. CMake version 3.17.2
1692 warns when the policy is not set and uses OLD behavior. Use the
1693 cmake_policy() command to set it to OLD or NEW explicitly.
1694 NOTE:
1696 The OLD behavior of a policy is deprecated by definition and may be
1697 removed in a future version of CMake.
1698 CMP0052
1700 Reject source and build dirs in installed INTERFACE_INCLUDE_DIRECTO‐
1701 RIES.
1702 CMake 3.0 and lower allowed subdirectories of the source directory or
1704 build directory to be in the INTERFACE_INCLUDE_DIRECTORIES of installed
1705 and exported targets, if the directory was also a subdirectory of the
1706 installation prefix. This makes the installation depend on the exis‐
1707 tence of the source dir or binary dir, and the installation will be
1708 broken if either are removed after installation.
1709 See Include Directories and Usage Requirements for more on specifying
1711 include directories for targets.
1712 The OLD behavior for this policy is to export the content of the INTER‐
1714 FACE_INCLUDE_DIRECTORIES with the source or binary directory. The NEW
1715 behavior for this policy is to issue an error if such a directory is
1716 used.
1717 This policy was introduced in CMake version 3.1. CMake version 3.17.2
1719 warns when the policy is not set and uses OLD behavior. Use the
1720 cmake_policy() command to set it to OLD or NEW explicitly.
1721 NOTE:
1723 The OLD behavior of a policy is deprecated by definition and may be
1724 removed in a future version of CMake.
1725 CMP0051
1727 List TARGET_OBJECTS in SOURCES target property.
1728 CMake 3.0 and lower did not include the TARGET_OBJECTS generator
1730 expression when returning the SOURCES target property.
1731 Configure-time CMake code is not able to handle generator expressions.
1733 If using the SOURCES target property at configure time, it may be nec‐
1734 essary to first remove generator expressions using the
1735 string(GENEX_STRIP) command. Generate-time CMake code such as
1736 file(GENERATE) can handle the content without stripping.
1737 The OLD behavior for this policy is to omit TARGET_OBJECTS expressions
1739 from the SOURCES target property. The NEW behavior for this policy is
1740 to include TARGET_OBJECTS expressions in the output.
1741 This policy was introduced in CMake version 3.1. CMake version 3.17.2
1743 warns when the policy is not set and uses OLD behavior. Use the
1744 cmake_policy() command to set it to OLD or NEW explicitly.
1745 NOTE:
1747 The OLD behavior of a policy is deprecated by definition and may be
1748 removed in a future version of CMake.
1749
1751 CMP0050
1752 Disallow add_custom_command SOURCE signatures.
1753 CMake 2.8.12 and lower allowed a signature for add_custom_command()
1755 which specified an input to a command. This was undocumented behavior.
1756 Modern use of CMake associates custom commands with their output,
1757 rather than their input.
1758 The OLD behavior for this policy is to allow the use of add_custom_com‐
1760 mand() SOURCE signatures. The NEW behavior for this policy is to issue
1761 an error if such a signature is used.
1762 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1764 warns when the policy is not set and uses OLD behavior. Use the
1765 cmake_policy() command to set it to OLD or NEW explicitly.
1766 NOTE:
1768 The OLD behavior of a policy is deprecated by definition and may be
1769 removed in a future version of CMake.
1770 CMP0049
1772 Do not expand variables in target source entries.
1773 CMake 2.8.12 and lower performed an extra layer of variable expansion
1775 when evaluating source file names:
1776 set(a_source foo.c)
1778 add_executable(foo \${a_source})
1779 This was undocumented behavior.
1781 The OLD behavior for this policy is to expand such variables when pro‐
1783 cessing the target sources. The NEW behavior for this policy is to
1784 issue an error if such variables need to be expanded.
1785 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1787 warns when the policy is not set and uses OLD behavior. Use the
1788 cmake_policy() command to set it to OLD or NEW explicitly.
1789 NOTE:
1791 The OLD behavior of a policy is deprecated by definition and may be
1792 removed in a future version of CMake.
1793 CMP0048
1795 The project() command manages VERSION variables.
1796 CMake version 3.0 introduced the VERSION option of the project() com‐
1798 mand to specify a project version as well as the name. In order to
1799 keep PROJECT_VERSION and related variables consistent with variable
1800 PROJECT_NAME it is necessary to set the VERSION variables to the empty
1801 string when no VERSION is given to project(). However, this can change
1802 behavior for existing projects that set VERSION variables themselves
1803 since project() may now clear them. This policy controls the behavior
1804 for compatibility with such projects.
1805 The OLD behavior for this policy is to leave VERSION variables
1807 untouched. The NEW behavior for this policy is to set VERSION as docu‐
1808 mented by the project() command.
1809 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1811 warns when the policy is not set and uses OLD behavior. Use the
1812 cmake_policy() command to set it to OLD or NEW explicitly.
1813 NOTE:
1815 The OLD behavior of a policy is deprecated by definition and may be
1816 removed in a future version of CMake.
1817 CMP0047
1819 Use QCC compiler id for the qcc drivers on QNX.
1820 CMake 3.0 and above recognize that the QNX qcc compiler driver is dif‐
1822 ferent from the GNU compiler. CMake now prefers to present this to
1823 projects by setting the CMAKE_<LANG>_COMPILER_ID variable to QCC
1824 instead of GNU. However, existing projects may assume the compiler id
1825 for QNX qcc is just GNU as it was in CMake versions prior to 3.0.
1826 Therefore this policy determines for QNX qcc which compiler id to
1827 report in the CMAKE_<LANG>_COMPILER_ID variable after language <LANG>
1828 is enabled by the project() or enable_language() command. The policy
1829 must be set prior to the invocation of either command.
1830 The OLD behavior for this policy is to use the GNU compiler id for the
1832 qcc and QCC compiler drivers. The NEW behavior for this policy is to
1833 use the QCC compiler id for those drivers.
1834 This policy was introduced in CMake version 3.0. Use the cmake_pol‐
1836 icy() command to set this policy to OLD or NEW explicitly. Unlike most
1837 policies, CMake version 3.17.2 does not warn by default when this pol‐
1838 icy is not set and simply uses OLD behavior. See documentation of the
1839 CMAKE_POLICY_WARNING_CMP0047 variable to control the warning.
1840 NOTE:
1842 The OLD behavior of a policy is deprecated by definition and may be
1843 removed in a future version of CMake.
1844 CMP0046
1846 Error on non-existent dependency in add_dependencies.
1847 CMake 2.8.12 and lower silently ignored non-existent dependencies
1849 listed in the add_dependencies() command.
1850 The OLD behavior for this policy is to silently ignore non-existent
1852 dependencies. The NEW behavior for this policy is to report an error if
1853 non-existent dependencies are listed in the add_dependencies() command.
1854 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1856 warns when the policy is not set and uses OLD behavior. Use the
1857 cmake_policy() command to set it to OLD or NEW explicitly.
1858 NOTE:
1860 The OLD behavior of a policy is deprecated by definition and may be
1861 removed in a future version of CMake.
1862 CMP0045
1864 Error on non-existent target in get_target_property.
1865 In CMake 2.8.12 and lower, the get_target_property() command accepted a
1867 non-existent target argument without issuing any error or warning. The
1868 result variable is set to a -NOTFOUND value.
1869 The OLD behavior for this policy is to issue no warning and set the
1871 result variable to a -NOTFOUND value. The NEW behavior for this policy
1872 is to issue a FATAL_ERROR if the command is called with a non-existent
1873 target.
1874 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1876 warns when the policy is not set and uses OLD behavior. Use the
1877 cmake_policy() command to set it to OLD or NEW explicitly.
1878 NOTE:
1880 The OLD behavior of a policy is deprecated by definition and may be
1881 removed in a future version of CMake.
1882 CMP0044
1884 Case sensitive <LANG>_COMPILER_ID generator expressions
1885 CMake 2.8.12 introduced the <LANG>_COMPILER_ID generator expressions to
1887 allow comparison of the CMAKE_<LANG>_COMPILER_ID with a test value.
1888 The possible valid values are lowercase, but the comparison with the
1889 test value was performed case-insensitively.
1890 The OLD behavior for this policy is to perform a case-insensitive com‐
1892 parison with the value in the <LANG>_COMPILER_ID expression. The NEW
1893 behavior for this policy is to perform a case-sensitive comparison with
1894 the value in the <LANG>_COMPILER_ID expression.
1895 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1897 warns when the policy is not set and uses OLD behavior. Use the
1898 cmake_policy() command to set it to OLD or NEW explicitly.
1899 NOTE:
1901 The OLD behavior of a policy is deprecated by definition and may be
1902 removed in a future version of CMake.
1903 CMP0043
1905 Ignore COMPILE_DEFINITIONS_<Config> properties
1906 CMake 2.8.12 and lower allowed setting the COMPILE_DEFINITIONS_<CONFIG>
1908 target property and COMPILE_DEFINITIONS_<CONFIG> directory property to
1909 apply configuration-specific compile definitions.
1910 Since CMake 2.8.10, the COMPILE_DEFINITIONS property has supported gen‐
1912 erator expressions for setting configuration-dependent content. The
1913 continued existence of the suffixed variables is redundant, and causes
1914 a maintenance burden. Population of the COMPILE_DEFINITIONS_DEBUG
1915 property may be replaced with a population of COMPILE_DEFINITIONS
1916 directly or via target_compile_definitions():
1917 # Old Interfaces:
1919 set_property(TARGET tgt APPEND PROPERTY
1920 COMPILE_DEFINITIONS_DEBUG DEBUG_MODE
1921 )
1922 set_property(DIRECTORY APPEND PROPERTY
1923 COMPILE_DEFINITIONS_DEBUG DIR_DEBUG_MODE
1924 )
1925 # New Interfaces:
1927 set_property(TARGET tgt APPEND PROPERTY
1928 COMPILE_DEFINITIONS $<$<CONFIG:Debug>:DEBUG_MODE>
1929 )
1930 target_compile_definitions(tgt PRIVATE $<$<CONFIG:Debug>:DEBUG_MODE>)
1931 set_property(DIRECTORY APPEND PROPERTY
1932 COMPILE_DEFINITIONS $<$<CONFIG:Debug>:DIR_DEBUG_MODE>
1933 )
1934 The OLD behavior for this policy is to consume the content of the suf‐
1936 fixed COMPILE_DEFINITIONS_<CONFIG> target property when generating the
1937 compilation command. The NEW behavior for this policy is to ignore the
1938 content of the COMPILE_DEFINITIONS_<CONFIG> target property .
1939 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1941 warns when the policy is not set and uses OLD behavior. Use the
1942 cmake_policy() command to set it to OLD or NEW explicitly.
1943 NOTE:
1945 The OLD behavior of a policy is deprecated by definition and may be
1946 removed in a future version of CMake.
1947 CMP0042
1949 MACOSX_RPATH is enabled by default.
1950 CMake 2.8.12 and newer has support for using @rpath in a target’s
1952 install name. This was enabled by setting the target property
1953 MACOSX_RPATH. The @rpath in an install name is a more flexible and
1954 powerful mechanism than @executable_path or @loader_path for locating
1955 shared libraries.
1956 CMake 3.0 and later prefer this property to be ON by default. Projects
1958 wanting @rpath in a target’s install name may remove any setting of the
1959 INSTALL_NAME_DIR and CMAKE_INSTALL_NAME_DIR variables.
1960 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1962 warns when the policy is not set and uses OLD behavior. Use the
1963 cmake_policy() command to set it to OLD or NEW explicitly.
1964 NOTE:
1966 The OLD behavior of a policy is deprecated by definition and may be
1967 removed in a future version of CMake.
1968 CMP0041
1970 Error on relative include with generator expression.
1971 Diagnostics in CMake 2.8.12 and lower silently ignored an entry in the
1973 INTERFACE_INCLUDE_DIRECTORIES of a target if it contained a generator
1974 expression at any position.
1975 The path entries in that target property should not be relative.
1977 High-level API should ensure that by adding either a source directory
1978 or a install directory prefix, as appropriate.
1979 As an additional diagnostic, the INTERFACE_INCLUDE_DIRECTORIES gener‐
1981 ated on an IMPORTED target for the install location should not contain
1982 paths in the source directory or the build directory.
1983 The OLD behavior for this policy is to ignore relative path entries if
1985 they contain a generator expression. The NEW behavior for this policy
1986 is to report an error if a generator expression appears in another
1987 location and the path is relative.
1988 This policy was introduced in CMake version 3.0. CMake version 3.17.2
1990 warns when the policy is not set and uses OLD behavior. Use the
1991 cmake_policy() command to set it to OLD or NEW explicitly.
1992 NOTE:
1994 The OLD behavior of a policy is deprecated by definition and may be
1995 removed in a future version of CMake.
1996 CMP0040
1998 The target in the TARGET signature of add_custom_command() must exist
1999 and must be defined in the current directory.
2000 CMake 2.8.12 and lower silently ignored a custom command created with
2002 the TARGET signature of add_custom_command() if the target is unknown
2003 or was defined outside the current directory.
2004 The OLD behavior for this policy is to ignore custom commands for
2006 unknown targets. The NEW behavior for this policy is to report an
2007 error if the target referenced in add_custom_command() is unknown or
2008 was defined outside the current directory.
2009 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2011 warns when the policy is not set and uses OLD behavior. Use the
2012 cmake_policy() command to set it to OLD or NEW explicitly.
2013 NOTE:
2015 The OLD behavior of a policy is deprecated by definition and may be
2016 removed in a future version of CMake.
2017 CMP0039
2019 Utility targets may not have link dependencies.
2020 CMake 2.8.12 and lower allowed using utility targets in the left hand
2022 side position of the target_link_libraries() command. This is an indi‐
2023 cator of a bug in user code.
2024 The OLD behavior for this policy is to ignore attempts to set the link
2026 libraries of utility targets. The NEW behavior for this policy is to
2027 report an error if an attempt is made to set the link libraries of a
2028 utility target.
2029 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2031 warns when the policy is not set and uses OLD behavior. Use the
2032 cmake_policy() command to set it to OLD or NEW explicitly.
2033 NOTE:
2035 The OLD behavior of a policy is deprecated by definition and may be
2036 removed in a future version of CMake.
2037 CMP0038
2039 Targets may not link directly to themselves.
2040 CMake 2.8.12 and lower allowed a build target to link to itself
2042 directly with a target_link_libraries() call. This is an indicator of a
2043 bug in user code.
2044 The OLD behavior for this policy is to ignore targets which list them‐
2046 selves in their own link implementation. The NEW behavior for this
2047 policy is to report an error if a target attempts to link to itself.
2048 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2050 warns when the policy is not set and uses OLD behavior. Use the
2051 cmake_policy() command to set it to OLD or NEW explicitly.
2052 NOTE:
2054 The OLD behavior of a policy is deprecated by definition and may be
2055 removed in a future version of CMake.
2056 CMP0037
2058 Target names should not be reserved and should match a validity pat‐
2059 tern.
2060 CMake 2.8.12 and lower allowed creating targets using add_library(),
2062 add_executable() and add_custom_target() with unrestricted choice for
2063 the target name. Newer cmake features such as cmake-generator-expres‐
2064 sions(7) and some diagnostics expect target names to match a restricted
2065 pattern.
2066 Target names may contain upper and lower case letters, numbers, the
2068 underscore character (_), dot(.), plus(+) and minus(-). As a special
2069 case, ALIAS and IMPORTED targets may contain two consecutive colons.
2070 Target names reserved by one or more CMake generators are not allowed.
2072 Among others these include all, clean, help, and install.
2073 Target names associated with optional features, such as test and pack‐
2075 age, may also be reserved. CMake 3.10 and below always reserve them.
2076 CMake 3.11 and above reserve them only when the corresponding feature
2077 is enabled (e.g. by including the CTest or CPack modules).
2078 The OLD behavior for this policy is to allow creating targets with
2080 reserved names or which do not match the validity pattern. The NEW
2081 behavior for this policy is to report an error if an add_* command is
2082 used with an invalid target name.
2083 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2085 warns when the policy is not set and uses OLD behavior. Use the
2086 cmake_policy() command to set it to OLD or NEW explicitly.
2087 NOTE:
2089 The OLD behavior of a policy is deprecated by definition and may be
2090 removed in a future version of CMake.
2091 CMP0036
2093 The build_name() command should not be called.
2094 This command was added in May 2001 to compute a name for the current
2096 operating system and compiler combination. The command has long been
2097 documented as discouraged and replaced by the CMAKE_SYSTEM and
2098 CMAKE_<LANG>_COMPILER variables.
2099 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2101 ior for this policy is to allow the command to be called. The NEW
2102 behavior for this policy is to issue a FATAL_ERROR when the command is
2103 called.
2104 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2106 warns when the policy is not set and uses OLD behavior. Use the
2107 cmake_policy() command to set it to OLD or NEW explicitly.
2108 NOTE:
2110 The OLD behavior of a policy is deprecated by definition and may be
2111 removed in a future version of CMake.
2112 CMP0035
2114 The variable_requires() command should not be called.
2115 This command was introduced in November 2001 to perform some condi‐
2117 tional logic. It has long been replaced by the if() command.
2118 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2120 ior for this policy is to allow the command to be called. The NEW
2121 behavior for this policy is to issue a FATAL_ERROR when the command is
2122 called.
2123 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2125 warns when the policy is not set and uses OLD behavior. Use the
2126 cmake_policy() command to set it to OLD or NEW explicitly.
2127 NOTE:
2129 The OLD behavior of a policy is deprecated by definition and may be
2130 removed in a future version of CMake.
2131 CMP0034
2133 The utility_source() command should not be called.
2134 This command was introduced in March 2001 to help build executables
2136 used to generate other files. This approach has long been replaced by
2137 add_executable() combined with add_custom_command().
2138 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2140 ior for this policy is to allow the command to be called. The NEW
2141 behavior for this policy is to issue a FATAL_ERROR when the command is
2142 called.
2143 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2145 warns when the policy is not set and uses OLD behavior. Use the
2146 cmake_policy() command to set it to OLD or NEW explicitly.
2147 NOTE:
2149 The OLD behavior of a policy is deprecated by definition and may be
2150 removed in a future version of CMake.
2151 CMP0033
2153 The export_library_dependencies() command should not be called.
2154 This command was added in January 2003 to export <tgt>_LIB_DEPENDS
2156 internal CMake cache entries to a file for installation with a project.
2157 This was used at the time to allow transitive link dependencies to work
2158 for applications outside of the original build tree of a project. The
2159 functionality has been superseded by the export() and install(EXPORT)
2160 commands.
2161 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2163 ior for this policy is to allow the command to be called. The NEW
2164 behavior for this policy is to issue a FATAL_ERROR when the command is
2165 called.
2166 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2168 warns when the policy is not set and uses OLD behavior. Use the
2169 cmake_policy() command to set it to OLD or NEW explicitly.
2170 NOTE:
2172 The OLD behavior of a policy is deprecated by definition and may be
2173 removed in a future version of CMake.
2174 CMP0032
2176 The output_required_files() command should not be called.
2177 This command was added in June 2001 to expose the then-current CMake
2179 implicit dependency scanner. CMake’s real implicit dependency scanner
2180 has evolved since then but is not exposed through this command. The
2181 scanning capabilities of this command are very limited and this func‐
2182 tionality is better achieved through dedicated outside tools.
2183 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2185 ior for this policy is to allow the command to be called. The NEW
2186 behavior for this policy is to issue a FATAL_ERROR when the command is
2187 called.
2188 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2190 warns when the policy is not set and uses OLD behavior. Use the
2191 cmake_policy() command to set it to OLD or NEW explicitly.
2192 NOTE:
2194 The OLD behavior of a policy is deprecated by definition and may be
2195 removed in a future version of CMake.
2196 CMP0031
2198 The load_command() command should not be called.
2199 This command was added in August 2002 to allow projects to add arbi‐
2201 trary commands implemented in C or C++. However, it does not work when
2202 the toolchain in use does not match the ABI of the CMake process. It
2203 has been mostly superseded by the macro() and function() commands.
2204 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2206 ior for this policy is to allow the command to be called. The NEW
2207 behavior for this policy is to issue a FATAL_ERROR when the command is
2208 called.
2209 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2211 warns when the policy is not set and uses OLD behavior. Use the
2212 cmake_policy() command to set it to OLD or NEW explicitly.
2213 NOTE:
2215 The OLD behavior of a policy is deprecated by definition and may be
2216 removed in a future version of CMake.
2217 CMP0030
2219 The use_mangled_mesa() command should not be called.
2220 This command was created in September 2001 to support VTK before modern
2222 CMake language and custom command capabilities. VTK has not used it in
2223 years.
2224 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2226 ior for this policy is to allow the command to be called. The NEW
2227 behavior for this policy is to issue a FATAL_ERROR when the command is
2228 called.
2229 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2231 warns when the policy is not set and uses OLD behavior. Use the
2232 cmake_policy() command to set it to OLD or NEW explicitly.
2233 NOTE:
2235 The OLD behavior of a policy is deprecated by definition and may be
2236 removed in a future version of CMake.
2237 CMP0029
2239 The subdir_depends() command should not be called.
2240 The implementation of this command has been empty since December 2001
2242 but was kept in CMake for compatibility for a long time.
2243 CMake >= 3.0 prefer that this command never be called. The OLD behav‐
2245 ior for this policy is to allow the command to be called. The NEW
2246 behavior for this policy is to issue a FATAL_ERROR when the command is
2247 called.
2248 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2250 warns when the policy is not set and uses OLD behavior. Use the
2251 cmake_policy() command to set it to OLD or NEW explicitly.
2252 NOTE:
2254 The OLD behavior of a policy is deprecated by definition and may be
2255 removed in a future version of CMake.
2256 CMP0028
2258 Double colon in target name means ALIAS or IMPORTED target.
2259 CMake 2.8.12 and lower allowed the use of targets and files with double
2261 colons in target_link_libraries(), with some buildsystem generators.
2262 The use of double-colons is a common pattern used to namespace IMPORTED
2264 targets and ALIAS targets. When computing the link dependencies of a
2265 target, the name of each dependency could either be a target, or a file
2266 on disk. Previously, if a target was not found with a matching name,
2267 the name was considered to refer to a file on disk. This can lead to
2268 confusing error messages if there is a typo in what should be a target
2269 name.
2270 The OLD behavior for this policy is to search for targets, then files
2272 on disk, even if the search term contains double-colons. The NEW
2273 behavior for this policy is to issue a FATAL_ERROR if a link dependency
2274 contains double-colons but is not an IMPORTED target or an ALIAS tar‐
2275 get.
2276 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2278 warns when the policy is not set and uses OLD behavior. Use the
2279 cmake_policy() command to set it to OLD or NEW explicitly.
2280 NOTE:
2282 The OLD behavior of a policy is deprecated by definition and may be
2283 removed in a future version of CMake.
2284 CMP0027
2286 Conditionally linked imported targets with missing include directories.
2287 CMake 2.8.11 introduced introduced the concept of INTER‐
2289 FACE_INCLUDE_DIRECTORIES, and a check at cmake time that the entries in
2290 the INTERFACE_INCLUDE_DIRECTORIES of an IMPORTED target actually exist.
2291 CMake 2.8.11 also introduced generator expression support in the tar‐
2292 get_link_libraries() command. However, if an imported target is linked
2293 as a result of a generator expression evaluation, the entries in the
2294 INTERFACE_INCLUDE_DIRECTORIES of that target were not checked for exis‐
2295 tence as they should be.
2296 The OLD behavior of this policy is to report a warning if an entry in
2298 the INTERFACE_INCLUDE_DIRECTORIES of a generator-expression condition‐
2299 ally linked IMPORTED target does not exist.
2300 The NEW behavior of this policy is to report an error if an entry in
2302 the INTERFACE_INCLUDE_DIRECTORIES of a generator-expression condition‐
2303 ally linked IMPORTED target does not exist.
2304 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2306 warns when the policy is not set and uses OLD behavior. Use the
2307 cmake_policy() command to set it to OLD or NEW explicitly.
2308 NOTE:
2310 The OLD behavior of a policy is deprecated by definition and may be
2311 removed in a future version of CMake.
2312 CMP0026
2314 Disallow use of the LOCATION property for build targets.
2315 CMake 2.8.12 and lower allowed reading the LOCATION target property
2317 (and configuration-specific variants) to determine the eventual loca‐
2318 tion of build targets. This relies on the assumption that all neces‐
2319 sary information is available at configure-time to determine the final
2320 location and filename of the target. However, this property is not
2321 fully determined until later at generate-time. At generate time, the
2322 $<TARGET_FILE> generator expression can be used to determine the even‐
2323 tual LOCATION of a target output.
2324 Code which reads the LOCATION target property can be ported to use the
2326 $<TARGET_FILE> generator expression together with the file(GENERATE)
2327 subcommand to generate a file containing the target location.
2328 The OLD behavior for this policy is to allow reading the LOCATION prop‐
2330 erties from build-targets. The NEW behavior for this policy is to not
2331 to allow reading the LOCATION properties from build-targets.
2332 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2334 warns when the policy is not set and uses OLD behavior. Use the
2335 cmake_policy() command to set it to OLD or NEW explicitly.
2336 NOTE:
2338 The OLD behavior of a policy is deprecated by definition and may be
2339 removed in a future version of CMake.
2340 CMP0025
2342 Compiler id for Apple Clang is now AppleClang.
2343 CMake 3.0 and above recognize that Apple Clang is a different compiler
2345 than upstream Clang and that they have different version numbers.
2346 CMake now prefers to present this to projects by setting the
2347 CMAKE_<LANG>_COMPILER_ID variable to AppleClang instead of Clang. How‐
2348 ever, existing projects may assume the compiler id for Apple Clang is
2349 just Clang as it was in CMake versions prior to 3.0. Therefore this
2350 policy determines for Apple Clang which compiler id to report in the
2351 CMAKE_<LANG>_COMPILER_ID variable after language <LANG> is enabled by
2352 the project() or enable_language() command. The policy must be set
2353 prior to the invocation of either command.
2354 The OLD behavior for this policy is to use compiler id Clang. The NEW
2356 behavior for this policy is to use compiler id AppleClang.
2357 This policy was introduced in CMake version 3.0. Use the cmake_pol‐
2359 icy() command to set this policy to OLD or NEW explicitly. Unlike most
2360 policies, CMake version 3.17.2 does not warn by default when this pol‐
2361 icy is not set and simply uses OLD behavior. See documentation of the
2362 CMAKE_POLICY_WARNING_CMP0025 variable to control the warning.
2363 NOTE:
2365 The OLD behavior of a policy is deprecated by definition and may be
2366 removed in a future version of CMake.
2367 CMP0024
2369 Disallow include export result.
2370 CMake 2.8.12 and lower allowed use of the include() command with the
2372 result of the export() command. This relies on the assumption that the
2373 export() command has an immediate effect at configure-time during a
2374 cmake run. Certain properties of targets are not fully determined
2375 until later at generate-time, such as the link language and complete
2376 list of link libraries. Future refactoring will change the effect of
2377 the export() command to be executed at generate-time. Use ALIAS tar‐
2378 gets instead in cases where the goal is to refer to targets by another
2379 name.
2380 The OLD behavior for this policy is to allow including the result of an
2382 export() command. The NEW behavior for this policy is not to allow
2383 including the result of an export() command.
2384 This policy was introduced in CMake version 3.0. CMake version 3.17.2
2386 warns when the policy is not set and uses OLD behavior. Use the
2387 cmake_policy() command to set it to OLD or NEW explicitly.
2388 NOTE:
2390 The OLD behavior of a policy is deprecated by definition and may be
2391 removed in a future version of CMake.
2392
2394 CMP0023
2395 Plain and keyword target_link_libraries() signatures cannot be mixed.
2396 CMake 2.8.12 introduced the target_link_libraries() signature using the
2398 PUBLIC, PRIVATE, and INTERFACE keywords to generalize the LINK_PUBLIC
2399 and LINK_PRIVATE keywords introduced in CMake 2.8.7. Use of signatures
2400 with any of these keywords sets the link interface of a target explic‐
2401 itly, even if empty. This produces confusing behavior when used in
2402 combination with the historical behavior of the plain tar‐
2403 get_link_libraries() signature. For example, consider the code:
2404 target_link_libraries(mylib A)
2406 target_link_libraries(mylib PRIVATE B)
2407 After the first line the link interface has not been set explicitly so
2409 CMake would use the link implementation, A, as the link interface.
2410 However, the second line sets the link interface to empty. In order to
2411 avoid this subtle behavior CMake now prefers to disallow mixing the
2412 plain and keyword signatures of target_link_libraries() for a single
2413 target.
2414 The OLD behavior for this policy is to allow keyword and plain tar‐
2416 get_link_libraries() signatures to be mixed. The NEW behavior for this
2417 policy is to not to allow mixing of the keyword and plain signatures.
2418 This policy was introduced in CMake version 2.8.12. CMake version
2420 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2421 cmake_policy() command to set it to OLD or NEW explicitly.
2422 NOTE:
2424 The OLD behavior of a policy is deprecated by definition and may be
2425 removed in a future version of CMake.
2426 CMP0022
2428 INTERFACE_LINK_LIBRARIES defines the link interface.
2429 CMake 2.8.11 constructed the ‘link interface’ of a target from proper‐
2431 ties matching (IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?. The
2432 modern way to specify config-sensitive content is to use generator
2433 expressions and the IMPORTED_ prefix makes uniform processing of the
2434 link interface with generator expressions impossible. The INTER‐
2435 FACE_LINK_LIBRARIES target property was introduced as a replacement in
2436 CMake 2.8.12. This new property is named consistently with the INTER‐
2437 FACE_COMPILE_DEFINITIONS, INTERFACE_INCLUDE_DIRECTORIES and INTER‐
2438 FACE_COMPILE_OPTIONS properties. For in-build targets, CMake will use
2439 the INTERFACE_LINK_LIBRARIES property as the source of the link inter‐
2440 face only if policy CMP0022 is NEW. When exporting a target which has
2441 this policy set to NEW, only the INTERFACE_LINK_LIBRARIES property will
2442 be processed and generated for the IMPORTED target by default. A new
2443 option to the install(EXPORT) and export commands allows export of the
2444 old-style properties for compatibility with downstream users of CMake
2445 versions older than 2.8.12. The target_link_libraries() command will
2446 no longer populate the properties matching LINK_INTER‐
2447 FACE_LIBRARIES(_<CONFIG>)? if this policy is NEW.
2448 Warning-free future-compatible code which works with CMake 2.8.7
2450 onwards can be written by using the LINK_PRIVATE and LINK_PUBLIC key‐
2451 words of target_link_libraries().
2452 The OLD behavior for this policy is to ignore the INTER‐
2454 FACE_LINK_LIBRARIES property for in-build targets. The NEW behavior
2455 for this policy is to use the INTERFACE_LINK_LIBRARIES property for
2456 in-build targets, and ignore the old properties matching
2457 (IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?.
2458 This policy was introduced in CMake version 2.8.12. CMake version
2460 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2461 cmake_policy() command to set it to OLD or NEW explicitly.
2462 NOTE:
2464 The OLD behavior of a policy is deprecated by definition and may be
2465 removed in a future version of CMake.
2466 CMP0021
2468 Fatal error on relative paths in INCLUDE_DIRECTORIES target property.
2469 CMake 2.8.10.2 and lower allowed the INCLUDE_DIRECTORIES target prop‐
2471 erty to contain relative paths. The base path for such relative
2472 entries is not well defined. CMake 2.8.12 issues a FATAL_ERROR if the
2473 INCLUDE_DIRECTORIES property contains a relative path.
2474 The OLD behavior for this policy is not to warn about relative paths in
2476 the INCLUDE_DIRECTORIES target property. The NEW behavior for this
2477 policy is to issue a FATAL_ERROR if INCLUDE_DIRECTORIES contains a rel‐
2478 ative path.
2479 This policy was introduced in CMake version 2.8.12. CMake version
2481 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2482 cmake_policy() command to set it to OLD or NEW explicitly.
2483 NOTE:
2485 The OLD behavior of a policy is deprecated by definition and may be
2486 removed in a future version of CMake.
2487 CMP0020
2489 Automatically link Qt executables to qtmain target on Windows.
2490 CMake 2.8.10 and lower required users of Qt to always specify a link
2492 dependency to the qtmain.lib static library manually on Windows. CMake
2493 2.8.11 gained the ability to evaluate generator expressions while
2494 determining the link dependencies from IMPORTED targets. This allows
2495 CMake itself to automatically link executables which link to Qt to the
2496 qtmain.lib library when using IMPORTED Qt targets. For applications
2497 already linking to qtmain.lib, this should have little impact. For
2498 applications which supply their own alternative WinMain implementation
2499 and for applications which use the QAxServer library, this automatic
2500 linking will need to be disabled as per the documentation.
2501 The OLD behavior for this policy is not to link executables to
2503 qtmain.lib automatically when they link to the QtCore IMPORTED target.
2504 The NEW behavior for this policy is to link executables to qtmain.lib
2505 automatically when they link to QtCore IMPORTED target.
2506 This policy was introduced in CMake version 2.8.11. CMake version
2508 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2509 cmake_policy() command to set it to OLD or NEW explicitly.
2510 NOTE:
2512 The OLD behavior of a policy is deprecated by definition and may be
2513 removed in a future version of CMake.
2514 CMP0019
2516 Do not re-expand variables in include and link information.
2517 CMake 2.8.10 and lower re-evaluated values given to the include_direc‐
2519 tories, link_directories, and link_libraries commands to expand any
2520 leftover variable references at the end of the configuration step.
2521 This was for strict compatibility with VERY early CMake versions
2522 because all variable references are now normally evaluated during CMake
2523 language processing. CMake 2.8.11 and higher prefer to skip the extra
2524 evaluation.
2525 The OLD behavior for this policy is to re-evaluate the values for
2527 strict compatibility. The NEW behavior for this policy is to leave the
2528 values untouched.
2529 This policy was introduced in CMake version 2.8.11. CMake version
2531 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2532 cmake_policy() command to set it to OLD or NEW explicitly.
2533 NOTE:
2535 The OLD behavior of a policy is deprecated by definition and may be
2536 removed in a future version of CMake.
2537 CMP0018
2539 Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.
2540 CMake 2.8.8 and lower compiled sources in SHARED and MODULE libraries
2542 using the value of the undocumented CMAKE_SHARED_LIBRARY_<Lang>_FLAGS
2543 platform variable. The variable contained platform-specific flags
2544 needed to compile objects for shared libraries. Typically it included
2545 a flag such as -fPIC for position independent code but also included
2546 other flags needed on certain platforms. CMake 2.8.9 and higher prefer
2547 instead to use the POSITION_INDEPENDENT_CODE target property to deter‐
2548 mine what targets should be position independent, and new undocumented
2549 platform variables to select flags while ignoring
2550 CMAKE_SHARED_LIBRARY_<Lang>_FLAGS completely.
2551 The default for either approach produces identical compilation flags,
2553 but if a project modifies CMAKE_SHARED_LIBRARY_<Lang>_FLAGS from its
2554 original value this policy determines which approach to use.
2555 The OLD behavior for this policy is to ignore the POSITION_INDEPEN‐
2557 DENT_CODE property for all targets and use the modified value of
2558 CMAKE_SHARED_LIBRARY_<Lang>_FLAGS for SHARED and MODULE libraries.
2559 The NEW behavior for this policy is to ignore
2561 CMAKE_SHARED_LIBRARY_<Lang>_FLAGS whether it is modified or not and
2562 honor the POSITION_INDEPENDENT_CODE target property.
2563 This policy was introduced in CMake version 2.8.9. CMake version
2565 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2566 cmake_policy() command to set it to OLD or NEW explicitly.
2567 NOTE:
2569 The OLD behavior of a policy is deprecated by definition and may be
2570 removed in a future version of CMake.
2571 CMP0017
2573 Prefer files from the CMake module directory when including from there.
2574 Starting with CMake 2.8.4, if a cmake-module shipped with CMake (i.e.
2576 located in the CMake module directory) calls include() or find_pack‐
2577 age(), the files located in the CMake module directory are preferred
2578 over the files in CMAKE_MODULE_PATH. This makes sure that the modules
2579 belonging to CMake always get those files included which they expect,
2580 and against which they were developed and tested. In all other cases,
2581 the files found in CMAKE_MODULE_PATH still take precedence over the
2582 ones in the CMake module directory. The OLD behavior is to always pre‐
2583 fer files from CMAKE_MODULE_PATH over files from the CMake modules
2584 directory.
2585 This policy was introduced in CMake version 2.8.4. CMake version
2587 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2588 cmake_policy() command to set it to OLD or NEW explicitly.
2589 NOTE:
2591 The OLD behavior of a policy is deprecated by definition and may be
2592 removed in a future version of CMake.
2593 CMP0016
2595 target_link_libraries() reports error if its only argument is not a
2596 target.
2597 In CMake 2.8.2 and lower the target_link_libraries() command silently
2599 ignored if it was called with only one argument, and this argument
2600 wasn’t a valid target. In CMake 2.8.3 and above it reports an error in
2601 this case.
2602 This policy was introduced in CMake version 2.8.3. CMake version
2604 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2605 cmake_policy() command to set it to OLD or NEW explicitly.
2606 NOTE:
2608 The OLD behavior of a policy is deprecated by definition and may be
2609 removed in a future version of CMake.
2610 CMP0015
2612 link_directories() treats paths relative to the source dir.
2613 In CMake 2.8.0 and lower the link_directories() command passed relative
2615 paths unchanged to the linker. In CMake 2.8.1 and above the
2616 link_directories() command prefers to interpret relative paths with
2617 respect to CMAKE_CURRENT_SOURCE_DIR, which is consistent with
2618 include_directories() and other commands. The OLD behavior for this
2619 policy is to use relative paths verbatim in the linker command. The
2620 NEW behavior for this policy is to convert relative paths to absolute
2621 paths by appending the relative path to CMAKE_CURRENT_SOURCE_DIR.
2622 This policy was introduced in CMake version 2.8.1. CMake version
2624 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2625 cmake_policy() command to set it to OLD or NEW explicitly.
2626 NOTE:
2628 The OLD behavior of a policy is deprecated by definition and may be
2629 removed in a future version of CMake.
2630 CMP0014
2632 Input directories must have CMakeLists.txt.
2633 CMake versions before 2.8 silently ignored missing CMakeLists.txt files
2635 in directories referenced by add_subdirectory() or subdirs(), treating
2636 them as if present but empty. In CMake 2.8.0 and above this cmake_pol‐
2637 icy() determines whether or not the case is an error. The OLD behavior
2638 for this policy is to silently ignore the problem. The NEW behavior
2639 for this policy is to report an error.
2640 This policy was introduced in CMake version 2.8.0. CMake version
2642 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2643 cmake_policy() command to set it to OLD or NEW explicitly.
2644 NOTE:
2646 The OLD behavior of a policy is deprecated by definition and may be
2647 removed in a future version of CMake.
2648 CMP0013
2650 Duplicate binary directories are not allowed.
2651 CMake 2.6.3 and below silently permitted add_subdirectory() calls to
2653 create the same binary directory multiple times. During build system
2654 generation files would be written and then overwritten in the build
2655 tree and could lead to strange behavior. CMake 2.6.4 and above explic‐
2656 itly detect duplicate binary directories. CMake 2.6.4 always considers
2657 this case an error. In CMake 2.8.0 and above this policy determines
2658 whether or not the case is an error. The OLD behavior for this policy
2659 is to allow duplicate binary directories. The NEW behavior for this
2660 policy is to disallow duplicate binary directories with an error.
2661 This policy was introduced in CMake version 2.8.0. CMake version
2663 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2664 cmake_policy() command to set it to OLD or NEW explicitly.
2665 NOTE:
2667 The OLD behavior of a policy is deprecated by definition and may be
2668 removed in a future version of CMake.
2669 CMP0012
2671 if() recognizes numbers and boolean constants.
2672 In CMake versions 2.6.4 and lower the if() command implicitly derefer‐
2674 enced arguments corresponding to variables, even those named like num‐
2675 bers or boolean constants, except for 0 and 1. Numbers and boolean
2676 constants such as true, false, yes, no, on, off, y, n, notfound, ignore
2677 (all case insensitive) were recognized in some cases but not all. For
2678 example, the code if(TRUE) might have evaluated as false. Numbers such
2679 as 2 were recognized only in boolean expressions like if(NOT 2) (lead‐
2680 ing to false) but not as a single-argument like if(2) (also leading to
2681 false). Later versions of CMake prefer to treat numbers and boolean
2682 constants literally, so they should not be used as variable names.
2683 The OLD behavior for this policy is to implicitly dereference variables
2685 named like numbers and boolean constants. The NEW behavior for this
2686 policy is to recognize numbers and boolean constants without derefer‐
2687 encing variables with such names.
2688 This policy was introduced in CMake version 2.8.0. CMake version
2690 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2691 cmake_policy() command to set it to OLD or NEW explicitly.
2692 NOTE:
2694 The OLD behavior of a policy is deprecated by definition and may be
2695 removed in a future version of CMake.
2696
2698 CMP0011
2699 Included scripts do automatic cmake_policy() PUSH and POP.
2700 In CMake 2.6.2 and below, CMake Policy settings in scripts loaded by
2702 the include() and find_package() commands would affect the includer.
2703 Explicit invocations of cmake_policy(PUSH) and cmake_policy(POP) were
2704 required to isolate policy changes and protect the includer. While
2705 some scripts intend to affect the policies of their includer, most do
2706 not. In CMake 2.6.3 and above, include() and find_package() by default
2707 PUSH and POP an entry on the policy stack around an included script,
2708 but provide a NO_POLICY_SCOPE option to disable it. This policy deter‐
2709 mines whether or not to imply NO_POLICY_SCOPE for compatibility. The
2710 OLD behavior for this policy is to imply NO_POLICY_SCOPE for include()
2711 and find_package() commands. The NEW behavior for this policy is to
2712 allow the commands to do their default cmake_policy PUSH and POP.
2713 This policy was introduced in CMake version 2.6.3. CMake version
2715 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2716 cmake_policy() command to set it to OLD or NEW explicitly.
2717 NOTE:
2719 The OLD behavior of a policy is deprecated by definition and may be
2720 removed in a future version of CMake.
2721 CMP0010
2723 Bad variable reference syntax is an error.
2724 In CMake 2.6.2 and below, incorrect variable reference syntax such as a
2726 missing close-brace (${FOO) was reported but did not stop processing of
2727 CMake code. This policy determines whether a bad variable reference is
2728 an error. The OLD behavior for this policy is to warn about the error,
2729 leave the string untouched, and continue. The NEW behavior for this
2730 policy is to report an error.
2731 If CMP0053 is set to NEW, this policy has no effect and is treated as
2733 always being NEW.
2734 This policy was introduced in CMake version 2.6.3. CMake version
2736 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2737 cmake_policy() command to set it to OLD or NEW explicitly.
2738 NOTE:
2740 The OLD behavior of a policy is deprecated by definition and may be
2741 removed in a future version of CMake.
2742 CMP0009
2744 FILE GLOB_RECURSE calls should not follow symlinks by default.
2745 In CMake 2.6.1 and below, file(GLOB_RECURSE) calls would follow through
2747 symlinks, sometimes coming up with unexpectedly large result sets
2748 because of symlinks to top level directories that contain hundreds of
2749 thousands of files.
2750 This policy determines whether or not to follow symlinks encountered
2752 during a file(GLOB_RECURSE) call. The OLD behavior for this policy is
2753 to follow the symlinks. The NEW behavior for this policy is not to
2754 follow the symlinks by default, but only if FOLLOW_SYMLINKS is given as
2755 an additional argument to the FILE command.
2756 This policy was introduced in CMake version 2.6.2. CMake version
2758 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2759 cmake_policy() command to set it to OLD or NEW explicitly.
2760 NOTE:
2762 The OLD behavior of a policy is deprecated by definition and may be
2763 removed in a future version of CMake.
2764 CMP0008
2766 Libraries linked by full-path must have a valid library file name.
2767 In CMake 2.4 and below it is possible to write code like
2769 target_link_libraries(myexe /full/path/to/somelib)
2771 where somelib is supposed to be a valid library file name such as lib‐
2773 somelib.a or somelib.lib. For Makefile generators this produces an
2774 error at build time because the dependency on the full path cannot be
2775 found. For Visual Studio Generators IDE and Xcode generators this used
2776 to work by accident because CMake would always split off the library
2777 directory and ask the linker to search for the library by name
2778 (-lsomelib or somelib.lib). Despite the failure with Makefiles, some
2779 projects have code like this and build only with Visual Studio and/or
2780 Xcode. This version of CMake prefers to pass the full path directly to
2781 the native build tool, which will fail in this case because it does not
2782 name a valid library file.
2783 This policy determines what to do with full paths that do not appear to
2785 name a valid library file. The OLD behavior for this policy is to
2786 split the library name from the path and ask the linker to search for
2787 it. The NEW behavior for this policy is to trust the given path and
2788 pass it directly to the native build tool unchanged.
2789 This policy was introduced in CMake version 2.6.1. CMake version
2791 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2792 cmake_policy() command to set it to OLD or NEW explicitly.
2793 NOTE:
2795 The OLD behavior of a policy is deprecated by definition and may be
2796 removed in a future version of CMake.
2797 CMP0007
2799 list command no longer ignores empty elements.
2800 This policy determines whether the list command will ignore empty ele‐
2802 ments in the list. CMake 2.4 and below list commands ignored all empty
2803 elements in the list. For example, a;b;;c would have length 3 and not
2804 4. The OLD behavior for this policy is to ignore empty list elements.
2805 The NEW behavior for this policy is to correctly count empty elements
2806 in a list.
2807 This policy was introduced in CMake version 2.6.0. CMake version
2809 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2810 cmake_policy() command to set it to OLD or NEW explicitly.
2811 NOTE:
2813 The OLD behavior of a policy is deprecated by definition and may be
2814 removed in a future version of CMake.
2815 CMP0006
2817 Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
2818 This policy determines whether the install(TARGETS) command must be
2820 given a BUNDLE DESTINATION when asked to install a target with the
2821 MACOSX_BUNDLE property set. CMake 2.4 and below did not distinguish
2822 application bundles from normal executables when installing targets.
2823 CMake 2.6 provides a BUNDLE option to the install(TARGETS) command that
2824 specifies rules specific to application bundles on the Mac. Projects
2825 should use this option when installing a target with the MACOSX_BUNDLE
2826 property set.
2827 The OLD behavior for this policy is to fall back to the RUNTIME DESTI‐
2829 NATION if a BUNDLE DESTINATION is not given. The NEW behavior for this
2830 policy is to produce an error if a bundle target is installed without a
2831 BUNDLE DESTINATION.
2832 This policy was introduced in CMake version 2.6.0. CMake version
2834 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2835 cmake_policy() command to set it to OLD or NEW explicitly.
2836 NOTE:
2838 The OLD behavior of a policy is deprecated by definition and may be
2839 removed in a future version of CMake.
2840 CMP0005
2842 Preprocessor definition values are now escaped automatically.
2843 This policy determines whether or not CMake should generate escaped
2845 preprocessor definition values added via add_definitions. CMake ver‐
2846 sions 2.4 and below assumed that only trivial values would be given for
2847 macros in add_definitions calls. It did not attempt to escape
2848 non-trivial values such as string literals in generated build rules.
2849 CMake versions 2.6 and above support escaping of most values, but can‐
2850 not assume the user has not added escapes already in an attempt to work
2851 around limitations in earlier versions.
2852 The OLD behavior for this policy is to place definition values given to
2854 add_definitions directly in the generated build rules without attempt‐
2855 ing to escape anything. The NEW behavior for this policy is to gener‐
2856 ate correct escapes for all native build tools automatically. See doc‐
2857 umentation of the COMPILE_DEFINITIONS target property for limitations
2858 of the escaping implementation.
2859 This policy was introduced in CMake version 2.6.0. CMake version
2861 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2862 cmake_policy() command to set it to OLD or NEW explicitly.
2863 NOTE:
2865 The OLD behavior of a policy is deprecated by definition and may be
2866 removed in a future version of CMake.
2867 CMP0004
2869 Libraries linked may not have leading or trailing whitespace.
2870 CMake versions 2.4 and below silently removed leading and trailing
2872 whitespace from libraries linked with code like
2873 target_link_libraries(myexe " A ")
2875 This could lead to subtle errors in user projects.
2877 The OLD behavior for this policy is to silently remove leading and
2879 trailing whitespace. The NEW behavior for this policy is to diagnose
2880 the existence of such whitespace as an error. The setting for this
2881 policy used when checking the library names is that in effect when the
2882 target is created by an add_executable() or add_library() command.
2883 This policy was introduced in CMake version 2.6.0. CMake version
2885 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2886 cmake_policy() command to set it to OLD or NEW explicitly.
2887 NOTE:
2889 The OLD behavior of a policy is deprecated by definition and may be
2890 removed in a future version of CMake.
2891 CMP0003
2893 Libraries linked via full path no longer produce linker search paths.
2894 This policy affects how libraries whose full paths are NOT known are
2896 found at link time, but was created due to a change in how CMake deals
2897 with libraries whose full paths are known. Consider the code
2898 target_link_libraries(myexe /path/to/libA.so)
2900 CMake 2.4 and below implemented linking to libraries whose full paths
2902 are known by splitting them on the link line into separate components
2903 consisting of the linker search path and the library name. The example
2904 code might have produced something like
2905 ... -L/path/to -lA ...
2907 in order to link to library A. An analysis was performed to order mul‐
2909 tiple link directories such that the linker would find library A in the
2910 desired location, but there are cases in which this does not work.
2911 CMake versions 2.6 and above use the more reliable approach of passing
2912 the full path to libraries directly to the linker in most cases. The
2913 example code now produces something like
2914 ... /path/to/libA.so ....
2916 Unfortunately this change can break code like
2918 target_link_libraries(myexe /path/to/libA.so B)
2920 where B is meant to find /path/to/libB.so. This code is wrong because
2922 the user is asking the linker to find library B but has not provided a
2923 linker search path (which may be added with the link_directories com‐
2924 mand). However, with the old linking implementation the code would
2925 work accidentally because the linker search path added for library A
2926 allowed library B to be found.
2927 In order to support projects depending on linker search paths added by
2929 linking to libraries with known full paths, the OLD behavior for this
2930 policy will add the linker search paths even though they are not needed
2931 for their own libraries. When this policy is set to OLD, CMake will
2932 produce a link line such as
2933 ... -L/path/to /path/to/libA.so -lB ...
2935 which will allow library B to be found as it was previously. When this
2937 policy is set to NEW, CMake will produce a link line such as
2938 ... /path/to/libA.so -lB ...
2940 which more accurately matches what the project specified.
2942 The setting for this policy used when generating the link line is that
2944 in effect when the target is created by an add_executable or
2945 add_library command. For the example described above, the code
2946 cmake_policy(SET CMP0003 OLD) # or cmake_policy(VERSION 2.4)
2948 add_executable(myexe myexe.c)
2949 target_link_libraries(myexe /path/to/libA.so B)
2950 will work and suppress the warning for this policy. It may also be
2952 updated to work with the corrected linking approach:
2953 cmake_policy(SET CMP0003 NEW) # or cmake_policy(VERSION 2.6)
2955 link_directories(/path/to) # needed to find library B
2956 add_executable(myexe myexe.c)
2957 target_link_libraries(myexe /path/to/libA.so B)
2958 Even better, library B may be specified with a full path:
2960 add_executable(myexe myexe.c)
2962 target_link_libraries(myexe /path/to/libA.so /path/to/libB.so)
2963 When all items on the link line have known paths CMake does not check
2965 this policy so it has no effect.
2966 Note that the warning for this policy will be issued for at most one
2968 target. This avoids flooding users with messages for every target when
2969 setting the policy once will probably fix all targets.
2970 This policy was introduced in CMake version 2.6.0. CMake version
2972 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
2973 cmake_policy() command to set it to OLD or NEW explicitly.
2974 NOTE:
2976 The OLD behavior of a policy is deprecated by definition and may be
2977 removed in a future version of CMake.
2978 CMP0002
2980 Logical target names must be globally unique.
2981 Targets names created with add_executable(), add_library(), or add_cus‐
2983 tom_target() are logical build target names. Logical target names must
2984 be globally unique because:
2985 - Unique names may be referenced unambiguously both in CMake
2987 code and on make tool command lines.
2988 - Logical names are used by Xcode and VS IDE generators
2989 to produce meaningful project names for the targets.
2990 The logical name of executable and library targets does not have to
2992 correspond to the physical file names built. Consider using the OUT‐
2993 PUT_NAME target property to create two targets with the same physical
2994 name while keeping logical names distinct. Custom targets must simply
2995 have globally unique names (unless one uses the global property
2996 ALLOW_DUPLICATE_CUSTOM_TARGETS with a Makefiles generator).
2997 This policy was introduced in CMake version 2.6.0. CMake version
2999 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
3000 cmake_policy() command to set it to OLD or NEW explicitly.
3001 NOTE:
3003 The OLD behavior of a policy is deprecated by definition and may be
3004 removed in a future version of CMake.
3005 CMP0001
3007 CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
3008 The behavior is to check CMAKE_BACKWARDS_COMPATIBILITY and present it
3010 to the user. The NEW behavior is to ignore CMAKE_BACKWARDS_COMPATIBIL‐
3011 ITY completely.
3012 In CMake 2.4 and below the variable CMAKE_BACKWARDS_COMPATIBILITY was
3014 used to request compatibility with earlier versions of CMake. In CMake
3015 2.6 and above all compatibility issues are handled by policies and the
3016 cmake_policy() command. However, CMake must still check CMAKE_BACK‐
3017 WARDS_COMPATIBILITY for projects written for CMake 2.4 and below.
3018 This policy was introduced in CMake version 2.6.0. CMake version
3020 3.17.2 warns when the policy is not set and uses OLD behavior. Use the
3021 cmake_policy() command to set it to OLD or NEW explicitly.
3022 NOTE:
3024 The OLD behavior of a policy is deprecated by definition and may be
3025 removed in a future version of CMake.
3026 CMP0000
3028 A minimum required CMake version must be specified.
3029 CMake requires that projects specify the version of CMake to which they
3031 have been written. This policy has been put in place so users trying
3032 to build the project may be told when they need to update their CMake.
3033 Specifying a version also helps the project build with CMake versions
3034 newer than that specified. Use the cmake_minimum_required() command at
3035 the top of your main CMakeLists.txt file:
3036 cmake_minimum_required(VERSION <major>.<minor>)
3038 where <major>.<minor> is the version of CMake you want to support (such
3040 as 3.14). The command will ensure that at least the given version of
3041 CMake is running and help newer versions be compatible with the
3042 project. See documentation of cmake_minimum_required() for details.
3043 Note that the command invocation must appear in the CMakeLists.txt file
3045 itself; a call in an included file is not sufficient. However, the
3046 cmake_policy() command may be called to set policy CMP0000 to OLD or
3047 NEW behavior explicitly. The OLD behavior is to silently ignore the
3048 missing invocation. The NEW behavior is to issue an error instead of a
3049 warning. An included file may set CMP0000 explicitly to affect how
3050 this policy is enforced for the main CMakeLists.txt file.
3051 This policy was introduced in CMake version 2.6.0.
3053 NOTE:
3055 The OLD behavior of a policy is deprecated by definition and may be
3056 removed in a future version of CMake.
3057
3059 2000-2020 Kitware, Inc. and Contributors
30603.17.2 Apr 28, 2020 CMAKE-POLICIES(7)