[libc++] Fix the dectection of lockfree atomics

[ldionne]

Summary

We were only building the program, however on some systems building will
work, but the program will fail to run due to a dynamic linker error.
When this happens, we will incorrectly think that lockfree atomics are
available when they aren't.

[ldionne]

Abandoning. Will reopen on Github if I want to pursue this.

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
   Feature(name='fdelayed-template-parsing',     when=lambda cfg: hasCompileFlag(cfg, '-fdelayed-template-parsing')),
   Feature(name='libcpp-no-coroutines',          when=lambda cfg: featureTestMacros(cfg).get('__cpp_impl_coroutine', 0) < 201902),
   Feature(name='has-fobjc-arc',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc') and
                                                                  sys.platform.lower().strip() == 'darwin'), # TODO: this doesn't handle cross-compiling to Apple platforms.
   Feature(name='objective-c++',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc')),
   Feature(name='verify-support',                when=lambda cfg: hasCompileFlag(cfg, '-Xclang -verify-ignore-unexpected')),
 
   Feature(name='non-lockfree-atomics',
-          when=lambda cfg: sourceBuilds(cfg, """
+          when=lambda cfg: programSucceeds(cfg, """
+            #include <stddef.h>
+            #if defined(_LIBCPP_HAS_NO_THREADS)
+              int main(int, char**) { return 1; }
+            #else
               #include <atomic>
               struct Large { int storage[100]; };
-            std::atomic<Large> x;
-            int main(int, char**) { (void)x.load(); return 0; }
+              int main(int, char**) {
+                Large l;
+                std::atomic<Large> x(l);
+                (void)x.load();
+                return 0;
+              }
+            #endif
           """)),
   # TODO: Remove this feature once compiler-rt includes __atomic_is_lockfree()
   # on all supported platforms.
   Feature(name='is-lockfree-runtime-function',
-          when=lambda cfg: sourceBuilds(cfg, """
+          when=lambda cfg: programSucceeds(cfg, """
+            #include <stddef.h>
+            #if defined(_LIBCPP_HAS_NO_THREADS)
+              int main(int, char**) { return 1; }
+            #else
               #include <atomic>
               struct Large { int storage[100]; };
-            std::atomic<Large> x;
-            int main(int, char**) { return x.is_lock_free(); }
+              int main(int, char**) {
+                Large l;
+                std::atomic<Large> x(l);
+                (void)x.is_lock_free();
+                return 0;
+              }
+            #endif
           """)),
 
   # Some tests rely on creating shared libraries which link in the C++ Standard Library. In some
   # cases, this doesn't work (e.g. if the library was built as a static archive and wasn't compiled
   # as position independent). This feature informs the test suite of whether it's possible to create
   # a shared library in a shell test by using the '-shared' compiler flag.
   #
   # Note: To implement this check properly, we need to make sure that we use something inside the