reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-23 11:39:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c587b8d026
CMake/Modules/CMakeParseImplicitLinkInfo.cmake

205 lines
8.5 KiB
CMake
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 19:01:08 +00:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
Protect implicit link library extraction with policy CMP0054 CMakeParseImplicitLinkInfo tests arbitrary content with `if(MATCHES)`. Set policy CMP0054 to ensure the line content is never interpreted as a variable reference (which may also produce a CMP0054 warning). While at it, also set policy CMP0053 to improve performance.
2018-07-10 13:25:10 +00:00
cmake_policy(PUSH)
cmake_policy(SET CMP0053 NEW)
cmake_policy(SET CMP0054 NEW)
Convert CMake non-find modules to BSD License This adds copyright/license notification blocks CMake's non-find modules. Most of the modules had no notices at all. Some had notices referring to the BSD license already. This commit normalizes existing notices and adds missing notices.
2009-09-28 15:46:51 +00:00
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
# Function parse implicit linker options.
# This is used internally by CMake and should not be included by user
# code.
OS X: Detect implicit linker framework search paths Previously we hard-coded a list of implicit framework directories but did not account for CMAKE_OSX_SYSROOT or for changes to the list across OS X versions. Instead we should automatically detect the framework directories for the active toolchain. The parent commit added the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays a block such as: Framework search paths: /... Parse this block to extract the list of framework directories. Detection may fail on toolchains that do not list their framework directories, such as older OS X linkers. Always treat the paths <sdk>/Library/Frameworks <sdk>/System/Library/Frameworks <sdk>/Network/Library/Frameworks # Older OS X only /System/Library/Frameworks as implicit. Note that /System/Library/Frameworks should always be considered implicit so that frameworks CMake finds there will not override the SDK copies.
2012-12-05 18:46:04 +00:00
function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj_regex)
Remove non-language implicit link dependencies Some compilers use implicit link options of the form -lcrt*.o -lgcc* -lSystem (on Mac) -lSystemStubs (on Mac) that provide system-wide symbols not specific to any language. These need not be listed explicitly for mixed-language linking. We teach CMake to remove the above items from the implicit library list of each language. This change makes it possible to mix GNU compiler versions in some cases.
2009-11-05 17:17:08 +00:00
set(implicit_libs_tmp "")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
set(implicit_dirs_tmp)
OS X: Detect implicit linker framework search paths Previously we hard-coded a list of implicit framework directories but did not account for CMAKE_OSX_SYSROOT or for changes to the list across OS X versions. Instead we should automatically detect the framework directories for the active toolchain. The parent commit added the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays a block such as: Framework search paths: /... Parse this block to extract the list of framework directories. Detection may fail on toolchains that do not list their framework directories, such as older OS X linkers. Always treat the paths <sdk>/Library/Frameworks <sdk>/System/Library/Frameworks <sdk>/Network/Library/Frameworks # Older OS X only /System/Library/Frameworks as implicit. Note that /System/Library/Frameworks should always be considered implicit so that frameworks CMake finds there will not override the SDK copies.
2012-12-05 18:46:04 +00:00
set(implicit_fwks_tmp)
Log implicit link information parsing actions This commit teaches the CMAKE_PARSE_IMPLICIT_LINK_INFO function to log its actions. We store the log in CMakeFiles/CMakeOutput.log at the top of the project build tree. This will make diagnosis of implicit link information parsing problems easier.
2009-10-06 19:16:12 +00:00
set(log "")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
# Parse implicit linker arguments.
set(linker "CMAKE_LINKER-NOTFOUND")
if(CMAKE_LINKER)
get_filename_component(linker ${CMAKE_LINKER} NAME)
Sanitize linker name to parse implicit link line (#14154) Teach CMakeParseImplicitLinkInfo to convert the CMAKE_LINKER file name to a regular expression that matches only the original name. Escape special characters like '+' so they are not treated as regex syntax. Extend the ImplicitLinkInfoTest to test handling of a CMAKE_LINKER value with many special characters.
2013-05-17 12:42:07 +00:00
string(REGEX REPLACE "([][+.*?()^$])" "\\\\\\1" linker "${linker}")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
endif()
ImplicitLinkInfo: Add support for PGI on Windows Since PGI does not write linker directives into objects, the necessary libraries have to be parsed from commandline. PGI does however link the Visual C++ runtime libraries, so they have to be filtered out to ensure no collision with settings of other languages can occur.
2017-05-12 17:03:16 +00:00
set(startfile "CMAKE_LINK_STARTFILE-NOTFOUND")
if(CMAKE_LINK_STARTFILE)
set(startfile "${CMAKE_LINK_STARTFILE}")
endif()
More robust implicit link line detection regex The regex used by CMAKE_PARSE_IMPLICIT_LINK_INFO to detect link lines should not match lines that happen to have ".../ld.../..." in them. A linker name should match only as the last component of a path. See issue #9666.
2009-10-07 12:43:51 +00:00
# Construct a regex to match linker lines. It must match both the
# whole line and just the command (argv[0]).
ImplicitLinkInfo: Add support for PGI on Windows Since PGI does not write linker directives into objects, the necessary libraries have to be parsed from commandline. PGI does however link the Visual C++ runtime libraries, so they have to be filtered out to ensure no collision with settings of other languages can occur.
2017-05-12 17:03:16 +00:00
set(linker_regex "^( *|.*[/\\])(${linker}|${startfile}|([^/\\]+-)?ld|collect2)[^/\\]*( |$)")
CMakeParseImplicitLinkInfo: Exclude pathcc ldfe lines (#16100) PathScale uses a wrapper around the linker. The "ldfe" invocation in the output is followed by a normal "ld" invocation. Exclude the former so we can reach and parse the latter correctly.
2016-05-11 17:52:31 +00:00
set(linker_exclude_regex "collect2 version |^[A-Za-z0-9_]+=|/ldfe ")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " link line regex: [${linker_regex}]\n")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
string(REGEX REPLACE "\r?\n" ";" output_lines "${text}")
foreach(line IN LISTS output_lines)
set(cmd)
Absoft: Detect implicit link libraries on Linux and Mac Use the "-X -v" flag to the Absoft front-end to pass "-v" to the gcc it invokes under the hood. Teach CMakeParseImplicitLinkInfo to exclude linker version lines from consideration as link lines. Fix parsing of Sun's linker search path option "-Y..." to avoid conflict with the Mac linker option "-Y<num>".
2011-01-24 16:18:18 +00:00
if("${line}" MATCHES "${linker_regex}" AND
NOT "${line}" MATCHES "${linker_exclude_regex}")
OS X: Detect implicit link directories on modern toolchains We detect the implicit link directories for the toolchain by adding a flag to get verbose output from the compiler front-end while linking the ABI detection binary. Newer OS X toolchains based on Clang do not add the implicit link directories with -L options to their internal invocation of "ld". Instead they use a linker that comes with the toolchain and is already configured with the proper directories. Add the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays them in a block such as: Library search paths: /... Parse this block to extract the implicit link directories. While at it, remove the checks introduced by commit efaf335b (Skip implicit link information on Xcode, 2009-07-23) and commit 5195a664 (Skip implicit link info for multiple OS X archs, 2009-09-22). Discard the non-system link directories added by Xcode. Discard all detected implicit libraries in the multi-architecture case but keep the directories. The directories are still useful without the libraries just to suppress addition of explicit -L options for them.
2012-12-05 16:49:13 +00:00
if(XCODE)
# Xcode unconditionally adds a path under the project build tree and
# on older versions it is not reported with proper quotes. Remove it.
string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" _dir_regex "${CMAKE_BINARY_DIR}")
string(REGEX REPLACE " -[FL]${_dir_regex}/([^ ]| [^-])+( |$)" " " xline "${line}")
if(NOT "x${xline}" STREQUAL "x${line}")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " reduced line: [${line}]\n to: [${xline}]\n")
OS X: Detect implicit link directories on modern toolchains We detect the implicit link directories for the toolchain by adding a flag to get verbose output from the compiler front-end while linking the ABI detection binary. Newer OS X toolchains based on Clang do not add the implicit link directories with -L options to their internal invocation of "ld". Instead they use a linker that comes with the toolchain and is already configured with the proper directories. Add the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays them in a block such as: Library search paths: /... Parse this block to extract the implicit link directories. While at it, remove the checks introduced by commit efaf335b (Skip implicit link information on Xcode, 2009-07-23) and commit 5195a664 (Skip implicit link info for multiple OS X archs, 2009-09-22). Discard the non-system link directories added by Xcode. Discard all detected implicit libraries in the multi-architecture case but keep the directories. The directories are still useful without the libraries just to suppress addition of explicit -L options for them.
2012-12-05 16:49:13 +00:00
set(line "${xline}")
endif()
endif()
separgs: Use NATIVE_COMMAND where appropriate
2017-04-26 18:34:23 +00:00
separate_arguments(args NATIVE_COMMAND "${line}")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
list(GET args 0 cmd)
CMakeParseImplicitLinkInfo supports comma separated link lines It is currently presumed that the linker will generate a space separated line. This is not the case for some compilers such as IBM XL where it can output space or comma separated. This is particularly apparent when IBM XL is used as the host compiler for CUDA as it generates a comma separated link line.
2019-08-23 20:49:27 +00:00
else()
#check to see if the link line is comma-separated instead of space separated
string(REGEX REPLACE "," " " line "${line}")
if("${line}" MATCHES "${linker_regex}" AND
NOT "${line}" MATCHES "${linker_exclude_regex}")
separate_arguments(args NATIVE_COMMAND "${line}")
list(GET args 0 cmd)
if("${cmd}" MATCHES "exec:")
# ibm xl sometimes has 'exec: ' in-front of the linker
list(GET args 1 cmd)
endif()
endif()
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
endif()
CMakeParseImplicitLinkInfo: Add support for MSVC invoked by CUDA nvcc
2016-12-13 16:08:53 +00:00
set(is_msvc 0)
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
if("${cmd}" MATCHES "${linker_regex}")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " link line: [${line}]\n")
BUG: Parse implicit link editor -z*extract options The Sun Fortran compiler passes -zallextract and -zdefaultextract to the linker so that all objects from one of its archives are included in the link. This teaches the implicit options parser to recognize the flags. We need to pass them explicitly on C++ link lines when Fortran code is linked.
2009-07-28 12:36:11 +00:00
string(REGEX REPLACE ";-([LYz]);" ";-\\1" args "${args}")
CMakeParseImplicitLinkInfo: Ignore ld -lto_library flag The `ld` tool in Xcode 8.3 now has a `-lto_library <path>` flag. Ignore the flag instead of accidentally parsing it as `-l` with `to_library`. Fixes: #16766
2017-04-03 17:19:52 +00:00
set(skip_value_of "")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
foreach(arg IN LISTS args)
CMakeParseImplicitLinkInfo: Ignore ld -lto_library flag The `ld` tool in Xcode 8.3 now has a `-lto_library <path>` flag. Ignore the flag instead of accidentally parsing it as `-l` with `to_library`. Fixes: #16766
2017-04-03 17:19:52 +00:00
if(skip_value_of)
string(APPEND log " arg [${arg}] ==> skip value of ${skip_value_of}\n")
set(skip_value_of "")
elseif("${arg}" MATCHES "^-L(.:)?[/\\]")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
# Unix search path.
string(REGEX REPLACE "^-L" "" dir "${arg}")
list(APPEND implicit_dirs_tmp ${dir})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> dir [${dir}]\n")
ImplicitLinkInfo: Add support for PGI on Windows Since PGI does not write linker directives into objects, the necessary libraries have to be parsed from commandline. PGI does however link the Visual C++ runtime libraries, so they have to be filtered out to ensure no collision with settings of other languages can occur.
2017-05-12 17:03:16 +00:00
elseif("${arg}" MATCHES "^[-/](LIBPATH|libpath):(.+)")
CMakeParseImplicitLinkInfo: Add support for MSVC invoked by CUDA nvcc
2016-12-13 16:08:53 +00:00
# MSVC search path.
ImplicitLinkInfo: Add support for PGI on Windows Since PGI does not write linker directives into objects, the necessary libraries have to be parsed from commandline. PGI does however link the Visual C++ runtime libraries, so they have to be filtered out to ensure no collision with settings of other languages can occur.
2017-05-12 17:03:16 +00:00
set(dir "${CMAKE_MATCH_2}")
CMakeParseImplicitLinkInfo: Add support for MSVC invoked by CUDA nvcc
2016-12-13 16:08:53 +00:00
list(APPEND implicit_dirs_tmp ${dir})
string(APPEND log " arg [${arg}] ==> dir [${dir}]\n")
elseif(is_msvc AND "${arg}" STREQUAL "-link")
string(APPEND log " arg [${arg}] ==> ignore MSVC cl option\n")
elseif(is_msvc AND "${arg}" MATCHES "^(.*\\.[Ll][Ii][Bb])$")
set(lib "${CMAKE_MATCH_1}")
list(APPEND implicit_libs_tmp ${lib})
string(APPEND log " arg [${arg}] ==> lib [${lib}]\n")
CMakeParseImplicitLinkInfo: Ignore ld -lto_library flag The `ld` tool in Xcode 8.3 now has a `-lto_library <path>` flag. Ignore the flag instead of accidentally parsing it as `-l` with `to_library`. Fixes: #16766
2017-04-03 17:19:52 +00:00
elseif("${arg}" STREQUAL "-lto_library")
# ld argument "-lto_library <path>"
set(skip_value_of "${arg}")
string(APPEND log " arg [${arg}] ==> ignore, skip following value\n")
Clean up usage of if(... MATCHES regex) followed string(REGEX REPLACE regex) The matches have already been calculated and can simply be taken from CMAKE_MATCH_n variables. This avoids multiple compilations of the same or very similar regular expressions.
2014-04-06 19:30:00 +00:00
elseif("${arg}" MATCHES "^-l([^:].*)$")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
# Unix library.
CMakeParseImplicitLinkInfo: Fix implicit library logging In commit v3.1.0-rc1~640^2~5 (Clean up usage of if(... MATCHES regex) followed string(REGEX REPLACE regex), 2014-04-06) we accidentally broke logging of the implicit library detection. Restore use of the intermediate 'lib' variable so that the log message is constructed properly. Reported-by: Bill Somerville <bill@classdesign.com>
2014-12-01 17:57:57 +00:00
set(lib "${CMAKE_MATCH_1}")
list(APPEND implicit_libs_tmp ${lib})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> lib [${lib}]\n")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
elseif("${arg}" MATCHES "^(.:)?[/\\].*\\.a$")
# Unix library full path.
Remove non-language implicit link dependencies Some compilers use implicit link options of the form -lcrt*.o -lgcc* -lSystem (on Mac) -lSystemStubs (on Mac) that provide system-wide symbols not specific to any language. These need not be listed explicitly for mixed-language linking. We teach CMake to remove the above items from the implicit library list of each language. This change makes it possible to mix GNU compiler versions in some cases.
2009-11-05 17:17:08 +00:00
list(APPEND implicit_libs_tmp ${arg})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> lib [${arg}]\n")
ImplicitLinkInfo: Add support for PGI on Windows Since PGI does not write linker directives into objects, the necessary libraries have to be parsed from commandline. PGI does however link the Visual C++ runtime libraries, so they have to be filtered out to ensure no collision with settings of other languages can occur.
2017-05-12 17:03:16 +00:00
elseif("${arg}" MATCHES "^[-/](DEFAULTLIB|defaultlib):(.+)")
# Windows library.
set(lib "${CMAKE_MATCH_2}")
list(APPEND implicit_libs_tmp ${lib})
string(APPEND log " arg [${arg}] ==> lib [${lib}]\n")
Detect object files in implicit link information The NAG Fortran compiler implicitly passes object files by full path to the linker. Teach CMakeParseImplicitLinkInfo to parse object files that match some tool-specific regular expression.
2010-12-09 22:07:34 +00:00
elseif("${arg}" MATCHES "^(.:)?[/\\].*\\.o$"
AND obj_regex AND "${arg}" MATCHES "${obj_regex}")
# Object file full path.
list(APPEND implicit_libs_tmp ${arg})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> obj [${arg}]\n")
Absoft: Detect implicit link libraries on Linux and Mac Use the "-X -v" flag to the Absoft front-end to pass "-v" to the gcc it invokes under the hood. Teach CMakeParseImplicitLinkInfo to exclude linker version lines from consideration as link lines. Fix parsing of Sun's linker search path option "-Y..." to avoid conflict with the Mac linker option "-Y<num>".
2011-01-24 16:18:18 +00:00
elseif("${arg}" MATCHES "^-Y(P,)?[^0-9]")
# Sun search path ([^0-9] avoids conflict with Mac -Y<num>).
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
string(REGEX REPLACE "^-Y(P,)?" "" dirs "${arg}")
string(REPLACE ":" ";" dirs "${dirs}")
list(APPEND implicit_dirs_tmp ${dirs})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> dirs [${dirs}]\n")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
elseif("${arg}" MATCHES "^-l:")
# HP named library.
Remove non-language implicit link dependencies Some compilers use implicit link options of the form -lcrt*.o -lgcc* -lSystem (on Mac) -lSystemStubs (on Mac) that provide system-wide symbols not specific to any language. These need not be listed explicitly for mixed-language linking. We teach CMake to remove the above items from the implicit library list of each language. This change makes it possible to mix GNU compiler versions in some cases.
2009-11-05 17:17:08 +00:00
list(APPEND implicit_libs_tmp ${arg})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> lib [${arg}]\n")
BUG: Parse implicit link editor -z*extract options The Sun Fortran compiler passes -zallextract and -zdefaultextract to the linker so that all objects from one of its archives are included in the link. This teaches the implicit options parser to recognize the flags. We need to pass them explicitly on C++ link lines when Fortran code is linked.
2009-07-28 12:36:11 +00:00
elseif("${arg}" MATCHES "^-z(all|default|weak)extract")
# Link editor option.
Remove non-language implicit link dependencies Some compilers use implicit link options of the form -lcrt*.o -lgcc* -lSystem (on Mac) -lSystemStubs (on Mac) that provide system-wide symbols not specific to any language. These need not be listed explicitly for mixed-language linking. We teach CMake to remove the above items from the implicit library list of each language. This change makes it possible to mix GNU compiler versions in some cases.
2009-11-05 17:17:08 +00:00
list(APPEND implicit_libs_tmp ${arg})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> opt [${arg}]\n")
CMakeParseImplicitLinkInfo: Add support for MSVC invoked by CUDA nvcc
2016-12-13 16:08:53 +00:00
elseif("${arg}" STREQUAL "cl.exe")
string(APPEND log " arg [${arg}] ==> recognize MSVC cl\n")
set(is_msvc 1)
Log implicit link information parsing actions This commit teaches the CMAKE_PARSE_IMPLICIT_LINK_INFO function to log its actions. We store the log in CMakeFiles/CMakeOutput.log at the top of the project build tree. This will make diagnosis of implicit link information parsing problems easier.
2009-10-06 19:16:12 +00:00
else()
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " arg [${arg}] ==> ignore\n")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
endif()
endforeach()
break()
Clean up usage of if(... MATCHES regex) followed string(REGEX REPLACE regex) The matches have already been calculated and can simply be taken from CMAKE_MATCH_n variables. This avoids multiple compilations of the same or very similar regular expressions.
2014-04-06 19:30:00 +00:00
elseif("${line}" MATCHES "LPATH(=| is:? *)(.*)$")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " LPATH line: [${line}]\n")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
# HP search path.
Clean up usage of if(... MATCHES regex) followed string(REGEX REPLACE regex) The matches have already been calculated and can simply be taken from CMAKE_MATCH_n variables. This avoids multiple compilations of the same or very similar regular expressions.
2014-04-06 19:30:00 +00:00
string(REPLACE ":" ";" paths "${CMAKE_MATCH_2}")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
list(APPEND implicit_dirs_tmp ${paths})
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " dirs [${paths}]\n")
Log implicit link information parsing actions This commit teaches the CMAKE_PARSE_IMPLICIT_LINK_INFO function to log its actions. We store the log in CMakeFiles/CMakeOutput.log at the top of the project build tree. This will make diagnosis of implicit link information parsing problems easier.
2009-10-06 19:16:12 +00:00
else()
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " ignore line: [${line}]\n")
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
endif()
endforeach()
OS X: Detect implicit link directories on modern toolchains We detect the implicit link directories for the toolchain by adding a flag to get verbose output from the compiler front-end while linking the ABI detection binary. Newer OS X toolchains based on Clang do not add the implicit link directories with -L options to their internal invocation of "ld". Instead they use a linker that comes with the toolchain and is already configured with the proper directories. Add the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays them in a block such as: Library search paths: /... Parse this block to extract the implicit link directories. While at it, remove the checks introduced by commit efaf335b (Skip implicit link information on Xcode, 2009-07-23) and commit 5195a664 (Skip implicit link info for multiple OS X archs, 2009-09-22). Discard the non-system link directories added by Xcode. Discard all detected implicit libraries in the multi-architecture case but keep the directories. The directories are still useful without the libraries just to suppress addition of explicit -L options for them.
2012-12-05 16:49:13 +00:00
# Look for library search paths reported by linker.
if("${output_lines}" MATCHES ";Library search paths:((;\t[^;]+)+)")
string(REPLACE ";\t" ";" implicit_dirs_match "${CMAKE_MATCH_1}")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " Library search paths: [${implicit_dirs_match}]\n")
OS X: Detect implicit link directories on modern toolchains We detect the implicit link directories for the toolchain by adding a flag to get verbose output from the compiler front-end while linking the ABI detection binary. Newer OS X toolchains based on Clang do not add the implicit link directories with -L options to their internal invocation of "ld". Instead they use a linker that comes with the toolchain and is already configured with the proper directories. Add the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays them in a block such as: Library search paths: /... Parse this block to extract the implicit link directories. While at it, remove the checks introduced by commit efaf335b (Skip implicit link information on Xcode, 2009-07-23) and commit 5195a664 (Skip implicit link info for multiple OS X archs, 2009-09-22). Discard the non-system link directories added by Xcode. Discard all detected implicit libraries in the multi-architecture case but keep the directories. The directories are still useful without the libraries just to suppress addition of explicit -L options for them.
2012-12-05 16:49:13 +00:00
list(APPEND implicit_dirs_tmp ${implicit_dirs_match})
endif()
OS X: Detect implicit linker framework search paths Previously we hard-coded a list of implicit framework directories but did not account for CMAKE_OSX_SYSROOT or for changes to the list across OS X versions. Instead we should automatically detect the framework directories for the active toolchain. The parent commit added the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays a block such as: Framework search paths: /... Parse this block to extract the list of framework directories. Detection may fail on toolchains that do not list their framework directories, such as older OS X linkers. Always treat the paths <sdk>/Library/Frameworks <sdk>/System/Library/Frameworks <sdk>/Network/Library/Frameworks # Older OS X only /System/Library/Frameworks as implicit. Note that /System/Library/Frameworks should always be considered implicit so that frameworks CMake finds there will not override the SDK copies.
2012-12-05 18:46:04 +00:00
if("${output_lines}" MATCHES ";Framework search paths:((;\t[^;]+)+)")
string(REPLACE ";\t" ";" implicit_fwks_match "${CMAKE_MATCH_1}")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " Framework search paths: [${implicit_fwks_match}]\n")
OS X: Detect implicit linker framework search paths Previously we hard-coded a list of implicit framework directories but did not account for CMAKE_OSX_SYSROOT or for changes to the list across OS X versions. Instead we should automatically detect the framework directories for the active toolchain. The parent commit added the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays a block such as: Framework search paths: /... Parse this block to extract the list of framework directories. Detection may fail on toolchains that do not list their framework directories, such as older OS X linkers. Always treat the paths <sdk>/Library/Frameworks <sdk>/System/Library/Frameworks <sdk>/Network/Library/Frameworks # Older OS X only /System/Library/Frameworks as implicit. Note that /System/Library/Frameworks should always be considered implicit so that frameworks CMake finds there will not override the SDK copies.
2012-12-05 18:46:04 +00:00
list(APPEND implicit_fwks_tmp ${implicit_fwks_match})
endif()
OS X: Detect implicit link directories on modern toolchains We detect the implicit link directories for the toolchain by adding a flag to get verbose output from the compiler front-end while linking the ABI detection binary. Newer OS X toolchains based on Clang do not add the implicit link directories with -L options to their internal invocation of "ld". Instead they use a linker that comes with the toolchain and is already configured with the proper directories. Add the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays them in a block such as: Library search paths: /... Parse this block to extract the implicit link directories. While at it, remove the checks introduced by commit efaf335b (Skip implicit link information on Xcode, 2009-07-23) and commit 5195a664 (Skip implicit link info for multiple OS X archs, 2009-09-22). Discard the non-system link directories added by Xcode. Discard all detected implicit libraries in the multi-architecture case but keep the directories. The directories are still useful without the libraries just to suppress addition of explicit -L options for them.
2012-12-05 16:49:13 +00:00
Remove non-language implicit link dependencies Some compilers use implicit link options of the form -lcrt*.o -lgcc* -lSystem (on Mac) -lSystemStubs (on Mac) that provide system-wide symbols not specific to any language. These need not be listed explicitly for mixed-language linking. We teach CMake to remove the above items from the implicit library list of each language. This change makes it possible to mix GNU compiler versions in some cases.
2009-11-05 17:17:08 +00:00
# Cleanup list of libraries and flags.
# We remove items that are not language-specific.
set(implicit_libs "")
foreach(lib IN LISTS implicit_libs_tmp)
Exclude "libgcc_eh" library files from implicit link libraries Extend the fix in commit v3.9.6~1^2 (Restore exclusion of "gcc_eh" from implicit link libraries, 2017-11-07) to also exclude `gcc_eh` libraries referenced by absolute path to the library file. Issue: #17436
2018-04-16 15:50:05 +00:00
if("x${lib}" MATCHES "^x(crt.*\\.o|gcc_eh.*|.*libgcc_eh.*|System.*|.*libclang_rt.*|msvcrt.*|libvcruntime.*|libucrt.*|libcmt.*)$")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " remove lib [${lib}]\n")
Normalize full paths in implicit link library list Teach CMakeParseImplicitLinkInfo to convert implicit link library full paths to a canonical form. This makes them more reproducible in case different language compiler front-ends add the same library by different paths e.g. ".../libA.a" and "...//libA.a". Add a case to the CMake.ImplicitLinkInfo test to cover removal of extra slashes from both library and directory paths.
2013-02-06 21:21:11 +00:00
elseif(IS_ABSOLUTE "${lib}")
get_filename_component(abs "${lib}" ABSOLUTE)
if(NOT "x${lib}" STREQUAL "x${abs}")
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " collapse lib [${lib}] ==> [${abs}]\n")
Normalize full paths in implicit link library list Teach CMakeParseImplicitLinkInfo to convert implicit link library full paths to a canonical form. This makes them more reproducible in case different language compiler front-ends add the same library by different paths e.g. ".../libA.a" and "...//libA.a". Add a case to the CMake.ImplicitLinkInfo test to cover removal of extra slashes from both library and directory paths.
2013-02-06 21:21:11 +00:00
endif()
list(APPEND implicit_libs "${abs}")
Remove non-language implicit link dependencies Some compilers use implicit link options of the form -lcrt*.o -lgcc* -lSystem (on Mac) -lSystemStubs (on Mac) that provide system-wide symbols not specific to any language. These need not be listed explicitly for mixed-language linking. We teach CMake to remove the above items from the implicit library list of each language. This change makes it possible to mix GNU compiler versions in some cases.
2009-11-05 17:17:08 +00:00
else()
list(APPEND implicit_libs "${lib}")
endif()
endforeach()
OS X: Detect implicit linker framework search paths Previously we hard-coded a list of implicit framework directories but did not account for CMAKE_OSX_SYSROOT or for changes to the list across OS X versions. Instead we should automatically detect the framework directories for the active toolchain. The parent commit added the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays a block such as: Framework search paths: /... Parse this block to extract the list of framework directories. Detection may fail on toolchains that do not list their framework directories, such as older OS X linkers. Always treat the paths <sdk>/Library/Frameworks <sdk>/System/Library/Frameworks <sdk>/Network/Library/Frameworks # Older OS X only /System/Library/Frameworks as implicit. Note that /System/Library/Frameworks should always be considered implicit so that frameworks CMake finds there will not override the SDK copies.
2012-12-05 18:46:04 +00:00
# Cleanup list of library and framework directories.
set(desc_dirs "library")
set(desc_fwks "framework")
foreach(t dirs fwks)
set(implicit_${t} "")
foreach(d IN LISTS implicit_${t}_tmp)
get_filename_component(dir "${d}" ABSOLUTE)
string(FIND "${dir}" "${CMAKE_FILES_DIRECTORY}/" pos)
if(NOT pos LESS 0)
set(msg ", skipping non-system directory")
else()
set(msg "")
list(APPEND implicit_${t} "${dir}")
endif()
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " collapse ${desc_${t}} dir [${d}] ==> [${dir}]${msg}\n")
OS X: Detect implicit linker framework search paths Previously we hard-coded a list of implicit framework directories but did not account for CMAKE_OSX_SYSROOT or for changes to the list across OS X versions. Instead we should automatically detect the framework directories for the active toolchain. The parent commit added the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays a block such as: Framework search paths: /... Parse this block to extract the list of framework directories. Detection may fail on toolchains that do not list their framework directories, such as older OS X linkers. Always treat the paths <sdk>/Library/Frameworks <sdk>/System/Library/Frameworks <sdk>/Network/Library/Frameworks # Older OS X only /System/Library/Frameworks as implicit. Note that /System/Library/Frameworks should always be considered implicit so that frameworks CMake finds there will not override the SDK copies.
2012-12-05 18:46:04 +00:00
endforeach()
list(REMOVE_DUPLICATES implicit_${t})
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
endforeach()
Log implicit link information parsing actions This commit teaches the CMAKE_PARSE_IMPLICIT_LINK_INFO function to log its actions. We store the log in CMakeFiles/CMakeOutput.log at the top of the project build tree. This will make diagnosis of implicit link information parsing problems easier.
2009-10-06 19:16:12 +00:00
# Log results.
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-27 22:41:13 +00:00
string(APPEND log " implicit libs: [${implicit_libs}]\n")
string(APPEND log " implicit dirs: [${implicit_dirs}]\n")
string(APPEND log " implicit fwks: [${implicit_fwks}]\n")
Log implicit link information parsing actions This commit teaches the CMAKE_PARSE_IMPLICIT_LINK_INFO function to log its actions. We store the log in CMakeFiles/CMakeOutput.log at the top of the project build tree. This will make diagnosis of implicit link information parsing problems easier.
2009-10-06 19:16:12 +00:00
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
# Return results.
set(${lib_var} "${implicit_libs}" PARENT_SCOPE)
set(${dir_var} "${implicit_dirs}" PARENT_SCOPE)
OS X: Detect implicit linker framework search paths Previously we hard-coded a list of implicit framework directories but did not account for CMAKE_OSX_SYSROOT or for changes to the list across OS X versions. Instead we should automatically detect the framework directories for the active toolchain. The parent commit added the "-Wl,-v" option to ask "ld" to print its implicit directories. It displays a block such as: Framework search paths: /... Parse this block to extract the list of framework directories. Detection may fail on toolchains that do not list their framework directories, such as older OS X linkers. Always treat the paths <sdk>/Library/Frameworks <sdk>/System/Library/Frameworks <sdk>/Network/Library/Frameworks # Older OS X only /System/Library/Frameworks as implicit. Note that /System/Library/Frameworks should always be considered implicit so that frameworks CMake finds there will not override the SDK copies.
2012-12-05 18:46:04 +00:00
set(${fwk_var} "${implicit_fwks}" PARENT_SCOPE)
Log implicit link information parsing actions This commit teaches the CMAKE_PARSE_IMPLICIT_LINK_INFO function to log its actions. We store the log in CMakeFiles/CMakeOutput.log at the top of the project build tree. This will make diagnosis of implicit link information parsing problems easier.
2009-10-06 19:16:12 +00:00
set(${log_var} "${log}" PARENT_SCOPE)
ENH: Implicit link info for C, CXX, and Fortran This teaches CMake to detect implicit link information for C, C++, and Fortran compilers. We detect the implicit linker search directories and implicit linker options for UNIX-like environments using verbose output from compiler front-ends. We store results in new variables called CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES The implicit libraries can contain linker flags as well as library names.
2009-07-23 14:07:25 +00:00
endfunction()
Protect implicit link library extraction with policy CMP0054 CMakeParseImplicitLinkInfo tests arbitrary content with `if(MATCHES)`. Set policy CMP0054 to ensure the line content is never interpreted as a variable reference (which may also produce a CMP0054 warning). While at it, also set policy CMP0053 to improve performance.
2018-07-10 13:25:10 +00:00
cmake_policy(POP)
Reference in New Issue Copy Permalink