[runtimes] [CMake] Unify variable names

[mstorsjo]

Summary

Avoid repeating CMake checks across runtimes by unifying names of
variables used for results to leverage CMake caching.

[MaskRay]

Looks great to me. Looks like CXX_SUPPORTS_ is already used.

[mstorsjo]

libcxxabi/cmake/config-ix.cmake

86

The newly added checks in llvm-project/runtimes (for -nostdinc++ and -nostdlib++) probably should be aligned with these too.

[compnerd]

While I think that the direction of this change is amazing, I'm less enthusiastic about the naming. I think that it is particularly confusing for the flags to use C and CXX as the prefixes for the flags as we have llvm-libc (aka "c") and libc++ (aka "c++", "cxx"). Using a more verbose name of COMPILER_ or C_COMPILER_, CXX_COMPILER_ would allow the flags to be easily attributed to the compiler or the runtime. However, the C standard flags definitely should be dropped.

compiler-rt/CMakeLists.txt

460

Can we rename this? I don't think that C_SUPPORTS_NODEFAULTLIBS_FLAG is ideal - how about COMPILER_SUPPORTS_... or C_COMPILER_...?

compiler-rt/cmake/config-ix.cmake

60–61

Similar, COMPILER_SUPPORTS_ or C_COMPILER_SUPPORTS_.... The flag isn't about the C library

61

I think that we should get rid of this check entirely. Instead, we should use the C_STANDARD and C_STANDARD_REQUIRED properties on the targets. This has been available since CMake 3.1.

[phosek]

In D110005#3010694, @compnerd wrote:

While I think that the direction of this change is amazing, I'm less enthusiastic about the naming. I think that it is particularly confusing for the flags to use C and CXX as the prefixes for the flags as we have llvm-libc (aka "c") and libc++ (aka "c++", "cxx"). Using a more verbose name of COMPILER_ or C_COMPILER_, CXX_COMPILER_ would allow the flags to be easily attributed to the compiler or the runtime. However, the C standard flags definitely should be dropped.

This is exactly the kind of suggestion I was looking for, thanks! I'm fine with either, the only reason why C_COMPILER_/CXX_COMPILER_ might be preferable over simple COMPILER_ is if there we ever wanted to distinguish between flags supported by C and C++ compiler (in particular if there was a flag that was only supported in one mode but not the other). I'm not sure if that's ever going to be the case?

Do you have any thoughts on variable naming for libraries? We seem to have HAVE_LIBPTHREAD, LIBCXX_HAS_PTHREAD_LIB and COMPILER_RT_HAS_LIBPTHREAD.

[ldionne]

In D110005#3010753, @phosek wrote:

In D110005#3010694, @compnerd wrote:

While I think that the direction of this change is amazing, I'm less enthusiastic about the naming. I think that it is particularly confusing for the flags to use C and CXX as the prefixes for the flags as we have llvm-libc (aka "c") and libc++ (aka "c++", "cxx"). Using a more verbose name of COMPILER_ or C_COMPILER_, CXX_COMPILER_ would allow the flags to be easily attributed to the compiler or the runtime. However, the C standard flags definitely should be dropped.

This is exactly the kind of suggestion I was looking for, thanks! I'm fine with either, the only reason why C_COMPILER_/CXX_COMPILER_ might be preferable over simple COMPILER_ is if there we ever wanted to distinguish between flags supported by C and C++ compiler (in particular if there was a flag that was only supported in one mode but not the other). I'm not sure if that's ever going to be the case?

Do you have any thoughts on variable naming for libraries? We seem to have HAVE_LIBPTHREAD, LIBCXX_HAS_PTHREAD_LIB and COMPILER_RT_HAS_LIBPTHREAD.

I agree with @compnerd , I think this is pure awesomeness. Also agree with the naming. My take would be:

CXX_COMPILER_SUPPORTS_<flag>
C_COMPILER_SUPPORTS_<flag>
PLATFORM_SUPPORTS_LIB_<library>

Requesting changes so it shows up in my review queue properly, but this LGTM in essence. Also we'll want to get a green CI.

[mstorsjo]

Any updates to this one? Now that the standalone builds of runtime projects have been removed, this would be rather nice to have, to reap easy benefits from building all projects in one cmake invocation. (I guess this one doesn't involve any really complicated cmake trickery either, so if you'd don't have time for it, maybe I should consider to pick it up.)

[mstorsjo]

Commandeering this patch, as it'd be nice to have it landed, and should be doable to get consensus on.

[mstorsjo]

Rebased to current git main. I split out the parts concerning -std=c11 in compiler-rt, as those can be handled differently, separately from this.

I also split out rewriting of the variable name for the -ffreestanding flag in compiler-rt, as that test doesn't seem to be shared with any of the other runtimes.

So far, I think the scope of the patch was to rename all of the variable names within libcxx/libcxxabi/libunwind, and the ones in compiler-rt that overlaps any of them, but there's lots of more variables in compiler-rt that could be renamed consistently, even if it doesn't add any extra cache sharing across projects.

[mstorsjo]

In D110005#3010753, @phosek wrote:

In D110005#3010694, @compnerd wrote:

While I think that the direction of this change is amazing, I'm less enthusiastic about the naming. I think that it is particularly confusing for the flags to use C and CXX as the prefixes for the flags as we have llvm-libc (aka "c") and libc++ (aka "c++", "cxx"). Using a more verbose name of COMPILER_ or C_COMPILER_, CXX_COMPILER_ would allow the flags to be easily attributed to the compiler or the runtime. However, the C standard flags definitely should be dropped.

This is exactly the kind of suggestion I was looking for, thanks! I'm fine with either, the only reason why C_COMPILER_/CXX_COMPILER_ might be preferable over simple COMPILER_ is if there we ever wanted to distinguish between flags supported by C and C++ compiler (in particular if there was a flag that was only supported in one mode but not the other). I'm not sure if that's ever going to be the case?

Do you have any thoughts on variable naming for libraries? We seem to have HAVE_LIBPTHREAD, LIBCXX_HAS_PTHREAD_LIB and COMPILER_RT_HAS_LIBPTHREAD.

I guess the naming of variables was indeed the only main issue to settle here. The currently proposed naming in this patch originally, e.g. CXX_SUPPORTS_..., does match what LLVM uses in add_flag_if_supported here: https://github.com/llvm/llvm-project/blob/main/llvm/cmake/modules/HandleLLVMOptions.cmake#L260-L265

So in this current form, this patch can also get cache hits between tests from llvm/cmake/modules and the rest of the runtimes, while if we settle on a different naming scheme like CXX_COMPILER_SUPPORTS_... we won't get matches between tests in those different areas. (Not sure if there are any right now, but there could be.) And expanding this patch to rename the naming style of LLVM's cmake modules would grow the scope of this patch quite significantly.

Or what's @beanz 's opinion on it?

[phosek]

In D110005#3405081, @mstorsjo wrote:

Rebased to current git main. I split out the parts concerning -std=c11 in compiler-rt, as those can be handled differently, separately from this.

I also split out rewriting of the variable name for the -ffreestanding flag in compiler-rt, as that test doesn't seem to be shared with any of the other runtimes.

So far, I think the scope of the patch was to rename all of the variable names within libcxx/libcxxabi/libunwind, and the ones in compiler-rt that overlaps any of them, but there's lots of more variables in compiler-rt that could be renamed consistently, even if it doesn't add any extra cache sharing across projects.

Thanks for taking over, I was far too busy over the last few weeks, but I should have more time for the next few weeks if you need help.

In D110005#3405107, @mstorsjo wrote:

I guess the naming of variables was indeed the only main issue to settle here. The currently proposed naming in this patch originally, e.g. CXX_SUPPORTS_..., does match what LLVM uses in add_flag_if_supported here: https://github.com/llvm/llvm-project/blob/main/llvm/cmake/modules/HandleLLVMOptions.cmake#L260-L265

So in this current form, this patch can also get cache hits between tests from llvm/cmake/modules and the rest of the runtimes, while if we settle on a different naming scheme like CXX_COMPILER_SUPPORTS_... we won't get matches between tests in those different areas. (Not sure if there are any right now, but there could be.) And expanding this patch to rename the naming style of LLVM's cmake modules would grow the scope of this patch quite significantly.

Or what's @beanz 's opinion on it?

Right, that's why I chose the naming scheme in the original patch, to avoid having to rename variables in llvm/cmake/modules and reduce the churn.

I think it's doable, but if we decide that's the direction we want to take, then I'd do it as a separate change .

[ldionne]

My naming suggestion wasn't meant to stall this effort. I still have a slight preference for mentioning _COMPILER_ in the name of these variables, but I don't care strongly enough to block this. I also think we'll want to lift these checks even further into runtimes/ to simplify the code, but that's certainly a separate effort.

I am fine with this as-is so I'll lift the hard "requires-changes" on the runtimes, but please wait to see whether others who had commented are fine too before shipping.

[phosek]

In D110005#3406655, @ldionne wrote:

My naming suggestion wasn't meant to stall this effort. I still have a slight preference for mentioning _COMPILER_ in the name of these variables, but I don't care strongly enough to block this.
I also think we'll want to lift these checks even further into runtimes/ to simplify the code, but that's certainly a separate effort.

Yes, the next step I had planned after this is to lift https://github.com/llvm/llvm-project/blob/df209b8038f3803621e96799f5c43e9145448e10/libcxx/cmake/Modules/HandleLibcxxFlags.cmake to runtimes/cmake/Modules, and then replace https://github.com/llvm/llvm-project/blob/df209b8038f3803621e96799f5c43e9145448e10/libcxxabi/cmake/Modules/HandleLibcxxabiFlags.cmake and https://github.com/llvm/llvm-project/blob/df209b8038f3803621e96799f5c43e9145448e10/libunwind/cmake/Modules/HandleLibunwindFlags.cmake (and eventually also https://github.com/llvm/llvm-project/blob/main/compiler-rt/cmake/Modules/CompilerRTUtils.cmake but that's going to take more effort). Once this change lands, those changes should be effectively no-ops.

[mstorsjo]

Ping @compnerd - can you look at the reasoning and arguments above? While your suggested naming would be clearer, it would be different from the rest of what's used in llvm/cmake/*, and I'd prefer not to start refactoring the naming of everything in the full llvm cmake universe for the sake of this patch - I'm just enabling reuse within some of the runtimes.

[mstorsjo]

In D110005#3426103, @mstorsjo wrote:

Ping @compnerd - can you look at the reasoning and arguments above? While your suggested naming would be clearer, it would be different from the rest of what's used in llvm/cmake/*, and I'd prefer not to start refactoring the naming of everything in the full llvm cmake universe for the sake of this patch - I'm just enabling reuse within some of the runtimes.

Ping @compnerd

[compnerd]

Sure, the argument of the cache hits is definitely reasonable - I'm not a fan of the naming, but can understand the desire to not rename all the variables across all the projects.

[mstorsjo]

Rebased, rerunning CI - will push later if everything still passes.

compiler-rt/CMakeLists.txt

 append_list_if(COMPILER_RT_HAS_WD4291_FLAG /wd4291 SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4391_FLAG /wd4391 SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4722_FLAG /wd4722 SANITIZER_COMMON_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WD4800_FLAG /wd4800 SANITIZER_COMMON_CFLAGS)
 
 append_list_if(MINGW -fms-extensions SANITIZER_COMMON_CFLAGS)
 
 # Set common link flags.
-append_list_if(COMPILER_RT_HAS_NODEFAULTLIBS_FLAG -nodefaultlibs SANITIZER_COMMON_LINK_FLAGS)
+append_list_if(C_SUPPORTS_NODEFAULTLIBS_FLAG -nodefaultlibs SANITIZER_COMMON_LINK_FLAGS)
 append_list_if(COMPILER_RT_HAS_Z_TEXT -Wl,-z,text SANITIZER_COMMON_LINK_FLAGS)
 
 if (COMPILER_RT_USE_BUILTINS_LIBRARY)
   string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
 else()
   if (ANDROID)
     append_list_if(COMPILER_RT_HAS_GCC_LIB gcc SANITIZER_COMMON_LINK_LIBS)
   else()

compiler-rt/cmake/config-ix.cmake

 else()
   if (ANDROID)
     check_library_exists(gcc __gcc_personality_v0 "" COMPILER_RT_HAS_GCC_LIB)
   else()
     check_library_exists(gcc_s __gcc_personality_v0 "" COMPILER_RT_HAS_GCC_S_LIB)
   endif()
 endif()
 
-check_c_compiler_flag(-nodefaultlibs COMPILER_RT_HAS_NODEFAULTLIBS_FLAG)
-if (COMPILER_RT_HAS_NODEFAULTLIBS_FLAG)
+check_c_compiler_flag(-nodefaultlibs C_SUPPORTS_NODEFAULTLIBS_FLAG)
+if (C_SUPPORTS_NODEFAULTLIBS_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
   if (COMPILER_RT_HAS_LIBC)
     list(APPEND CMAKE_REQUIRED_LIBRARIES c)
   endif ()
   if (COMPILER_RT_USE_BUILTINS_LIBRARY)
     # TODO: remote this check once we address PR51389.
     if (${COMPILER_RT_BUILTINS_LIBRARY})
       list(APPEND CMAKE_REQUIRED_LIBRARIES "${COMPILER_RT_BUILTINS_LIBRARY}")
set(MINGW_LIBRARIES mingw32 ${MINGW_RUNTIME} moldname mingwex msvcrt advapi32
                         moldname mingwex msvcrt)
     list(APPEND CMAKE_REQUIRED_LIBRARIES ${MINGW_LIBRARIES})
   endif()
 endif ()
 
 # CodeGen options.
 check_c_compiler_flag(-ffreestanding         COMPILER_RT_HAS_FFREESTANDING_FLAG)
 check_c_compiler_flag(-fomit-frame-pointer   COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG)
 check_c_compiler_flag(-std=c11               COMPILER_RT_HAS_STD_C11_FLAG)
 check_c_compiler_flag(-fcf-protection=full   COMPILER_RT_HAS_FCF_PROTECTION_FLAG)
 check_cxx_compiler_flag(-fPIC                COMPILER_RT_HAS_FPIC_FLAG)
 check_cxx_compiler_flag(-fPIE                COMPILER_RT_HAS_FPIE_FLAG)
 check_cxx_compiler_flag(-fno-builtin         COMPILER_RT_HAS_FNO_BUILTIN_FLAG)
 check_cxx_compiler_flag(-fno-exceptions      COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG)
 check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG)
 check_cxx_compiler_flag(-funwind-tables      COMPILER_RT_HAS_FUNWIND_TABLES_FLAG)
 check_cxx_compiler_flag(-fno-stack-protector COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG)
 check_cxx_compiler_flag(-fno-sanitize=safe-stack COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG)

libcxx/CMakeLists.txt

function(cxx_add_basic_build_flags target)
   # Let the library headers know they are currently being used to build the
   # library.
   target_compile_definitions(${target} PRIVATE -D_LIBCPP_BUILDING_LIBRARY)
 
   if (NOT LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS)
     target_compile_definitions(${target} PRIVATE -D_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
   endif()
 
-  if (LIBCXX_HAS_COMMENT_LIB_PRAGMA)
+  if (C_SUPPORTS_COMMENT_LIB_PRAGMA)
     if (LIBCXX_HAS_PTHREAD_LIB)
       target_compile_definitions(${target} PRIVATE -D_LIBCPP_LINK_PTHREAD_LIB)
     endif()
     if (LIBCXX_HAS_RT_LIB)
       target_compile_definitions(${target} PRIVATE -D_LIBCPP_LINK_RT_LIB)
     endif()
   endif()
 endfunction()

 # Link system libraries =======================================================
 function(cxx_link_system_libraries target)
 
 # In order to remove just libc++ from the link step
 # we need to use -nostdlib++ whenever it is supported.
 # Unfortunately this cannot be used universally because for example g++ supports
 # only -nodefaultlibs in which case all libraries will be removed and
 # all libraries but c++ have to be added in manually.
-  if (LIBCXX_SUPPORTS_NOSTDLIBXX_FLAG)
+  if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
     target_add_link_flags_if_supported(${target} PRIVATE "-nostdlib++")
   else()
     target_add_link_flags_if_supported(${target} PRIVATE "-nodefaultlibs")
     target_add_compile_flags_if_supported(${target} PRIVATE "/Zl")
     target_add_link_flags_if_supported(${target} PRIVATE "/nodefaultlib")
   endif()
 
-  if (LIBCXX_SUPPORTS_UNWINDLIB_NONE_FLAG AND LIBCXXABI_USE_LLVM_UNWINDER)
+  if (CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG AND LIBCXXABI_USE_LLVM_UNWINDER)
     # If we're linking directly against the libunwind that we're building
     # in the same invocation, don't try to link in the toolchain's
     # default libunwind (which may be missing still).
     target_add_link_flags_if_supported(${target} PRIVATE "--unwindlib=none")
   endif()
 
   if (LIBCXX_HAS_SYSTEM_LIB)
     target_link_libraries(${target} PRIVATE System)

libcxx/cmake/Modules/HandleLibcxxFlags.cmake

foreach(var ${ARGN})
     string(REPLACE "${var}" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
     string(REPLACE "${var}" "" CMAKE_SHARED_MODULE_FLAGS "${CMAKE_SHARED_MODULE_FLAGS}")
     remove_definitions(${var})
   endforeach()
 endmacro(remove_flags)
 
 macro(check_flag_supported flag)
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
 endmacro()
 
 macro(append_flags DEST)
   foreach(value ${ARGN})
     list(APPEND ${DEST} ${value})
     list(APPEND ${DEST} ${value})
   endforeach()
 endmacro()
 
 # If the specified 'condition' is true then append the specified list of flags to DEST
 macro(append_flags_if condition DEST)
   if (${condition})
     list(APPEND ${DEST} ${ARGN})
   endif()
 endmacro()
 
 # Add each flag in the list specified by DEST if that flag is supported by the current compiler.
 macro(append_flags_if_supported DEST)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
-    append_flags_if(LIBCXX_SUPPORTS_${flagname}_FLAG ${DEST} ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    append_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${DEST} ${flag})
   endforeach()
 endmacro()
 
 # Add a macro definition if condition is true.
 macro(define_if condition def)
   if (${condition})
     add_definitions(${def})
   endif()

 endmacro()
 
 # Add all the flags supported by the compiler to all of
 # 'CMAKE_CXX_FLAGS', 'CMAKE_C_FLAGS', 'LIBCXX_COMPILE_FLAGS'
 # and 'LIBCXX_LINK_FLAGS'.
 macro(add_target_flags_if_supported)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
-    add_target_flags_if(LIBCXX_SUPPORTS_${flagname}_FLAG ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    add_target_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a specified list of flags to both 'LIBCXX_COMPILE_FLAGS' and
 # 'LIBCXX_LINK_FLAGS'.
 macro(add_flags)
   foreach(value ${ARGN})
     list(APPEND LIBCXX_COMPILE_FLAGS ${value})
macro(add_flags_if condition)
   endif()
 endmacro()
 
 # Add each flag in the list to LIBCXX_COMPILE_FLAGS and LIBCXX_LINK_FLAGS
 # if that flag is supported by the current compiler.
 macro(add_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
-      add_flags_if(LIBCXX_SUPPORTS_${flagname}_FLAG ${flag})
+      check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+      add_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBCXX_COMPILE_FLAGS'.
 macro(add_compile_flags)
   foreach(f ${ARGN})
     list(APPEND LIBCXX_COMPILE_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBCXX_COMPILE_FLAGS'
 macro(add_compile_flags_if condition)
   if (${condition})
     add_compile_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBCXX_COMPILE_FLAGS' if the
 # flag is supported by the C++ compiler.
 macro(add_compile_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
-      add_compile_flags_if(LIBCXX_SUPPORTS_${flagname}_FLAG ${flag})
+      check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+      add_compile_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBCXX_LINK_FLAGS'.
 macro(add_link_flags)
   foreach(f ${ARGN})
     list(APPEND LIBCXX_LINK_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBCXX_LINK_FLAGS'
 macro(add_link_flags_if condition)
   if (${condition})
     add_link_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBCXX_LINK_FLAGS' if the
 # flag is supported by the C++ compiler.
 macro(add_link_flags_if_supported)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
-    add_link_flags_if(LIBCXX_SUPPORTS_${flagname}_FLAG ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    add_link_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of libraries or link flags to 'LIBCXX_LIBRARIES'.
 macro(add_library_flags)
   foreach(lib ${ARGN})
     list(APPEND LIBCXX_LIBRARIES ${lib})
   endforeach()
macro(split_list listname)
   string(REPLACE ";" " " ${listname} "${${listname}}")
 endmacro()
 
 # For each specified flag, add that link flag to the provided target.
 # The flags are added with the given visibility, i.e. PUBLIC|PRIVATE|INTERFACE.
 function(target_add_link_flags_if_supported target visibility)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
-    if (LIBCXX_SUPPORTS_${flagname}_FLAG)
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    if (CXX_SUPPORTS_${flagname}_FLAG)
       target_link_libraries(${target} ${visibility} ${flag})
     endif()
   endforeach()
 endfunction()
 
 # For each specified flag, add that compile flag to the provided target.
 # The flags are added with the given visibility, i.e. PUBLIC|PRIVATE|INTERFACE.
 function(target_add_compile_flags_if_supported target visibility)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXX_SUPPORTS_${flagname}_FLAG")
-    if (LIBCXX_SUPPORTS_${flagname}_FLAG)
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    if (CXX_SUPPORTS_${flagname}_FLAG)
       target_compile_options(${target} ${visibility} ${flag})
     endif()
   endforeach()
 endfunction()

libcxx/cmake/config-ix.cmake

 include(CMakePushCheckState)
 include(CheckLibraryExists)
 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_compiler_linker_flag(C "--unwindlib=none" LIBCXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
-if (LIBCXX_SUPPORTS_UNWINDLIB_NONE_FLAG)
+llvm_check_compiler_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
+if (CXX_SUPPORTS_UNWINDLIB_EQ_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)
 else()

 # 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.
 
-check_c_compiler_flag(-nostdlib++ LIBCXX_SUPPORTS_NOSTDLIBXX_FLAG)
-if (LIBCXX_SUPPORTS_NOSTDLIBXX_FLAG)
+check_cxx_compiler_flag(-nostdlib++ CXX_SUPPORTS_NOSTDLIBXX_FLAG)
+if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdlib++")
 else()
-  check_c_compiler_flag(-nodefaultlibs LIBCXX_SUPPORTS_NODEFAULTLIBS_FLAG)
-  if (LIBCXX_SUPPORTS_NODEFAULTLIBS_FLAG)
+  check_c_compiler_flag(-nodefaultlibs C_SUPPORTS_NODEFAULTLIBS_FLAG)
+  if (C_SUPPORTS_NODEFAULTLIBS_FLAG)
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
   endif()
 endif()
 
-if (LIBCXX_SUPPORTS_NOSTDLIBXX_FLAG OR LIBCXX_SUPPORTS_NODEFAULTLIBS_FLAG)
+if (CXX_SUPPORTS_NOSTDLIBXX_FLAG OR C_SUPPORTS_NODEFAULTLIBS_FLAG)
   if (LIBCXX_HAS_C_LIB)
     list(APPEND CMAKE_REQUIRED_LIBRARIES c)
   endif ()
   if (LIBCXX_USE_COMPILER_RT)
     include(HandleCompilerRT)
     find_compiler_rt_library(builtins LIBCXX_BUILTINS_LIBRARY
                              FLAGS ${LIBCXX_COMPILE_FLAGS})
     list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBCXX_BUILTINS_LIBRARY}")

 
 # Check compiler pragmas
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   cmake_push_check_state()
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror=unknown-pragmas")
   check_c_source_compiles("
 #pragma comment(lib, \"c\")
 int main() { return 0; }
-" LIBCXX_HAS_COMMENT_LIB_PRAGMA)
+" C_SUPPORTS_COMMENT_LIB_PRAGMA)
   cmake_pop_check_state()
 endif()
 
 # Check libraries
 if(WIN32 AND NOT MINGW)
   # TODO(compnerd) do we want to support an emulation layer that allows for the
   # use of pthread-win32 or similar libraries to emulate pthreads on Windows?
   set(LIBCXX_HAS_PTHREAD_LIB NO)

libcxxabi/CMakeLists.txt

 # Configure target flags
 if(ZOS)
   add_target_flags_if_supported("-fzos-le-char-mode=ebcdic")
 endif()
 
 # Configure compiler. Must happen after setting the target flags.
 include(config-ix)
 
-if (LIBCXXABI_HAS_NOSTDINCXX_FLAG)
+if (CXX_SUPPORTS_NOSTDINCXX_FLAG)
   list(APPEND LIBCXXABI_COMPILE_FLAGS -nostdinc++)
   # cmake 3.14 and above remove system include paths that are explicitly
   # passed on the command line.  We build with -nostdinc++ and explicitly add
   # just the libcxx system include paths with -I on the command line.
   # Setting CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES effectively prevents cmake
   # from removing these.
   # See: https://gitlab.kitware.com/cmake/cmake/issues/19227
   set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "")

 if (LIBCXXABI_NON_DEMANGLING_TERMINATE)
   add_definitions(-DLIBCXXABI_NON_DEMANGLING_TERMINATE)
 endif()
 
 if (LIBCXXABI_BAREMETAL)
     add_definitions(-DLIBCXXABI_BAREMETAL)
 endif()
 
-if (LIBCXXABI_HAS_COMMENT_LIB_PRAGMA)
+if (C_SUPPORTS_COMMENT_LIB_PRAGMA)
   if (LIBCXXABI_HAS_PTHREAD_LIB)
     add_definitions(-D_LIBCXXABI_LINK_PTHREAD_LIB)
   endif()
 endif()
 
 string(REPLACE ";" " " LIBCXXABI_CXX_FLAGS "${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBCXXABI_C_FLAGS}")

libcxxabi/cmake/Modules/HandleLibcxxabiFlags.cmake

foreach(var ${ARGN})
     string(REPLACE "${var}" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
     string(REPLACE "${var}" "" CMAKE_SHARED_MODULE_FLAGS "${CMAKE_SHARED_MODULE_FLAGS}")
     remove_definitions(${var})
   endforeach()
 endmacro(remove_flags)
 
 macro(check_flag_supported flag)
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXXABI_SUPPORTS_${flagname}_FLAG")
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
 endmacro()
 
 macro(append_flags DEST)
   foreach(value ${ARGN})
     list(APPEND ${DEST} ${value})
     list(APPEND ${DEST} ${value})
   endforeach()
 endmacro()
 
 # If the specified 'condition' is true then append the specified list of flags to DEST
 macro(append_flags_if condition DEST)
   if (${condition})
     list(APPEND ${DEST} ${ARGN})
   endif()
 endmacro()
 
 # Add each flag in the list specified by DEST if that flag is supported by the current compiler.
 macro(append_flags_if_supported DEST)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXXABI_SUPPORTS_${flagname}_FLAG")
-    append_flags_if(LIBCXXABI_SUPPORTS_${flagname}_FLAG ${DEST} ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    append_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${DEST} ${flag})
   endforeach()
 endmacro()
 
 # Add a macro definition if condition is true.
 macro(define_if condition def)
   if (${condition})
     add_definitions(${def})
   endif()

 endmacro()
 
 # Add all the flags supported by the compiler to all of
 # 'CMAKE_CXX_FLAGS', 'CMAKE_C_FLAGS', 'LIBCXXABI_COMPILE_FLAGS'
 # and 'LIBCXXABI_LINK_FLAGS'.
 macro(add_target_flags_if_supported)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXXABI_SUPPORTS_${flagname}_FLAG")
-    add_target_flags_if(LIBCXXABI_SUPPORTS_${flagname}_FLAG ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    add_target_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a specified list of flags to both 'LIBCXXABI_COMPILE_FLAGS' and
 # 'LIBCXXABI_LINK_FLAGS'.
 macro(add_flags)
   foreach(value ${ARGN})
     list(APPEND LIBCXXABI_COMPILE_FLAGS ${value})
macro(add_flags_if condition)
   endif()
 endmacro()
 
 # Add each flag in the list to LIBCXXABI_COMPILE_FLAGS and LIBCXXABI_LINK_FLAGS
 # if that flag is supported by the current compiler.
 macro(add_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_cxx_compiler_flag("${flag}" "LIBCXXABI_SUPPORTS_${flagname}_FLAG")
-      add_flags_if(LIBCXXABI_SUPPORTS_${flagname}_FLAG ${flag})
+      check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+      add_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBCXXABI_COMPILE_FLAGS'.
 macro(add_compile_flags)
   foreach(f ${ARGN})
     list(APPEND LIBCXXABI_COMPILE_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBCXXABI_COMPILE_FLAGS'
 macro(add_compile_flags_if condition)
   if (${condition})
     add_compile_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBCXXABI_COMPILE_FLAGS' if the
 # flag is supported by the C++ compiler.
 macro(add_compile_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_cxx_compiler_flag("${flag}" "LIBCXXABI_SUPPORTS_${flagname}_FLAG")
-      add_compile_flags_if(LIBCXXABI_SUPPORTS_${flagname}_FLAG ${flag})
+      check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+      add_compile_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBCXXABI_COMPILE_FLAGS' if the
 # flag is supported by the C compiler.
 macro(add_c_compile_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_c_compiler_flag("${flag}" "LIBCXXABI_SUPPORTS_${flagname}_FLAG")
-      add_compile_flags_if(LIBCXXABI_SUPPORTS_${flagname}_FLAG ${flag})
+      check_c_compiler_flag("${flag}" "C_SUPPORTS_${flagname}_FLAG")
+      add_compile_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBCXXABI_LINK_FLAGS'.
 macro(add_link_flags)
   foreach(f ${ARGN})
     list(APPEND LIBCXXABI_LINK_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBCXXABI_LINK_FLAGS'
 macro(add_link_flags_if condition)
   if (${condition})
     add_link_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBCXXABI_LINK_FLAGS' if the
 # flag is supported by the C++ compiler.
 macro(add_link_flags_if_supported)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBCXXABI_SUPPORTS_${flagname}_FLAG")
-    add_link_flags_if(LIBCXXABI_SUPPORTS_${flagname}_FLAG ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    add_link_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of libraries or link flags to 'LIBCXXABI_LIBRARIES'.
 macro(add_library_flags)
   foreach(lib ${ARGN})
     list(APPEND LIBCXXABI_LIBRARIES ${lib})
   endforeach()

libcxxabi/cmake/config-ix.cmake

 # 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 -nodefaultlibs) and the flags that are actually
 # required during compilation (which has the -nodefaultlibs). libc is
 # required for the link to go through. We remove sanitizers from the
 # configuration checks to avoid spurious link errors.
 
-check_c_compiler_flag(-nostdlib++ LIBCXXABI_SUPPORTS_NOSTDLIBXX_FLAG)
-if (LIBCXXABI_SUPPORTS_NOSTDLIBXX_FLAG)
+check_cxx_compiler_flag(-nostdlib++ CXX_SUPPORTS_NOSTDLIBXX_FLAG)
+if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdlib++")
 else()
-  check_c_compiler_flag(-nodefaultlibs LIBCXXABI_SUPPORTS_NODEFAULTLIBS_FLAG)
-  if (LIBCXXABI_SUPPORTS_NODEFAULTLIBS_FLAG)
+  check_c_compiler_flag(-nodefaultlibs C_SUPPORTS_NODEFAULTLIBS_FLAG)
+  if (C_SUPPORTS_NODEFAULTLIBS_FLAG)
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
   endif()
 endif()
 
-if (LIBCXXABI_SUPPORTS_NOSTDLIBXX_FLAG OR LIBCXXABI_SUPPORTS_NODEFAULTLIBS_FLAG)
+if (CXX_SUPPORTS_NOSTDLIBXX_FLAG OR C_SUPPORTS_NODEFAULTLIBS_FLAG)
   if (LIBCXXABI_HAS_C_LIB)
     list(APPEND CMAKE_REQUIRED_LIBRARIES c)
   endif ()
   if (LIBCXXABI_USE_COMPILER_RT)
     include(HandleCompilerRT)
     find_compiler_rt_library(builtins LIBCXXABI_BUILTINS_LIBRARY
                              FLAGS "${LIBCXXABI_COMPILE_FLAGS}")
     list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBCXXABI_BUILTINS_LIBRARY}")

 
 # Check compiler pragmas
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   cmake_push_check_state()
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror=unknown-pragmas")
   check_c_source_compiles("
 #pragma comment(lib, \"c\")
 int main() { return 0; }
-" LIBCXXABI_HAS_COMMENT_LIB_PRAGMA)
+" C_SUPPORTS_COMMENT_LIB_PRAGMA)
   cmake_pop_check_state()
 endif()
 
 # Check compiler flags
-check_cxx_compiler_flag(-nostdinc++ LIBCXXABI_HAS_NOSTDINCXX_FLAG)
+check_cxx_compiler_flag(-nostdinc++ CXX_SUPPORTS_NOSTDINCXX_FLAG)
 
 # Check libraries
 if(FUCHSIA)
   set(LIBCXXABI_HAS_DL_LIB NO)
   set(LIBCXXABI_HAS_PTHREAD_LIB NO)
   check_library_exists(c __cxa_thread_atexit_impl ""
     LIBCXXABI_HAS_CXA_THREAD_ATEXIT_IMPL)
   set(LIBCXXABI_HAS_SYSTEM_LIB NO)
 else()
   check_library_exists(dl dladdr "" LIBCXXABI_HAS_DL_LIB)
   check_library_exists(pthread pthread_once "" LIBCXXABI_HAS_PTHREAD_LIB)
   check_library_exists(c __cxa_thread_atexit_impl ""
     LIBCXXABI_HAS_CXA_THREAD_ATEXIT_IMPL)
   check_library_exists(System write "" LIBCXXABI_HAS_SYSTEM_LIB)
 endif()

libcxxabi/src/CMakeLists.txt

if (ANDROID AND ANDROID_PLATFORM_LEVEL LESS 21)
   list(APPEND LIBCXXABI_LIBRARIES android_support)
 endif()
 
 if (NOT LIBCXXABI_USE_COMPILER_RT)
   add_library_flags_if(LIBCXXABI_HAS_GCC_LIB gcc)
 endif ()
 
 # Setup flags.
-if (LIBCXXABI_SUPPORTS_NOSTDLIBXX_FLAG)
+if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   add_link_flags_if_supported(-nostdlib++)
 else()
   add_link_flags_if_supported(-nodefaultlibs)
 endif()
 
 if ( APPLE )
   if (LLVM_USE_SANITIZER)
     if (("${LLVM_USE_SANITIZER}" STREQUAL "Address") OR

libunwind/CMakeLists.txt

 #
 # 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(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 add_compile_flags_if_supported(-funwind-tables)
 set(CMAKE_TRY_COMPILE_TARGET_TYPE ${_previous_CMAKE_TRY_COMPILE_TARGET_TYPE})
 
-if (LIBUNWIND_USES_ARM_EHABI AND NOT LIBUNWIND_SUPPORTS_FUNWIND_TABLES_FLAG)
+if (LIBUNWIND_USES_ARM_EHABI AND NOT CXX_SUPPORTS_FUNWIND_TABLES_FLAG)
   message(SEND_ERROR "The -funwind-tables flag must be supported "
                      "because this target uses ARM Exception Handling ABI")
 endif()
 
 add_cxx_compile_flags_if_supported(-fno-exceptions)
 add_cxx_compile_flags_if_supported(-fno-rtti)
 
 # Ensure that we don't depend on C++ standard library.
-if (LIBUNWIND_HAS_NOSTDINCXX_FLAG)
+if (CXX_SUPPORTS_NOSTDINCXX_FLAG)
   list(APPEND LIBUNWIND_COMPILE_FLAGS -nostdinc++)
   # Remove -stdlib flags to prevent them from causing an unused flag warning.
   string(REPLACE "--stdlib=libc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REPLACE "--stdlib=libstdc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REPLACE "-stdlib=libc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   string(REPLACE "-stdlib=libstdc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 endif()
 
if (MSVC)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 # Disable DLL annotations on Windows for static builds.
 if (WIN32 AND LIBUNWIND_ENABLE_STATIC AND NOT LIBUNWIND_ENABLE_SHARED)
   add_definitions(-D_LIBUNWIND_HIDE_SYMBOLS)
 endif()
 
-if (LIBUNWIND_HAS_COMMENT_LIB_PRAGMA)
+if (C_SUPPORTS_COMMENT_LIB_PRAGMA)
   if (LIBUNWIND_HAS_DL_LIB)
     add_definitions(-D_LIBUNWIND_LINK_DL_LIB)
   endif()
   if (LIBUNWIND_HAS_PTHREAD_LIB)
     add_definitions(-D_LIBUNWIND_LINK_PTHREAD_LIB)
   endif()
 endif()
 

libunwind/cmake/Modules/HandleLibunwindFlags.cmake

foreach(var ${ARGN})
     string(REPLACE "${var}" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
     string(REPLACE "${var}" "" CMAKE_SHARED_MODULE_FLAGS "${CMAKE_SHARED_MODULE_FLAGS}")
     remove_definitions(${var})
   endforeach()
 endmacro(remove_flags)
 
 macro(check_flag_supported flag)
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
 endmacro()
 
 macro(append_flags DEST)
   foreach(value ${ARGN})
     list(APPEND ${DEST} ${value})
     list(APPEND ${DEST} ${value})
   endforeach()
 endmacro()
 
 # If the specified 'condition' is true then append the specified list of flags to DEST
 macro(append_flags_if condition DEST)
   if (${condition})
     list(APPEND ${DEST} ${ARGN})
   endif()
 endmacro()
 
 # Add each flag in the list specified by DEST if that flag is supported by the current compiler.
 macro(append_flags_if_supported DEST)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
-    append_flags_if(LIBUNWIND_SUPPORTS_${flagname}_FLAG ${DEST} ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    append_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${DEST} ${flag})
   endforeach()
 endmacro()
 
 # Add a macro definition if condition is true.
 macro(define_if condition def)
   if (${condition})
     add_definitions(${def})
   endif()

 endmacro()
 
 # Add all the flags supported by the compiler to all of
 # 'CMAKE_CXX_FLAGS', 'CMAKE_C_FLAGS', 'LIBUNWIND_COMPILE_FLAGS'
 # and 'LIBUNWIND_LINK_FLAGS'.
 macro(add_target_flags_if_supported)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
-    add_target_flags_if(LIBUNWIND_SUPPORTS_${flagname}_FLAG ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    add_target_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a specified list of flags to both 'LIBUNWIND_COMPILE_FLAGS' and
 # 'LIBUNWIND_LINK_FLAGS'.
 macro(add_flags)
   foreach(value ${ARGN})
     list(APPEND LIBUNWIND_COMPILE_FLAGS ${value})
macro(add_flags_if condition)
   endif()
 endmacro()
 
 # Add each flag in the list to LIBUNWIND_COMPILE_FLAGS and LIBUNWIND_LINK_FLAGS
 # if that flag is supported by the current compiler.
 macro(add_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_cxx_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
-      add_flags_if(LIBUNWIND_SUPPORTS_${flagname}_FLAG ${flag})
+      check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+      add_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBUNWIND_COMPILE_FLAGS'.
 macro(add_compile_flags)
   foreach(f ${ARGN})
     list(APPEND LIBUNWIND_COMPILE_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBUNWIND_COMPILE_FLAGS'
 macro(add_compile_flags_if condition)
   if (${condition})
     add_compile_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBUNWIND_COMPILE_FLAGS' if the
 # flag is supported by the C++ compiler.
 macro(add_compile_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_cxx_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
-      add_compile_flags_if(LIBUNWIND_SUPPORTS_${flagname}_FLAG ${flag})
+      check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+      add_compile_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBUNWIND_C_FLAGS'.
 macro(add_c_flags)
   foreach(f ${ARGN})
     list(APPEND LIBUNWIND_C_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBUNWIND_C_FLAGS'
 macro(add_c_flags_if condition)
   if (${condition})
     add_c_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBUNWIND_C_FLAGS' if the
 # flag is supported by the C compiler.
 macro(add_c_compile_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_c_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
-      add_c_flags_if(LIBUNWIND_SUPPORTS_${flagname}_FLAG ${flag})
+      check_c_compiler_flag("${flag}" "C_SUPPORTS_${flagname}_FLAG")
+      add_c_flags_if(C_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBUNWIND_CXX_FLAGS'.
 macro(add_cxx_flags)
   foreach(f ${ARGN})
     list(APPEND LIBUNWIND_CXX_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBUNWIND_CXX_FLAGS'
 macro(add_cxx_flags_if condition)
   if (${condition})
     add_cxx_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBUNWIND_CXX_FLAGS' if the
 # flag is supported by the C compiler.
 macro(add_cxx_compile_flags_if_supported)
   foreach(flag ${ARGN})
       mangle_name("${flag}" flagname)
-      check_cxx_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
-      add_cxx_flags_if(LIBUNWIND_SUPPORTS_${flagname}_FLAG ${flag})
+      check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+      add_cxx_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of flags to 'LIBUNWIND_LINK_FLAGS'.
 macro(add_link_flags)
   foreach(f ${ARGN})
     list(APPEND LIBUNWIND_LINK_FLAGS ${f})
   endforeach()
 endmacro()
 
 # If 'condition' is true then add the specified list of flags to
 # 'LIBUNWIND_LINK_FLAGS'
 macro(add_link_flags_if condition)
   if (${condition})
     add_link_flags(${ARGN})
   endif()
 endmacro()
 
 # For each specified flag, add that flag to 'LIBUNWIND_LINK_FLAGS' if the
 # flag is supported by the C++ compiler.
 macro(add_link_flags_if_supported)
   foreach(flag ${ARGN})
     mangle_name("${flag}" flagname)
-    check_cxx_compiler_flag("${flag}" "LIBUNWIND_SUPPORTS_${flagname}_FLAG")
-    add_link_flags_if(LIBUNWIND_SUPPORTS_${flagname}_FLAG ${flag})
+    check_cxx_compiler_flag("${flag}" "CXX_SUPPORTS_${flagname}_FLAG")
+    add_link_flags_if(CXX_SUPPORTS_${flagname}_FLAG ${flag})
   endforeach()
 endmacro()
 
 # Add a list of libraries or link flags to 'LIBUNWIND_LIBRARIES'.
 macro(add_library_flags)
   foreach(lib ${ARGN})
     list(APPEND LIBUNWIND_LIBRARIES ${lib})
   endforeach()

libunwind/cmake/config-ix.cmake

 include(CMakePushCheckState)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckLibraryExists)
 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_compiler_linker_flag(C "--unwindlib=none" LIBUNWIND_SUPPORTS_UNWINDLIB_NONE_FLAG)
-if (LIBUNWIND_SUPPORTS_UNWINDLIB_NONE_FLAG)
+llvm_check_compiler_linker_flag(C "--unwindlib=none" CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG)
+if (CXX_SUPPORTS_UNWINDLIB_EQ_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_compiler_linker_flag(C "-nostdlib++" LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG)
-if (LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG)
+llvm_check_compiler_linker_flag(C "-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" LIBUNWIND_SUPPORTS_NODEFAULTLIBS_FLAG)
-  if (LIBUNWIND_SUPPORTS_NODEFAULTLIBS_FLAG)
+  if (C_SUPPORTS_NODEFAULTLIBS_FLAG)
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
   endif()
 endif()
 
-if (LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG OR LIBUNWIND_SUPPORTS_NODEFAULTLIBS_FLAG)
+if (CXX_SUPPORTS_NOSTDLIBXX_FLAG OR C_SUPPORTS_NODEFAULTLIBS_FLAG)
   if (LIBUNWIND_HAS_C_LIB)
     list(APPEND CMAKE_REQUIRED_LIBRARIES c)
   endif ()
   if (LIBUNWIND_USE_COMPILER_RT)
     include(HandleCompilerRT)
     find_compiler_rt_library(builtins LIBUNWIND_BUILTINS_LIBRARY
                              FLAGS ${LIBUNWIND_COMPILE_FLAGS})
     list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBUNWIND_BUILTINS_LIBRARY}")

 
 # Check compiler pragmas
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   cmake_push_check_state()
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror=unknown-pragmas")
   check_c_source_compiles("
 #pragma comment(lib, \"c\")
 int main() { return 0; }
-" LIBUNWIND_HAS_COMMENT_LIB_PRAGMA)
+" C_SUPPORTS_COMMENT_LIB_PRAGMA)
   cmake_pop_check_state()
 endif()
 
 # Check compiler flags
-check_cxx_compiler_flag(-nostdinc++ LIBUNWIND_HAS_NOSTDINCXX_FLAG)
+check_cxx_compiler_flag(-nostdinc++ CXX_SUPPORTS_NOSTDINCXX_FLAG)
 
 # Check symbols
 check_symbol_exists(__arm__ "" LIBUNWIND_TARGET_ARM)
 check_symbol_exists(__USING_SJLJ_EXCEPTIONS__ "" LIBUNWIND_USES_SJLJ_EXCEPTIONS)
 check_symbol_exists(__ARM_DWARF_EH__ "" LIBUNWIND_USES_DWARF_EH)
 
 if(LIBUNWIND_TARGET_ARM AND NOT LIBUNWIND_USES_SJLJ_EXCEPTIONS AND NOT LIBUNWIND_USES_DWARF_EH)
   # This condition is copied from __libunwind_config.h

libunwind/src/CMakeLists.txt

 endif()
 add_library_flags_if(LIBUNWIND_HAS_DL_LIB dl)
 if (LIBUNWIND_ENABLE_THREADS)
   add_library_flags_if(LIBUNWIND_HAS_PTHREAD_LIB pthread)
   add_compile_flags_if(LIBUNWIND_WEAK_PTHREAD_LIB -DLIBUNWIND_USE_WEAK_PTHREAD=1)
 endif()
 
 # Setup flags.
-add_link_flags_if(LIBUNWIND_SUPPORTS_UNWINDLIB_NONE_FLAG --unwindlib=none)
-if (LIBUNWIND_SUPPORTS_NOSTDLIBXX_FLAG)
+add_link_flags_if(CXX_SUPPORTS_UNWINDLIB_EQ_NONE_FLAG --unwindlib=none)
+if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   add_link_flags_if_supported(-nostdlib++)
 else()
   add_link_flags_if_supported(-nodefaultlibs)
 endif()
 
 # MINGW_LIBRARIES is defined in config-ix.cmake
 add_library_flags_if(MINGW "${MINGW_LIBRARIES}")
 
 if (LIBUNWIND_ENABLE_SHARED AND
-    NOT (LIBUNWIND_SUPPORTS_FNO_EXCEPTIONS_FLAG AND
-         LIBUNWIND_SUPPORTS_FUNWIND_TABLES_FLAG))
+    NOT (CXX_SUPPORTS_FNO_EXCEPTIONS_FLAG AND
+         CXX_SUPPORTS_FUNWIND_TABLES_FLAG))
   message(FATAL_ERROR
           "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.")
 endif()
 
 if (APPLE)
   add_compile_flags("-U__STRICT_ANSI__")

runtimes/CMakeLists.txt

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_compiler_linker_flag(C "-nostdlib++" LLVM_RUNTIMES_SUPPORT_NOSTDLIBXX_FLAG)
-if (LLVM_RUNTIMES_SUPPORT_NOSTDLIBXX_FLAG)
+llvm_check_compiler_linker_flag(C "-nostdlib++" CXX_SUPPORTS_NOSTDLIBXX_FLAG)
+if (CXX_SUPPORTS_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)
+check_cxx_compiler_flag(-nostdinc++ CXX_SUPPORTS_NOSTDINCXX_FLAG)
+if (CXX_SUPPORTS_NOSTDINCXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdinc++")
 endif()
 
 # Avoid checking whether the compiler is working.
 set(LLVM_COMPILER_CHECKED ON)
 
 # Handle common options used by all runtimes.
 include(AddLLVM)