[CMake] Replace llvm_check_linker_flag and llvm_check_compiler_linker_flag

[phosek]

Summary

These are both polyfills for check_linker_flag which was introduced in
CMake 3.18 and now that LLVM requires CMake 3.20 as the minimum version
we can use it to simplify our build.

[mstorsjo]

LGTM, this looks great!

I wonder why we didn't think of that before (in particular, using CMAKE_EXE_LINKER_FLAGS instead of CMAKE_REQUIRED_FLAGS before) - I wonder if there's some pitfalls we don't come to think of right now? I can put this through a full bootstrap build of mine too. And I guess we'll see if the libcxx CI says anything.

What are the practical differences between CMAKE_EXE_LINKER_FLAGS and CMAKE_REQUIRED_FLAGS here - both get used in all linking tests, while CMAKE_REQUIRED_FLAGS also gets used in pure compilation tests (which is suboptimal)? In a large comment in runtimes/CMakeLists.txt, I've noted that we should move to using CMAKE_REQUIRED_LINK_OPTIONS when we can require cmake 3.14 - what would be the differences between CMAKE_REQUIRED_LINK_OPTIONS and CMAKE_EXE_LINKER_FLAGS here?

(I've noted one such difference when testing CMAKE_REQUIRED_LINK_OPTIONS; when testing with CMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY, the flags from CMAKE_REQUIRED_LINK_OPTIONS end up passed to the static library tool, which fails - and that wouldn't be the issue with CMAKE_EXE_LINKER_FLAGS.)

[mstorsjo]

In D143052#4095952, @mstorsjo wrote:

I can put this through a full bootstrap build of mine too.

It built fine in a from-scratch build for me, so it looks good in that aspect!

And I guess we'll see if the libcxx CI says anything.

It seems like the CI is hitting a bunch of seemingly unrelated issues; can you rebase the patch on top of latest main to retrigger the CI, where I'd hope the unrelated issues are fixed?

[phosek]

In D143052#4095952, @mstorsjo wrote:

LGTM, this looks great!

I wonder why we didn't think of that before (in particular, using CMAKE_EXE_LINKER_FLAGS instead of CMAKE_REQUIRED_FLAGS before) - I wonder if there's some pitfalls we don't come to think of right now? I can put this through a full bootstrap build of mine too. And I guess we'll see if the libcxx CI says anything.

What are the practical differences between CMAKE_EXE_LINKER_FLAGS and CMAKE_REQUIRED_FLAGS here - both get used in all linking tests, while CMAKE_REQUIRED_FLAGS also gets used in pure compilation tests (which is suboptimal)? In a large comment in runtimes/CMakeLists.txt, I've noted that we should move to using CMAKE_REQUIRED_LINK_OPTIONS when we can require cmake 3.14 - what would be the differences between CMAKE_REQUIRED_LINK_OPTIONS and CMAKE_EXE_LINKER_FLAGS here?

(I've noted one such difference when testing CMAKE_REQUIRED_LINK_OPTIONS; when testing with CMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY, the flags from CMAKE_REQUIRED_LINK_OPTIONS end up passed to the static library tool, which fails - and that wouldn't be the issue with CMAKE_EXE_LINKER_FLAGS.)

CMAKE_EXE_LINKER_FLAGS instead of CMAKE_REQUIRED_FLAGS serve a different purpose. CMAKE_REQUIRED_FLAGS are applied only to CMake checks whereas CMAKE_EXE_LINKER_FLAGS are also applied to CMake targets so we don't want to be appending flags that are only needed during configuration to it. That's why llvm_check_linker_flag saves and restores CMAKE_EXE_LINKER_FLAGS (at least that was the intention, I found a bug in the implementation that's addressed in D143088).

Furthermoe, the modern CMake approach is to avoid modifying global variables such as CMAKE_EXE_LINKER_FLAGS and instead set flags directly on targets so I think we should avoid relying on that approach in general. Once we update the minimum CMake version, we should switch to CMAKE_REQUIRED_LINK_OPTIONS and check_linker_flag which I think is the best solution.

[mstorsjo]

In D143052#4097128, @phosek wrote:

CMAKE_EXE_LINKER_FLAGS instead of CMAKE_REQUIRED_FLAGS serve a different purpose. CMAKE_REQUIRED_FLAGS are applied only to CMake checks whereas CMAKE_EXE_LINKER_FLAGS are also applied to CMake targets so we don't want to be appending flags that are only needed during configuration to it. That's why llvm_check_linker_flag saves and restores CMAKE_EXE_LINKER_FLAGS (at least that was the intention, I found a bug in the implementation that's addressed in D143088).

Furthermoe, the modern CMake approach is to avoid modifying global variables such as CMAKE_EXE_LINKER_FLAGS and instead set flags directly on targets so I think we should avoid relying on that approach in general. Once we update the minimum CMake version, we should switch to CMAKE_REQUIRED_LINK_OPTIONS and check_linker_flag which I think is the best solution.

Ah, I see - thanks!

Regarding CMAKE_REQUIRED_LINK_OPTIONS, as mentioned before, that one is annoying in practice, but I guess it's still the right way forward. I have a local patch to take that into use, where I've had to add this workaround:

diff --git a/libunwind/CMakeLists.txt b/libunwind/CMakeLists.txt
index 5c547883f992..81b4d42658a5 100644
--- a/libunwind/CMakeLists.txt
+++ b/libunwind/CMakeLists.txt
@@ -231,9 +231,12 @@ add_cxx_compile_flags_if_supported(-EHsc)
 # This leads to libunwind not being built with this flag, which makes
 # libunwind quite useless in this setup.
 set(_previous_CMAKE_TRY_COMPILE_TARGET_TYPE ${CMAKE_TRY_COMPILE_TARGET_TYPE})
+set(_previous_CMAKE_REQUIRED_LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS})
 set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+set(CMAKE_REQUIRED_LINK_OPTIONS)
 add_compile_flags_if_supported(-funwind-tables)
 set(CMAKE_TRY_COMPILE_TARGET_TYPE ${_previous_CMAKE_TRY_COMPILE_TARGET_TYPE})
+set(CMAKE_REQUIRED_LINK_OPTIONS ${_previous_CMAKE_REQUIRED_LINK_OPTIONS})
 
 if (LIBUNWIND_USES_ARM_EHABI AND NOT CXX_SUPPORTS_FUNWIND_TABLES_FLAG)
   message(SEND_ERROR "The -funwind-tables flag must be supported "

[phosek]

@ldionne would it be possible to take a look?

[DavidSpickett]

I suspect this commit has broken the flang standalone build: https://lab.llvm.org/buildbot/#/builders/175/builds/25443

LLVMCheckCompilerLinkerFlag.cmake used to be present in the build dir, but is now not because it's in the top level cmake folder.

Building Flang as a standalone project.
CMake Error at /home/tcwg-buildbot/worker/flang-aarch64-out-of-tree/build_llvm/lib/cmake/llvm/HandleLLVMStdlib.cmake:16 (include):
  include could not find requested file:
    LLVMCheckLinkerFlag
Call Stack (most recent call first):
  /home/tcwg-buildbot/worker/flang-aarch64-out-of-tree/build_llvm/lib/cmake/llvm/HandleLLVMOptions.cmake:11 (include)
  CMakeLists.txt:107 (include)

Is the intention that we handle this like CMakePolicy.cmake and pull it from the source dir when we build flang, or is it a mistake to move it to the top level?

[DavidSpickett]

Due to the, unique, way the bot is configured, this is actually the build that first included the change: https://lab.llvm.org/buildbot/#/builders/175/builds/25426
(because it only triggers on certain subprojects it only shows the commits from those projects, which causes major confusion)

That passed, because we did not clean the build dir. The next time we did clear it was https://lab.llvm.org/buildbot/#/builders/175/builds/25433, which failed as shown before.

[DavidSpickett]

(because it only triggers on certain subprojects it only shows the commits from those projects, which causes major confusion)

Turns out Buildbot uses the Github API in a way that doesn't include the previous filenames. So a bot looking at llvm changes does not see a commit that only moves files out of llvm.

[phosek]

In D143052#4144613, @DavidSpickett wrote:

Is the intention that we handle this like CMakePolicy.cmake and pull it from the source dir when we build flang, or is it a mistake to move it to the top level?

Yes that's the intention. I'm also fine reverting this change; after D144509 lands which presumably will be soon, we should be able to just use check_linker_flag directly.

I suspect we'll want to use more common modules in the LLVM build in the future though so we'll need a better solution to avoid future such failures.

[DavidSpickett]

https://cmake.org/cmake/help/v3.18/module/CheckLinkerFlag.html

Looks equivalent to me, good timing.

[ldionne]

What is the status of this? We now require CMake 3.20, can this be rebased and landed in some form?

[phosek]

In D143052#4468485, @ldionne wrote:

What is the status of this? We now require CMake 3.20, can this be rebased and landed in some form?

The issue I ran into is that check_linker_flag annoyingly behaves differently from check_{c,cxx}_compiler_flag.

• With check_{c,cxx}_compiler_flag, CMake appends CMAKE_REQUIRED_FLAGS to the flag before invoking try_compile.
• With check_linker_flag, CMake replaces the content of CMAKE_REQUIRED_LINK_OPTIONS with the flag.

This somewhat reduces the utility of check_linker_flag and also means it behaves differently from llvm_check_compiler_linker_flag which is based on check_{c,cxx}_compiler_flag.

What I'm considering now is keeping llvm_check_linker_flag, but changing its implementation to be based on check_linker_flag while preserving CMAKE_REQUIRED_LINK_OPTIONS.

cmake/Modules/LLVMCheckCompilerLinkerFlag.cmake

-include(CMakePushCheckState)
-
-include(CheckCompilerFlag OPTIONAL)
-
-if(NOT COMMAND check_compiler_flag)
-  include(CheckCCompilerFlag)
-  include(CheckCXXCompilerFlag)
-endif()
-
-function(llvm_check_compiler_linker_flag lang flag out_var)
-  # If testing a flag with check_c_compiler_flag, it gets added to the compile
-  # command only, but not to the linker command in that test. If the flag
-  # is vital for linking to succeed, the test would fail even if it would
-  # have succeeded if it was included on both commands.
-  #
-  # Therefore, try adding the flag to CMAKE_REQUIRED_FLAGS, which gets
-  # added to both compiling and linking commands in the tests.
-
-  cmake_push_check_state()
-  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag}")
-  if(COMMAND check_compiler_flag)
-    check_compiler_flag("${lang}" "" ${out_var})
-  else()
-    # Until the minimum CMAKE version is 3.19
-    # cmake builtin compatible, except we assume lang is C or CXX
-    if("${lang}" STREQUAL "C")
-      check_c_compiler_flag("" ${out_var})
-    elseif("${lang}" STREQUAL "CXX")
-      check_cxx_compiler_flag("" ${out_var})
-    else()
-      message(FATAL_ERROR "\"${lang}\" is not C or CXX")
-    endif()
-  endif()
-  cmake_pop_check_state()
-endfunction()

compiler-rt/cmake/config-ix.cmake

 include(CMakePushCheckState)
-include(LLVMCheckCompilerLinkerFlag)
+include(LLVMCheckLinkerFlag)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckIncludeFiles)
 include(CheckLibraryExists)
-include(LLVMCheckCompilerLinkerFlag)
+include(LLVMCheckLinkerFlag)
 include(CheckSymbolExists)
 include(TestBigEndian)
 
 # The compiler driver may be implicitly trying to link against libunwind.
 # This is normally ok (libcxx relies on an unwinder), but if libunwind is
 # built in the same cmake invocation as compiler-rt and we're using the
 # in tree version of runtimes, we'd be linking against the just-built
 # libunwind (and the compiler implicit -lunwind wouldn't succeed as the newly
 # built libunwind isn't installed yet). For those cases, it'd be good to
 # link with --uwnindlib=none. Check if that option works.
-llvm_check_compiler_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
+llvm_check_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
 
 check_library_exists(c fopen "" COMPILER_RT_HAS_LIBC)
 if (COMPILER_RT_USE_BUILTINS_LIBRARY)
   include(HandleCompilerRT)
   find_compiler_rt_library(builtins COMPILER_RT_BUILTINS_LIBRARY
                            FLAGS ${SANITIZER_COMMON_FLAGS})
   # TODO(PR51389): We should check COMPILER_RT_BUILTINS_LIBRARY and report an
   # error if the value is NOTFOUND rather than silenty continuing but we first

 if (ANDROID AND COMPILER_RT_HAS_LIBDL)
   # Android's libstdc++ has a dependency on libdl.
   list(APPEND CMAKE_REQUIRED_LIBRARIES dl)
 endif()
 check_library_exists(c++ __cxa_throw "" COMPILER_RT_HAS_LIBCXX)
 check_library_exists(stdc++ __cxa_throw "" COMPILER_RT_HAS_LIBSTDCXX)
 
 # Linker flags.
-llvm_check_compiler_linker_flag(C "-Wl,-z,text" COMPILER_RT_HAS_Z_TEXT)
-llvm_check_compiler_linker_flag(C "-fuse-ld=lld" COMPILER_RT_HAS_FUSE_LD_LLD_FLAG)
+llvm_check_linker_flag(C "-Wl,-z,text" COMPILER_RT_HAS_Z_TEXT)
+llvm_check_linker_flag(C "-fuse-ld=lld" COMPILER_RT_HAS_FUSE_LD_LLD_FLAG)
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
   set(VERS_COMPAT_OPTION "-Wl,-z,gnu-version-script-compat")
-  llvm_check_compiler_linker_flag(C "${VERS_COMPAT_OPTION}" COMPILER_RT_HAS_GNU_VERSION_SCRIPT_COMPAT)
+  llvm_check_linker_flag(C "${VERS_COMPAT_OPTION}" COMPILER_RT_HAS_GNU_VERSION_SCRIPT_COMPAT)
 endif()
 
 set(DUMMY_VERS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/dummy.vers)
 file(WRITE ${DUMMY_VERS} "{};")
 set(VERS_OPTION "-Wl,--version-script,${DUMMY_VERS}")
 if(COMPILER_RT_HAS_GNU_VERSION_SCRIPT_COMPAT)
   # Solaris 11.4 ld only supports --version-script with
   # -z gnu-version-script-compat.
   string(APPEND VERS_OPTION " ${VERS_COMPAT_OPTION}")
 endif()
-llvm_check_compiler_linker_flag(C "${VERS_OPTION}" COMPILER_RT_HAS_VERSION_SCRIPT)
+llvm_check_linker_flag(C "${VERS_OPTION}" COMPILER_RT_HAS_VERSION_SCRIPT)
 
 if(ANDROID)
-  llvm_check_compiler_linker_flag(C "-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL)
+  llvm_check_linker_flag(C "-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL)
   check_library_exists(log __android_log_write "" COMPILER_RT_HAS_LIBLOG)
 endif()
 
 # Architectures.
 
 # List of all architectures we can target.
 set(COMPILER_RT_SUPPORTED_ARCH)
 
if(APPLE)
   set(CMAKE_OSX_DEPLOYMENT_TARGET "")
 
   set(DARWIN_COMMON_CFLAGS -stdlib=libc++)
   set(DARWIN_COMMON_LINK_FLAGS
     -stdlib=libc++
     -lc++
     -lc++abi)
 
-  llvm_check_compiler_linker_flag(C "-fapplication-extension" COMPILER_RT_HAS_APP_EXTENSION)
+  llvm_check_linker_flag(C "-fapplication-extension" COMPILER_RT_HAS_APP_EXTENSION)
   if(COMPILER_RT_HAS_APP_EXTENSION)
     list(APPEND DARWIN_COMMON_LINK_FLAGS "-fapplication-extension")
   endif()
 
   set(DARWIN_osx_CFLAGS
     ${DARWIN_COMMON_CFLAGS}
     ${DARWIN_osx_MIN_VER_FLAG}=${SANITIZER_MIN_OSX_VERSION})
   set(DARWIN_osx_LINK_FLAGS

libcxx/cmake/config-ix.cmake

 include(CMakePushCheckState)
 include(CheckLibraryExists)
-include(LLVMCheckCompilerLinkerFlag)
+include(LLVMCheckLinkerFlag)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckCSourceCompiles)
 
 # The compiler driver may be implicitly trying to link against libunwind.
 # This is normally ok (libcxx relies on an unwinder), but if libunwind is
 # built in the same cmake invocation as libcxx and we've got
 # LIBCXXABI_USE_LLVM_UNWINDER set, we'd be linking against the just-built
 # libunwind (and the compiler implicit -lunwind wouldn't succeed as the newly
 # built libunwind isn't installed yet). For those cases, it'd be good to
 # link with --uwnindlib=none. Check if that option works.
-llvm_check_compiler_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
+llvm_check_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
 
 if(WIN32 AND NOT MINGW)
   # NOTE(compnerd) this is technically a lie, there is msvcrt, but for now, lets
   # let the default linking take care of that.
   set(LIBCXX_HAS_C_LIB NO)
 else()
   check_library_exists(c fopen "" LIBCXX_HAS_C_LIB)
 endif()

libunwind/cmake/config-ix.cmake

 include(CMakePushCheckState)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckLibraryExists)
-include(LLVMCheckCompilerLinkerFlag)
+include(LLVMCheckLinkerFlag)
 include(CheckSymbolExists)
 include(CheckCSourceCompiles)
 
 # The compiler driver may be implicitly trying to link against libunwind, which
 # might not work if libunwind doesn't exist yet. Try to check if
 # --unwindlib=none is supported, and use that if possible.
-llvm_check_compiler_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
+llvm_check_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
 
 check_library_exists(c fopen "" LIBUNWIND_HAS_C_LIB)
 
 if (NOT LIBUNWIND_USE_COMPILER_RT)
   if (ANDROID)
     check_library_exists(gcc __gcc_personality_v0 "" LIBUNWIND_HAS_GCC_LIB)
   else ()
     check_library_exists(gcc_s __gcc_personality_v0 "" LIBUNWIND_HAS_GCC_S_LIB)
     check_library_exists(gcc __absvdi2 "" LIBUNWIND_HAS_GCC_LIB)
   endif ()
 endif()
 
 # libunwind is using -nostdlib++ at the link step when available,
 # otherwise -nodefaultlibs is used. We want all our checks to also
 # use one of these options, otherwise we may end up with an inconsistency between
 # the flags we think we require during configuration (if the checks are
 # performed without one of those options) and the flags that are actually
 # required during compilation (which has the -nostdlib++ or -nodefaultlibs). libc is
 # required for the link to go through. We remove sanitizers from the
 # configuration checks to avoid spurious link errors.
 
-llvm_check_compiler_linker_flag(CXX "-nostdlib++" CXX_SUPPORTS_NOSTDLIBXX_FLAG)
+llvm_check_linker_flag(CXX "-nostdlib++" CXX_SUPPORTS_NOSTDLIBXX_FLAG)
 if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdlib++")
 else()
-  llvm_check_compiler_linker_flag(C "-nodefaultlibs" C_SUPPORTS_NODEFAULTLIBS_FLAG)
+  llvm_check_linker_flag(C "-nodefaultlibs" C_SUPPORTS_NODEFAULTLIBS_FLAG)
   if (C_SUPPORTS_NODEFAULTLIBS_FLAG)
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
   endif()
 endif()
 
 if (CXX_SUPPORTS_NOSTDLIBXX_FLAG OR C_SUPPORTS_NODEFAULTLIBS_FLAG)
   if (LIBUNWIND_HAS_C_LIB)
     list(APPEND CMAKE_REQUIRED_LIBRARIES c)

runtimes/CMakeLists.txt

 # This variable makes sure that e.g. llvm-lit is found.
 set(LLVM_MAIN_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../llvm)
 set(LLVM_CMAKE_DIR ${LLVM_MAIN_SRC_DIR}/cmake/modules)
 
 # This variable is used by individual runtimes to locate LLVM files.
 set(LLVM_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../llvm)
 
 include(CheckLibraryExists)
-include(LLVMCheckCompilerLinkerFlag)
+include(LLVMCheckLinkerFlag)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
 # CMake omits default compiler include paths, but in runtimes build, we use
 # -nostdinc and -nostdinc++ and control include paths manually so this behavior
 # is undesirable. Filtering CMAKE_{LANG}_IMPLICIT_INCLUDE_DIRECTORIES to remove
 # paths that are inside the build directory disables this behavior.
 #

 
 check_c_compiler_flag("" LLVM_RUNTIMES_LINKING_WORKS)
 if (NOT LLVM_RUNTIMES_LINKING_WORKS)
   # The compiler driver may be implicitly trying to link against libunwind,
   # which might not work if libunwind doesn't exist yet. Try to check if
   # --unwindlib=none is supported, and use that if possible.
   # Don't add this if not necessary to fix linking, as it can break using
   # e.g. ASAN/TSAN.
-  llvm_check_compiler_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
+  llvm_check_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
   if (CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
     set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} --unwindlib=none")
     # TODO: When we can require CMake 3.14, we should use
     # CMAKE_REQUIRED_LINK_OPTIONS here. Until then, we need a workaround:
     # When using CMAKE_REQUIRED_FLAGS, this option gets added both to
     # compilation and linking commands. That causes warnings in the
     # compilation commands during cmake tests. This is normally benign, but
if (CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
     endif()
   endif()
 endif()
 
 # Disable use of the installed C++ standard library when building runtimes.
 # Check for -nostdlib++ first; if there's no C++ standard library yet,
 # all check_cxx_compiler_flag commands will fail until we add -nostdlib++
 # (or -nodefaultlibs).
-llvm_check_compiler_linker_flag(CXX "-nostdlib++" CXX_SUPPORTS_NOSTDLIBXX_FLAG)
+llvm_check_linker_flag(CXX "-nostdlib++" CXX_SUPPORTS_NOSTDLIBXX_FLAG)
 if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdlib++")
 endif()
 check_cxx_compiler_flag(-nostdinc++ CXX_SUPPORTS_NOSTDINCXX_FLAG)
 if (CXX_SUPPORTS_NOSTDINCXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdinc++")
 endif()