[scudo][standalone] Use CheckAtomic to decide to link to libatomic

[benwolsieffer]

Summary

Standalone scudo uses the atomic operation builtin functions, which require
linking to libatomic on some platforms. Currently, this is done in an ad-hoc
manner. MIPS platforms always link to libatomic, and the tests are always linked
to it as well. libatomic is required on base ARMv6 (but not ARMv6K), but it is
currently not linked, causing the build to fail.

This patch replaces this ad-hoc logic with the CheckAtomic CMake module already
used in other parts of LLVM. The CheckAtomic module checks whether std::atomic
requires libatomic, which is not strictly the same as checking the atomic
builtins, but should have the same results as far as I know. If this is
problematic, a custom version of CheckAtomic could be used to specifically test
the builtins.

[benwolsieffer]

Note that I have not tested this exact version of the patch. My testing so far has been done with a backported version with LLVM 14.

I would appreciate feedback about whether compiler-rt should have its own version of CheckAtomic.cmake (that specifically checks for builtins) or whether using the LLVM one is good enough.

[vitalybuka]

Is this still relevant?

[benwolsieffer]

Rebased on main

[benwolsieffer]

Yes, this is still needed along with https://reviews.llvm.org/D139585 and https://reviews.llvm.org/D139600 to build compiler-rt on plain ARMv6 (not ARMv6k).

[benwolsieffer]

Update diff with arcanist to provide full context. I was previously having issues with arcanist.

[vitalybuka]

cmake -B ../out/t -GNinja -S llvm '-DLLVM_ENABLE_PROJECTS=clang;lld' '-DLLVM_ENABLE_RUNTIMES=libcxx;libcxxabi;compiler-rt'   -DLLVM_CCACHE_BUILD=ON -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=OFF  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++  -DCMAKE_BUILD_TYPE=Release 

ninja -C ../out/t

-- Performing Test HAVE_CXX_ATOMICS_WITH_LIB
-- Performing Test HAVE_CXX_ATOMICS_WITH_LIB - Failed
CMake Error at llvm-project/llvm/cmake/modules/CheckAtomic.cmake:57 (message):
  Host compiler must support std::atomic!
Call Stack (most recent call first):
  llvm-project/compiler-rt/lib/scudo/standalone/CMakeLists.txt:3 (include)


cat out/t/runtimes/runtimes-bins/CMakeFiles/CMakeError.log

out/t/./bin/clang++ --target=x86_64-unknown-linux-gnu -DHAVE_CXX_ATOMICS_WITH_LIB  -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -Wctad-maybe-unsupported -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -Wno-unused-parameter  --start-no-unused-arguments --unwindlib=none --end-no-unused-arguments -nostdlib++ -nostdinc++ -nodefaultlibs -std=c++11 -std=c++17 -MD -MT CMakeFiles/cmTC_6228f.dir/src.cxx.o -MF CMakeFiles/cmTC_6228f.dir/src.cxx.o.d -o CMakeFiles/cmTC_6228f.dir/src.cxx.o -c out/t/runtimes/runtimes-bins/CMakeFiles/CMakeScratch/TryCompile-1c0GZ3/src.cxx
out/t/runtimes/runtimes-bins/CMakeFiles/CMakeScratch/TryCompile-1c0GZ3/src.cxx:2:10: fatal error: 'atomic' file not found
    2 | #include <atomic>
      |          ^~~~~~~~
1 error generated.

compiler-rt/lib/scudo/standalone/CMakeLists.txt

 add_compiler_rt_component(scudo_standalone)
 
+include(CheckAtomic)
+
 include_directories(../.. include)
 
 set(SCUDO_CFLAGS)
 
 list(APPEND SCUDO_CFLAGS
   -Werror=conversion
   -Wall
   -Wextra
if(COMPILER_RT_DEBUG)
   list(APPEND SCUDO_CFLAGS -O0 -DSCUDO_DEBUG=1 -DSCUDO_ENABLE_HOOKS=1)
 else()
   list(APPEND SCUDO_CFLAGS -O3)
 endif()
 
 append_list_if(COMPILER_RT_HAS_WTHREAD_SAFETY_FLAG -Werror=thread-safety
   SCUDO_CFLAGS)
 
-set(SCUDO_LINK_FLAGS)
+set(SCUDO_LINK_FLAGS ${LLVM_ATOMIC_LIB})
 
 list(APPEND SCUDO_LINK_FLAGS -Wl,-z,defs,-z,now,-z,relro)
 
 list(APPEND SCUDO_LINK_FLAGS -ffunction-sections -fdata-sections -Wl,--gc-sections)
 
 # We don't use the C++ standard library, so avoid including it by mistake.
 append_list_if(COMPILER_RT_HAS_NOSTDLIBXX_FLAG -nostdlib++ SCUDO_LINK_FLAGS)
 append_list_if(CXX_SUPPORTS_UNWINDLIB_NONE_FLAG --unwindlib=none SCUDO_LINK_FLAGS)
if(COMPILER_RT_BUILD_SCUDO_STANDALONE_WITH_LLVM_LIBC)
 
   list(APPEND SCUDO_CFLAGS "-ffreestanding")
 endif()
 
 append_list_if(COMPILER_RT_HAS_LIBPTHREAD -pthread SCUDO_LINK_FLAGS)
 
 append_list_if(FUCHSIA zircon SCUDO_LINK_LIBS)
 
-if(COMPILER_RT_DEFAULT_TARGET_ARCH MATCHES "mips|mips64|mipsel|mips64el")
-  list(APPEND SCUDO_LINK_LIBS atomic)
-endif()
-
 if(COMPILER_RT_HAS_SCUDO_STANDALONE)
   add_compiler_rt_object_libraries(RTScudoStandalone
     ARCHS ${SCUDO_STANDALONE_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES}
     ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     CFLAGS ${SCUDO_CFLAGS}
     DEPS ${SCUDO_DEPS})
   add_compiler_rt_object_libraries(RTScudoStandaloneCWrappers

compiler-rt/lib/scudo/standalone/tests/CMakeLists.txt

append_list_if(COMPILER_RT_HAS_WTHREAD_SAFETY_FLAG -Werror=thread-safety
   SCUDO_UNITTEST_CFLAGS)
 
 set(SCUDO_TEST_ARCH ${SCUDO_STANDALONE_SUPPORTED_ARCH})
 
 # gtests requires c++
 set(SCUDO_UNITTEST_LINK_FLAGS
   ${COMPILER_RT_UNITTEST_LINK_FLAGS}
   ${COMPILER_RT_UNWINDER_LINK_LIBS}
-  ${SANITIZER_TEST_CXX_LIBRARIES})
+  ${SANITIZER_TEST_CXX_LIBRARIES}
+  ${LLVM_ATOMIC_LIB})
 list(APPEND SCUDO_UNITTEST_LINK_FLAGS -pthread -no-pie)
-# Linking against libatomic is required with some compilers
-check_library_exists(atomic __atomic_load_8 "" COMPILER_RT_HAS_LIBATOMIC)
-if (COMPILER_RT_HAS_LIBATOMIC)
-  list(APPEND SCUDO_UNITTEST_LINK_FLAGS -latomic)
-endif()
 
 set(SCUDO_TEST_HEADERS
   scudo_unit_test.h
   )
 foreach (header ${SCUDO_HEADERS})
   list(APPEND SCUDO_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
 endforeach()
 

llvm/cmake/modules/CheckAtomic.cmake

 # atomic builtins are required for threading support.
 
 INCLUDE(CheckCXXSourceCompiles)
 INCLUDE(CheckLibraryExists)
+INCLUDE(DetermineGCCCompatible)
 
 # Sometimes linking against libatomic is required for atomic ops, if
 # the platform doesn't support lock-free atomics.
 
 function(check_working_cxx_atomics varname)
   set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11")
   CHECK_CXX_SOURCE_COMPILES("