[cmake] Partially deduplicate `{llvm,compiler_rt}_check_linker_flag` for runtime libs and llvm

[Ericson2314]

Summary

We previously had a few varied definitions of this floating around.

I had tried to make the one installed with LLVM handle all the cases, and then made the others use it, but this ran into issues with HandleOutOfTreeLLVM not working for compiler-rt, and also CMAKE_EXE_LINKER_FLAGS not working right without CMP0056 set to the new behavior.

My compromise solution is this:

• No not completely deduplicate: the runtime libs will instead use a version that still exists as part of the internal and not installed common shared CMake utilities. This avoids HandleOutOfTreeLLVM or a workaround for compiler-rt.

• Continue to use CMAKE_REQUIRED_FLAGS, which effects compilation and linking. Maybe this is unnecessary, but it's safer to leave that as a future change. Also means we can avoid CMP0056 for now, to try out later, which is good incrementality too.

• Call it llvm_check_compiler_linker_flag since it, in fact is about both per its implementation (before and after this patch), so there is no name collision.

In the future, we might still enable CMP0056 and make compiler-rt work with HandleOutOfTreeLLVM, which case we delete llvm_check_compiler_flag and go back to the old way (as these are, in fact, linking related flags), but that I leave for someone else as future work.

The original issue was reported to me in https://reviews.llvm.org/D116521#3248117 as
D116521 made clang and LLVM use the common cmake utils.

[sebastian-ne]

I verified that this fixes the issue, thanks for the fast fix!

[ldionne]

LGTM with rewording.

cmake/Modules/CheckLinkerFlag.cmake

0

After this patch, the two functions have different names so I don't think this comment is relevant.

[phosek]

I'd prefer going in a different direction, that is figure out how to deduplicate llvm_check_linker_flag rather than duplicating it under a different name.

[Ericson2314]

@phosek Hmm it is indeed closer than I thought. This makes me sympathetic too. This is also a compiler-rt one, and a much more complex openmp one.

LLVM's llvm_check_linker_flag is used by AddLLVM, so it must continue to be installed. But HandleOutOfTreeLLVM will ensure for libcxx and friends that the LLVM modules are indeed available?

[Ericson2314]

I made D117617 as a first step towards a better version. If anyone wants this landed as a stop-gap in the interim, that is fine with me, too.

[Ericson2314]

Dedup instead

[Ericson2314]

Fix module including in compiler-rt

[Ericson2314]

Fix bug

[Ericson2314]

Fix more of the bug, hopefully there are no more commas I added by mistake

[sebastian-ne]

The latest patch still fixes the regression in llvm (didn’t look at anything else though).

[Ericson2314]

rebase to hopefully fix

compiler-rt/CMakeLists.txt

24–25 ↗

(On Diff #401102)

@phosek here is compiler-rt using it, as you wanted.

[Ericson2314]

Fix remaining missing C/CXX arguments

My sed was looking for (" but these weren't quoted before.

[Ericson2314]

Fix STREQUAL which is actually infix

[phosek]

compiler-rt/CMakeLists.txt

24–25 ↗

(On Diff #401102)

Thanks, can we land this separately?

compiler-rt/cmake/config-ix.cmake

168–169

This is not C++ specific so C should be enough.

169

This is not C++ specific so C should be enough.

173

This is not C++ specific so C should be enough.

184

This is not C++ specific so C should be enough.

187

This is not C++ specific so C should be enough.

433

This is not C++ specific so C should be enough.

libunwind/cmake/config-ix.cmake

37

This flag is C++ specific so this should be CXX.

runtimes/CMakeLists.txt

113

This flag is C++ specific so this should be CXX.

[Ericson2314]

@phosek I agree with your fixing what language to do each flag, but do note I was purposely matching the existing dubious categorizations. Might it be better to first land this as-is, and then make a separate patch to clean up the languages?

compiler-rt/CMakeLists.txt

24–25 ↗

(On Diff #401102)

Done in D117815

[phosek]

In D117537#3259240, @Ericson2314 wrote:

@phosek I agree with your fixing what language to do each flag, but do note I was purposely matching the existing dubious categorizations. Might it be better to first land this as-is, and then make a separate patch to clean up the languages?

That's fine with me as well.

[leonardchan]

Hi, I suspect that this patch (or D117815) led to the build failure we're seeing on our builders (https://luci-milo.appspot.com/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8824480583333895809):

CMake Error at /b/s/w/ir/x/w/llvm-llvm-project/libunwind/src/CMakeLists.txt:99 (message):
  Compiler doesn't support generation of unwind tables if exception support
  is disabled.  Building libunwind DSO with runtime dependency on C++ ABI
  library is not supported.


-- Configuring incomplete, errors occurred!
See also "/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-fuchsia+asan-bins/CMakeFiles/CMakeOutput.log".
See also "/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-fuchsia+asan-bins/CMakeFiles/CMakeError.log".
FAILED: runtimes/runtimes-x86_64-unknown-fuchsia+asan-stamps/runtimes-x86_64-unknown-fuchsia+asan-configure /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-fuchsia+asan-stamps/runtimes-x86_64-unknown-fuchsia+asan-configure

Maybe @phosek knows if we're missing something like a cmake flag on our end or if there's something in this patch causing it.

[Ericson2314]

Perhaps the difference betwen CMAKE_EXE_LINKER_FLAGS and CMAKE_REQUIRED_FLAGS is important? Also, if it is not possible to link until these libraries are built (e.g. in a cross setting) maybe I am not sure what happens.

If it was neessary these flags aren't just checked re linking, maybe we need to make a similar compat wrapper around https://cmake.org/cmake/help/latest/module/CheckCompilerFlag.html and use that instead?

[Ericson2314]

I have been auto-emailed with some build failures, but they seem unrelated (see https://reviews.llvm.org/rG60f61918795b91f3fc9d310bc0957b75783f826b) so haven't taken any action doing a revert yet.

[phosek]

In D117537#3259970, @Ericson2314 wrote:

Perhaps the difference betwen CMAKE_EXE_LINKER_FLAGS and CMAKE_REQUIRED_FLAGS is important? Also, if it is not possible to link until these libraries are built (e.g. in a cross setting) maybe I am not sure what happens.

If it was neessary these flags aren't just checked re linking, maybe we need to make a similar compat wrapper around https://cmake.org/cmake/help/latest/module/CheckCompilerFlag.html and use that instead?

CMAKE_EXE_LINKER_FLAGS is only passed to try_compile (which is what check_${lang}_compiler_flag uses internally when CMP0056 policy is set to NEW which we don't do in LLVM.

We either need to set this policy, or change llvm_check_linker_flag to use CMAKE_REQUIRED_FLAGS instead CMAKE_EXE_LINKER_FLAGS.

Can we revert this change until we figure the best path forward?

[Ericson2314]

New attempt splitting the difference between last 2

[Ericson2314]

Fix and simplify CMAKE_REQUIRED_DEFINITIONS

[Ericson2314]

Restore compromise a bit more

[Ericson2314]

Fix includes

[Ericson2314]

Fix more issues

[phosek]

What's the reason for keeping both functions instead of changing llvm_check_linker_flag to use CMAKE_REQUIRED_FLAGS?

[Ericson2314]

In D117537#3266889, @phosek wrote:

What's the reason for keeping both functions instead of changing llvm_check_linker_flag to use CMAKE_REQUIRED_FLAGS?

1. Abundance of caution / taking baby steps. No on had yet complained about how LLVM/Clang work yet pre the name collision.

2. I was planning on not trying to hack in compiler-rt using llvm/cmake/modules until HandleOutOfTreeLLVM there was fixed to handle that for us more cleanly. Conversely, compiler-rt can already use cmake/Modules just fine.

[Ericson2314]

@phosek does that reasoning check out to you?

[phosek]

In D117537#3270331, @Ericson2314 wrote:

@phosek does that reasoning check out to you?

I'd still like to avoid having multiple similar copies of this function in the tree.

I'd prefer starting with a smaller change that only modified llvm/cmake/modules/LLVMCheckLinkerFlag.cmake to use CMAKE_REQUIRED_FLAGS (it can also include the other changes you've made in this patch).

We can land that and if everything is working fine, I'd update this change to move llvm/cmake/modules/LLVMCheckLinkerFlag.cmake to cmake/Modules/CheckLinkerFlag.cmake and use it from everywhere except for compiler-rt which is going to need a more major cleanup.

[sebastian-ne]

@phosek, this patch fixes a regression that was introduced with D116521.
Could we fix this regression first with a simple patch that does not risk to be reverted again and do further refactorings afterwards?
Our downstream gcc build is broken and we’d like to re-enable it rather sooner than later.

[Ericson2314]

@phosek

I'd update this change to move llvm/cmake/modules/LLVMCheckLinkerFlag.cmake to cmake/Modules/CheckLinkerFlag.cmake

Note we cannot make that move because this is referred to from installed cmake modules, whereas cmake/ is internal only and never installed.

I am a bit inclined to agree with @sebastian-ne. I don't like a bug I made staying open, and I rather get this done which at least moves us in the right direction and doesn't add any *new* sources of duplication.

We can still do the things you want to improve the situation (leaving compiler-rt) after.

[kuhar]

In D117537#3271928, @sebastian-ne wrote:

@phosek, this patch fixes a regression that was introduced with D116521.
Could we fix this regression first with a simple patch that does not risk to be reverted again and do further refactorings afterwards?
Our downstream gcc build is broken and we’d like to re-enable it rather sooner than later.

+1

cmake/Modules/CheckLinkerFlag.cmake

-include(CMakePushCheckState)
-include(CheckCCompilerFlag)
-
-function(llvm_check_linker_flag flag dest)
-  # 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}")
-  check_c_compiler_flag("" ${dest})
-  cmake_pop_check_state()
-endfunction()

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(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckIncludeFiles)
 include(CheckLibraryExists)
 include(CheckSymbolExists)
 include(TestBigEndian)
 
-function(compiler_rt_check_linker_flag flag out_var)
-  cmake_push_check_state()
-  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${flag}")
-  check_cxx_compiler_flag("" ${out_var})
-  cmake_pop_check_state()
-endfunction()
-
 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
   # need to fix find_compiler_rt_library on Darwin.

 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.
-compiler_rt_check_linker_flag("-Wl,-z,text" COMPILER_RT_HAS_Z_TEXT)
-compiler_rt_check_linker_flag("-fuse-ld=lld" COMPILER_RT_HAS_FUSE_LD_LLD_FLAG)
+llvm_check_compiler_linker_flag(CXX "-Wl,-z,text" COMPILER_RT_HAS_Z_TEXT)
+llvm_check_compiler_linker_flag(CXX "-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")
-  compiler_rt_check_linker_flag("${VERS_COMPAT_OPTION}" COMPILER_RT_HAS_GNU_VERSION_SCRIPT_COMPAT)
+  llvm_check_compiler_linker_flag(CXX "${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()
-compiler_rt_check_linker_flag("${VERS_OPTION}" COMPILER_RT_HAS_VERSION_SCRIPT)
+llvm_check_compiler_linker_flag(CXX "${VERS_OPTION}" COMPILER_RT_HAS_VERSION_SCRIPT)
 
 if(ANDROID)
-  compiler_rt_check_linker_flag("-Wl,-z,global" COMPILER_RT_HAS_Z_GLOBAL)
+  llvm_check_compiler_linker_flag(CXX "-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)
 
-  compiler_rt_check_linker_flag("-fapplication-extension" COMPILER_RT_HAS_APP_EXTENSION)
+  llvm_check_compiler_linker_flag(CXX "-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(CheckLinkerFlag)
+include(LLVMCheckCompilerLinkerFlag)
 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_linker_flag("--unwindlib=none" LIBCXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
+llvm_check_compiler_linker_flag(C "--unwindlib=none" LIBCXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
 if (LIBCXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} --unwindlib=none")
 endif()
 
 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)

libunwind/cmake/config-ix.cmake

 include(CMakePushCheckState)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckLibraryExists)
-include(CheckLinkerFlag)
+include(LLVMCheckCompilerLinkerFlag)
 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_linker_flag("--unwindlib=none" LIBUNWIND_SUPPORTS_UNWINDLIB_NONE_FLAG)
+llvm_check_compiler_linker_flag(C "--unwindlib=none" LIBUNWIND_SUPPORTS_UNWINDLIB_NONE_FLAG)
 if (LIBUNWIND_SUPPORTS_UNWINDLIB_NONE_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} --unwindlib=none")
 endif()
 
 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_linker_flag(-nostdlib++ LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG)
+llvm_check_compiler_linker_flag(C "-nostdlib++" LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG)
 if (LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdlib++")
 else()
-  llvm_check_linker_flag(-nodefaultlibs LIBUNWIND_SUPPORTS_NODEFAULTLIBS_FLAG)
+  llvm_check_compiler_linker_flag(C "-nodefaultlibs" LIBUNWIND_SUPPORTS_NODEFAULTLIBS_FLAG)
   if (LIBUNWIND_SUPPORTS_NODEFAULTLIBS_FLAG)
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
   endif()
 endif()
 
 if (LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG OR LIBUNWIND_SUPPORTS_NODEFAULTLIBS_FLAG)
   if (LIBUNWIND_HAS_C_LIB)
     list(APPEND CMAKE_REQUIRED_LIBRARIES c)

llvm/cmake/modules/LLVMCheckLinkerFlag.cmake

 include(CheckLinkerFlag OPTIONAL)
 
 if (COMMAND check_linker_flag)
   macro(llvm_check_linker_flag)
     check_linker_flag(${ARGN})
   endmacro()
 else()
+  # Until the minimum CMAKE version is 3.18
+
   include(CheckCXXCompilerFlag)
   include(CMakePushCheckState)
 
-  # cmake builtin compatible, except we assume lang is CXX
+  # cmake builtin compatible, except we assume lang is C or CXX
   function(llvm_check_linker_flag lang flag out_var)
     cmake_push_check_state()
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}")
+    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()
     cmake_pop_check_state()
   endfunction()
 endif()

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(CheckLinkerFlag)
+include(LLVMCheckCompilerLinkerFlag)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
 
 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_linker_flag("--unwindlib=none" LLVM_RUNTIMES_SUPPORT_UNWINDLIB_NONE_FLAG)
+  llvm_check_compiler_linker_flag(C "--unwindlib=none" LLVM_RUNTIMES_SUPPORT_UNWINDLIB_NONE_FLAG)
   if (LLVM_RUNTIMES_SUPPORT_UNWINDLIB_NONE_FLAG)
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} --unwindlib=none")
   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_linker_flag(-nostdlib++ LLVM_RUNTIMES_SUPPORT_NOSTDLIBXX_FLAG)
+llvm_check_compiler_linker_flag(C "-nostdlib++" LLVM_RUNTIMES_SUPPORT_NOSTDLIBXX_FLAG)
 if (LLVM_RUNTIMES_SUPPORT_NOSTDLIBXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdlib++")
 endif()
 check_cxx_compiler_flag(-nostdinc++ LLVM_RUNTIMES_SUPPORT_NOSTDINCXX_FLAG)
 if (LLVM_RUNTIMES_SUPPORT_NOSTDINCXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdinc++")
 endif()