[CMake] Use __libc_start_main rather than fopen when checking for C library

[phosek]

Summary

The check_library_exists CMake uses a custom symbol definition. This
is a problem when checking for C library symbols because Clang
recognizes many of them as builtins, and returns the
-Wbuiltin-requires-header (or -Wincompatible-library-redeclaration)
error. When building with -Werror which is the default, this causes
the check_library_exists check fail making the build think that C
library isn't available.

To avoid this issue, we should use a symbol that isn't recognized by
Clang and wouldn't cause the same issue. __libc_start_main seems like
reasonable choice that fits the bill.

[phosek]

I ran into this while debugging http://lab.llvm.org:8014/builders/fuchsia-x86_64-linux/builds/146/steps/ninja-build/logs/stdio, this fails because CMake fails to find libatomic, but that's not the real culprit, the real culprit is that CMake fails to find libc, so it doesn't include it on the link line when testing for libatomic which makes that check fail for obvious reasons.

[smeenai]

-Werror is the default in general, or for some particular configuration? Passing -Werror to configuration checks seems like a bad idea in general...

This seems reasonable, but it also seems fragile (e.g. what if clang starts recognizing atexit some day). Thoughts on a more robust fix? Perhaps check_library_exists should strip out any -Werror flags, but that would be a CMake-side change... maybe we could do something with CMAKE_REQUIRED_FLAGS?

[mgorny]

I don't know if it works with the way CMake checks stuff but I think autotools can be fooled by checking for main.

[phosek]

In D57142#1371909, @smeenai wrote:

-Werror is the default in general, or for some particular configuration? Passing -Werror to configuration checks seems like a bad idea in general...

Agreed, but I think that's a broader discussion. There are also cases where that's desirable.

This seems reasonable, but it also seems fragile (e.g. what if clang starts recognizing atexit some day). Thoughts on a more robust fix? Perhaps check_library_exists should strip out any -Werror flags, but that would be a CMake-side change... maybe we could do something with CMAKE_REQUIRED_FLAGS?

I could wrap the check_library_exists in cmake_push_check_state and cmake_pop_check_state and add -Wno-error to CMAKE_REQUIRED_FLAGS.

In D57142#1372387, @mgorny wrote:

I don't know if it works with the way CMake checks stuff but I think autotools can be fooled by checking for main.

I don't think main works because that's not a symbol provided by libc, but this gave me an idea to use __libc_start_main which is better than atexit because while the latter might be eventually recognized by Clang, the former won't be since that one isn't defined in any public libc header. This also matches what we do for other libraries like libgcc_s (__gcc_personality_v0) or libc++ (__cxa_throw) where we also rely on internal symbols.

[mclow.lists]

This change breaks building on Mac OS X - at least for libc++.
The user visible failure is:

-- Performing Test LIBCXX_SUPPORTS_STD_EQ_CXX11_FLAG
-- Performing Test LIBCXX_SUPPORTS_STD_EQ_CXX11_FLAG - Failed
-- Performing Test LIBCXX_SUPPORTS_STD_COLON_CXX11_FLAG
-- Performing Test LIBCXX_SUPPORTS_STD_COLON_CXX11_FLAG - Failed
CMake Error at CMakeLists.txt:526 (message):
  C++11 or greater is required but the compiler does not support c++11

and in the log, I see:

Performing C++ SOURCE FILE Test LIBCXX_SUPPORTS_STD_EQ_CXX11_FLAG failed with the following output:
Change Dir: /Sources/LLVM/build/test-libcxx/CMakeFiles/CMakeTmp

Run Build Command:"/usr/local/bin/ninja" "cmTC_4ab59"
[1/2] Building CXX object CMakeFiles/cmTC_4ab59.dir/src.cxx.o
[2/2] Linking CXX executable cmTC_4ab59
FAILED: cmTC_4ab59 
: && /Sources/LLVM/bin/bin/clang++  -DLIBCXX_SUPPORTS_STD_EQ_CXX11_FLAG  -nodefaultlibs -Wl,-search_paths_first -Wl,-headerpad_max_install_names  CMakeFiles/cmTC_4ab59.dir/src.cxx.o  -o cmTC_4ab59   && :
ld: dynamic main executables must link with libSystem.dylib for architecture x86_64
clang-9: error: linker command failed with exit code 1 (use -v to see invocation)
ninja: build stopped: subcommand failed.

Source file was:
int main() { return 0; }

compiler-rt/cmake/config-ix.cmake

 include(CMakePushCheckState)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckLibraryExists)
 include(CheckSymbolExists)
 include(TestBigEndian)
 
 function(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)
+check_library_exists(c atexit "" COMPILER_RT_HAS_LIBC)
 if (COMPILER_RT_USE_BUILTINS_LIBRARY)
   include(HandleCompilerRT)
   find_compiler_rt_library(builtins COMPILER_RT_BUILTINS_LIBRARY)
 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)

libcxx/cmake/config-ix.cmake

 include(CheckLibraryExists)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
 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)
+  check_library_exists(c atexit "" LIBCXX_HAS_C_LIB)
 endif()
 
 if (NOT LIBCXX_USE_COMPILER_RT)
   if(WIN32 AND NOT MINGW)
     set(LIBCXX_HAS_GCC_S_LIB NO)
   else()
     check_library_exists(gcc_s __gcc_personality_v0 "" LIBCXX_HAS_GCC_S_LIB)
   endif()

libcxxabi/cmake/config-ix.cmake

 include(CheckLibraryExists)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
-check_library_exists(c fopen "" LIBCXXABI_HAS_C_LIB)
+check_library_exists(c atexit "" LIBCXXABI_HAS_C_LIB)
 if (NOT LIBCXXABI_USE_COMPILER_RT)
   check_library_exists(gcc_s __gcc_personality_v0 "" LIBCXXABI_HAS_GCC_S_LIB)
 endif ()
 
 # libc++abi is built with -nodefaultlibs, so we want all our checks to also
 # use this option, 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

libunwind/cmake/config-ix.cmake

 
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckLibraryExists)
 
-check_library_exists(c fopen "" LIBUNWIND_HAS_C_LIB)
+check_library_exists(c atexit "" LIBUNWIND_HAS_C_LIB)
 
 if (NOT LIBUNWIND_USE_COMPILER_RT)
   check_library_exists(gcc_s __gcc_personality_v0 "" LIBUNWIND_HAS_GCC_S_LIB)
   check_library_exists(gcc __absvdi2 "" LIBUNWIND_HAS_GCC_LIB)
 endif()
 
 # libunwind is built with -nodefaultlibs, so we want all our checks to also
 # use this option, otherwise we may end up with an inconsistency between

llvm/runtimes/CMakeLists.txt

if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
   endif()
 
   set(SAFE_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
   set(SAFE_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
 
   include(CheckLibraryExists)
   include(CheckCCompilerFlag)
 
-  check_library_exists(c fopen "" LLVM_HAS_C_LIB)
+  check_library_exists(c atexit "" LLVM_HAS_C_LIB)
   check_c_compiler_flag(-nodefaultlibs LLVM_HAS_NODEFAULTLIBS_FLAG)
   if(LLVM_HAS_NODEFAULTLIBS_FLAG)
     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
     if(LLVM_HAS_C_LIB)
       list(APPEND CMAKE_REQUIRED_LIBRARIES c)
     endif()
   endif()