[libc++] Add a 'is-lockfree-runtime-function' lit feature

[arichardson]

Summary

On macOS 10.14 /usr/lib/system/libcompiler_rt.dylib contains all the
__atomic_load*, etc. functions but does not include the __atomic_is_lock_free
function. The lack of this function causes the non-lockfree-atomics feature
to be set to false even though large atomic operations are actually
supported, it's just the is_lock_free() function that is missing.

This is required so that the !non-lockfree-atomics feature can be used
to XFAIL tests that require runtime library support (D88818).

[arichardson]

Correctly skip align.pass.pass.cpp for macOS

[arichardson]

rebase after formatting change

[ldionne]

libcxx/test/libcxx/atomics/atomics.align/align.pass.pass.cpp

10 ↗

(On Diff #307861)

Ok, I think we're getting down to the bottom of my concern now. When is !is-lockfree-runtime-function true, but non-lockfree-atomics not true?

I want to understand in what context those can't be substituted for one another.

10 ↗

(On Diff #307861)

Never mind, I re-read the review summary and it explains it.

[ldionne]

How difficult would it be to implement __atomic_is_lock_free in compiler-rt? I think something like this in atomic.c would work:

int __atomic_is_lock_free(size_t size, void const volatile* ptr) {
#define LOCK_FREE_ACTION(type) return sizeof(type) <= size;
  LOCK_FREE_CASES(ptr);
#undef LOCK_FREE_ACTION
  return 0;
}

However, I'm not familiar with how to add builtins in compiler-rt, and I haven't been able to figure out the details at a glance.

Do I understand correctly that:

1. When Clang sees __atomic_is_lock_free(args...), it tries to generate code directly for it if it can.
2. Otherwise, it generates an external call to a function called int __atomic_is_lock_free(unsigned long, void const volatile*);
3. If a library that defines this function isn't provided, a linker error follows

Is that how these work? We can definitely add a workaround to fix the test suite here, however I'd also like to actually solve the root cause of this issue. It's also something we've had requests about in the past.

[arichardson]

In D91911#2420671, @ldionne wrote:

How difficult would it be to implement __atomic_is_lock_free in compiler-rt? I think something like this in atomic.c would work:

int __atomic_is_lock_free(size_t size, void const volatile* ptr) {
#define LOCK_FREE_ACTION(type) return sizeof(type) <= size;
  LOCK_FREE_CASES(ptr);
#undef LOCK_FREE_ACTION
  return 0;
}

However, I'm not familiar with how to add builtins in compiler-rt, and I haven't been able to figure out the details at a glance.

Do I understand correctly that:

1. When Clang sees __atomic_is_lock_free(args...), it tries to generate code directly for it if it can.
2. Otherwise, it generates an external call to a function called int __atomic_is_lock_free(unsigned long, void const volatile*);
3. If a library that defines this function isn't provided, a linker error follows

Is that how these work? We can definitely add a workaround to fix the test suite here, however I'd also like to actually solve the root cause of this issue. It's also something we've had requests about in the past.

That matches my understanding and what the GCC documentation says:

Built-in Function: bool __atomic_is_lock_free (size_t size, void *ptr)
This built-in function returns true if objects of size bytes always generate lock-free atomic instructions for the target architecture. If the built-in function is not known to be lock-free, a call is made to a runtime routine named __atomic_is_lock_free.
ptr is an optional pointer to the object that may be used to determine alignment. A value of 0 indicates typical alignment should be used. The compiler may also ignore this parameter.

I've also posted D92302 to implement this in compiler-rt.

[ldionne]

Apart from the TODO comment, LGTM. Ship it with the comment.

libcxx/utils/libcxx/test/features.py

45

Can you add a TODO to remove this once compiler-rt ships atomic_is_lockfree?

[arichardson]

Thanks for reviewing!

libcxx/utils/libcxx/test/features.py

45

Sure, will do. However, it will still be needed for older versions of macOS+FreeBSD that don't include the function, so I guess it will be a while until it can be removed.

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
   Feature(name='libcpp-no-structured-bindings', when=lambda cfg: '__cpp_structured_bindings' not in featureTestMacros(cfg)),
   Feature(name='libcpp-no-deduction-guides',    when=lambda cfg: featureTestMacros(cfg).get('__cpp_deduction_guides', 0) < 201611),
   Feature(name='libcpp-no-concepts',            when=lambda cfg: featureTestMacros(cfg).get('__cpp_concepts', 0) < 201811),
   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='modules-support',               when=lambda cfg: hasCompileFlag(cfg, '-fmodules')),
   Feature(name='non-lockfree-atomics',          when=lambda cfg: sourceBuilds(cfg, """
                                                                   #include <atomic>
                                                                   struct Large { int storage[100]; };
                                                                   std::atomic<Large> x;
-                                                                  int main(int, char**) { return x.load(), x.is_lock_free(); }
+                                                                  int main(int, char**) { (void)x.load(); return 0; }
+                                                                """)),
+  Feature(name='is-lockfree-runtime-function',  when=lambda cfg: sourceBuilds(cfg, """
+                                                                  #include <atomic>
+                                                                  struct Large { int storage[100]; };
+                                                                  std::atomic<Large> x;
+                                                                  int main(int, char**) { return x.is_lock_free(); }
                                                                 """)),
 
   Feature(name='apple-clang',                                                                                                      when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}'.format(**compilerMacros(cfg)),                                          when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}'.format(**compilerMacros(cfg)),                        when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}.{__clang_patchlevel__}'.format(**compilerMacros(cfg)), when=_isAppleClang),
 
   Feature(name='clang',                                                                                                            when=_isClang),