Repair cmake libatomic check.

[jyknight]

Summary

The cmake check for whether libatomic could be used had been
unconditionally setting the result to false. Which was somewhat
fortunate, because the prerequisite check for whether it was *needed*
was always claiming it was, even if it was not.

However, this made platforms where libatomic is actually necessary
fail to link.

[jyknight]

BTW, I've tested this patch both on a platform that does need libatomic (sparc, with clang as host compiler), and two that don't (x86-64 and sparc with gcc host compiler) and verified that it does the right thing on both kinds.

[chandlerc]

Looks good, but be cautious in landing this. There may be platforms where this detection scheme fails but where LLVM was by some miracle getting a working <atomic> header and we'll need to figure out why/how in order to get the detection to work.

Also, as a side note, file a bug to track LLVM being able to work on SPARC without libatomic? ;] If GCC can do it....

[jyknight]

Thanks. I'll land it in the morning when I can watch for problems. :)

As to the side note:

GCC can do it only because its default target on Debian is the "v8plus"
mode, which is the SparcV8 32bit calling convention/ABI, but assuming a
minimum of a Sparc V9 CPU to execute on. This allows the use of the V9
instructions, and the ability to store 64bit values in some of the
registers.

But, a base Sparc V8 truly cannot support native atomic-ops (in GCC
either), because it doesn't have a CAS instruction or LL/SC. The only
primitive atomic ops available are swap, load, and store, which are only
enough to implement locks.

There's not even any magic kernel userspace-helper routine for doing atomic
cmpxchg, like there is for ARMv5, presumably because nobody really cares
about base sparc v8: the v9 cpu was introduced 20 years ago, and even the
popular LEON embedded sparcv8 chip has CAS an an extension (though,
unfortunately incompatible with the v9 one, for somewhat-reasonable
reasons).

Anyways, currently LLVM supports v9 only in the 64bit ABI, not as a cpu for
the v8 ABI. Thus, the lack of atomics support here is actually working as
intended -- for the "v8" cpu that LLVM is compiling for.

cmake/modules/CheckAtomic.cmake

 # atomic builtins are required for threading support.
 
 INCLUDE(CheckCXXSourceCompiles)
 
-check_function_exists(__atomic_fetch_add_4 HAVE___ATOMIC_FETCH_ADD_4)
-if( NOT HAVE___ATOMIC_FETCH_ADD_4 )
+# 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 "-std=c++11")
+  CHECK_CXX_SOURCE_COMPILES("
+#include <atomic>
+std::atomic<int> x;
+int main() {
+  return x;
+}
+" ${varname})
+  set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+endfunction(check_working_cxx_atomics)
+
+# This isn't necessary on MSVC, so avoid command-line switch annoyance
+# by only running on GCC-like hosts.
+if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
+  # First check if atomics work without the library.
+  check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITHOUT_LIB)
+  # If not, check if the library exists, and atomics work with it.
+  if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
     check_library_exists(atomic __atomic_fetch_add_4 "" HAVE_LIBATOMIC)
-  set(HAVE_LIBATOMIC False)
     if( HAVE_LIBATOMIC )
       list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+      check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
+      if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
+  message(FATAL_ERROR "Host compiler must support std::atomic!")
+      endif()
+    else()
+      message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
+    endif()
   endif()
 endif()
 
+## TODO: This define is only used for the legacy atomic operations in
+## llvm's Atomic.h, which should be replaced.  Other code simply
+## assumes C++11 <atomic> works.
 CHECK_CXX_SOURCE_COMPILES("
 #ifdef _MSC_VER
 #include <Intrin.h> /* Workaround for PR19898. */
 #include <windows.h>
 #endif
 int main() {
 #ifdef _MSC_VER
         volatile LONG val = 1;