Implement is_always_lock_free

[jfb]

Summary

This was voted into C++17 at last week's Jacksonville meeting. The final P0152R1 paper will be in the upcoming post-Jacksonville mailing, and is also available here:

http://jfbastien.github.io/papers/P0152R1.html

The libc++ part of this implementation is in the following code review:

http://reviews.llvm.org/D17951

[jfb]

I'll check with GCC folks whether they want to share macros the same way we're already sharing __GCC_ATOMIC_*_LOCK_FREE. The new macros I propose are __LLVM__ATOMIC_*_BYTES_LOCK_FREE and __LLVM_LOCK_FREE_IS_SIZE_BASED.

Let's do a first sanity-check round of code reviews to make sure I have the LLVM-isms down right, then I'll add GCC folks.

[jfb]

lib/Frontend/InitPreprocessor.cpp

480

How do you pick these numbers before the standard is actually out? 201603 is the Jacksonville meeting, seems fine to me :)

853

Adding these which aren't in the C standard, but which is_always_lock_free would use. We're proposing that floating-point atomics be added so it's not crazy:

http://open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0020r1.html

test/Lexer/cxx-features.cpp

6

This was out of date, I'm updating the test to C++1z, testing C++14, and keeping c++1y for compatibility.

[jfb]

lib/Frontend/InitPreprocessor.cpp

480

Those come from a separate SG10 paper: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0096r1.html#recs.cpp17
A number hasn't been published yet, I'll update the number once the post-Jacksonville mailing is out (I sent Clark a ping).

[jyknight]

This conflicts with http://reviews.llvm.org/D17933. Most of this change also seems unnecessary.

• I think the is_always_lock_free function should be defined based on the existing __atomic_always_lock_free builtin, not on defines (just like is_lock_free uses __atomic_is_lock_free, or __c11_atomic_is_lock_free, which is effectively an alias).
• Then, the new __GCC_ATOMIC_DOUBLE_LOCK_FREE macros are unnecessary, unless we need to actually define a ATOMIC_DOUBLE_LOCK_FREE macro.
• __LLVM_ATOMIC_1_BYTES_LOCK_FREE effectively duplicates __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1, so aren't needed.

[bcraig]

lib/Frontend/InitPreprocessor.cpp

305

On some targets (like Hexagon), 4-byte values are cheap to inline, but 1-byte values are not. Clang is spotty about checking this, but TargetInfo::hasBuiltinAtomic seems like the right function to ask, if you have access to it.

[jfb]

In D17950#376349, @jyknight wrote:

This conflicts with http://reviews.llvm.org/D17933. Most of this change also seems unnecessary.

• I think the is_always_lock_free function should be defined based on the existing __atomic_always_lock_free builtin, not on defines (just like is_lock_free uses __atomic_is_lock_free, or __c11_atomic_is_lock_free, which is effectively an alias).
• Then, the new __GCC_ATOMIC_DOUBLE_LOCK_FREE macros are unnecessary, unless we need to actually define a ATOMIC_DOUBLE_LOCK_FREE macro.
• __LLVM_ATOMIC_1_BYTES_LOCK_FREE effectively duplicates __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1, so aren't needed.

Hmm, when I originally wrote the paper I though I'd tried that. Can't remember why I went the other way, let me try out __atomic_always_lock_free. That would indeed be much simpler as it would be a pure libc++ change., thanks for raising the issue.

lib/Frontend/InitPreprocessor.cpp

305

You're commenting on:

if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&
    TypeWidth <= InlineWidth)

?

Are you asking for a separate change, or for a change to my patch?

[jyknight]

lib/Frontend/InitPreprocessor.cpp

305

That issue in clang's purview in any case; if hexagon wants to lower a 1-byte cmpxchg to a compiler runtime function, it should do so in its backend.

[bcraig]

lib/Frontend/InitPreprocessor.cpp

305

I am asking for a change to this patch. Don't assume that all widths smaller than some value are inline-able and lock free, because that may not be the case. A 4 byte cmpxchg could be lock free, while a 1 byte cmpxchg may not be lock free.

[jfb]

lib/Frontend/InitPreprocessor.cpp

305

Are you asking me to change this line:

if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&
    TypeWidth <= InlineWidth)

?

In what way?

Please be more specific.

[jyknight]

A 4 byte cmpxchg could be lock free, while a 1 byte cmpxchg may not be

lock free.

That's not possible: if you have a 4-byte cmpxchg instruction, you can use
it to implement a 1-byte cmpxchg, too. Many targets do this already. (It
would be better if that was available generically so that code didn't need
to be written separately fit each target, but that's not the case at the
moment.)

[cfe-commits]

I know that MIPS does that, and an out-of-tree implementation of hexagon
implements 1-byte cmpxchg in terms of the 4-byte version. The emulation
code isn't particularly small, and it seems reasonable to make it a
libcall. The emulation code seems sketchy from a correctness
perspective, as you end up generating unsolicited loads and stores on
adjacent bytes. Take a look at the thread on cfe-dev and llvm-dev named
"the as-if rule / perf vs. security" for some of the ramifications and
concerns surrounding unsolicited loads and stores.

[bcraig]

lib/Frontend/InitPreprocessor.cpp

305

Yes, please change this line...

if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&

TypeWidth <= InlineWidth)

... to something more like ...
if(TI.hasBuiltinAtomic(TypeWidth, TypeAlign))

You will need to get the TargetInfo class into the method, and you should ensure that TypeWidth and TypeAlign are measured in terms of bits, because that is what TypeInfo::hasBuiltinAtomic is expecting.

Using TargetInfo::hasBuiltinAtomic will let Targets have explicit control over what is and is not always lock free. The default implementation also happens to be pretty reasonable.

[jfb]

In D17950#377386, @cfe-commits wrote:

I know that MIPS does that, and an out-of-tree implementation of hexagon
implements 1-byte cmpxchg in terms of the 4-byte version. The emulation
code isn't particularly small, and it seems reasonable to make it a
libcall. The emulation code seems sketchy from a correctness
perspective, as you end up generating unsolicited loads and stores on
adjacent bytes. Take a look at the thread on cfe-dev and llvm-dev named
"the as-if rule / perf vs. security" for some of the ramifications and
concerns surrounding unsolicited loads and stores.

C++ atomics are explicitly designed to avoid problems with touching adjacent bytes: if atomic<T> where sizeof(T) == 1 requires a 4-byte cmpxchg then it's up to the frontend to make sure sizeof<atomic<T>> >= 4 (or something equivalent such as making it non-lock-free).

This doesn't fall under "as-if".

Whether clang does this correctly for the targets you have in mind is another issue.

Whether LLVM's atomic instructions should assume C++ semantics in one way or another, i.e. whether they should assume the frontend generated code where padding can be overriden, is also a separate issue.

In all of these cases I suggest filing a separate issue. This patch is the wrong place to address the issues you raise. They're not invalid issues, they're simply not related to D17950.

lib/Frontend/InitPreprocessor.cpp

305

That's entirely unrelated to my change. My change is designed to *support* the use case you allude to even though right now LLVM doesn't have targets which exercise this usecase.

[bcraig]

C++ atomics are explicitly designed to avoid problems with touching adjacent bytes: if atomic<T> where sizeof(T) == 1 requires a 4-byte cmpxchg then it's up to the frontend to make sure sizeof<atomic<T>> >= 4 (or something equivalent such as making it non-lock-free).

I was aware of the C++11 wording on this, but for some reason, I was under the impression that the C11 wording didn't give the sizeof(T) latitude that C++11 did. A quick glance at the C spec tells me that I was under the wrong impression though. sizeof(_Atomic char) doesn't have to be the same as sizeof(char).

So assuming the front end does the right per-target thing, _Atomic char (and std::atomic<char>) on MIPS and Hexagon probably _should_ be 4 bytes, and the IR should only do a 4 byte (or larger) cmpxchg. All the loads and stores would be "solicited" loads and stores. The back-end shouldn't need to do any masking, because the extra bytes are basically just padding.

Long story short... continue as you were. Code looks fine. Ignore the crazy drive-by reviewer :)

lib/Frontend/InitPreprocessor.cpp

305

Since you aren't changing the logic here, I'm find dropping this issue from this review.

[jfb]

• Use __atomic_always_lock_free instead

[jfb]

In D17950#376965, @jfb wrote:

In D17950#376349, @jyknight wrote:

This conflicts with http://reviews.llvm.org/D17933. Most of this change also seems unnecessary.

• I think the is_always_lock_free function should be defined based on the existing __atomic_always_lock_free builtin, not on defines (just like is_lock_free uses __atomic_is_lock_free, or __c11_atomic_is_lock_free, which is effectively an alias).
• Then, the new __GCC_ATOMIC_DOUBLE_LOCK_FREE macros are unnecessary, unless we need to actually define a ATOMIC_DOUBLE_LOCK_FREE macro.
• __LLVM_ATOMIC_1_BYTES_LOCK_FREE effectively duplicates __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1, so aren't needed.

Hmm, when I originally wrote the paper I though I'd tried that. Can't remember why I went the other way, let me try out __atomic_always_lock_free. That would indeed be much simpler as it would be a pure libc++ change., thanks for raising the issue.

Changed to what you suggested. Much nicer. I don't remember why I thought it was a bad idea.

[jyknight]

Changed to what you suggested. Much nicer. I don't remember why I thought it was a bad idea.

Thanks, great! I don't have any opinion on what remains in this patch; someone else should review now.

[rsmith]

lib/Frontend/InitPreprocessor.cpp

480

This should be defined by the relevant library header, not by the compiler, to indicate the library actually provides the new symbol.

[jfb]

lib/Frontend/InitPreprocessor.cpp

480

Ah yes, makes sense. Looks like libc++ doesn't do this for other library features yet so I'll add it there.

This patch would then just fix test/Lexer/cxx-features.cpp for C++17 support and have nothing to do with is_always_lock_free. It's probably better if I close this patch and open a new one in that case.

[jfb]

lib/Frontend/InitPreprocessor.cpp

480

On the mailing list @rsmith said:

Feel free to commit that portion of the change.

Done in: http://reviews.llvm.org/rL264098

I'll abandon this change since it doesn't contain anything useful anymore (all in libc++ instead).

Thanks for the reviews!

lib/Frontend/InitPreprocessor.cpp

static void DefineFastIntType(unsigned TypeWidth, bool IsSigned,
 
   const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST";
   DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder);
   DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder);
 
   DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder);
 }
 
+/// Get values for:
+///  - ATOMIC_*_LOCK_FREE macros
+///  - constexpr is_always_lock_free
+struct LockFree {
+  enum Value { Never, Sometimes, Always };  // Values specified by C standard.
+
+  // Currently LLVM always bases lock-freeness on the size of the type, and not
+  // on type of address. Were this to change then constexpr is_always_lock_free
+  // couldn't base its value solely on sizeof(T).
+  static bool getIsSizeBased() { return true; }
 
-/// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with
-/// the specified properties.
-static const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign,
-                                    unsigned InlineWidth) {
-  // Fully-aligned, power-of-2 sizes no larger than the inline
-  // width will be inlined as lock-free operations.
+  static Value getValue(unsigned TypeWidth, unsigned TypeAlign,
+    // Fully-aligned, power-of-2 sizes no larger than the inline width will be
+    // inlined as lock-free operations.
     if (TypeWidth == TypeAlign && (TypeWidth & (TypeWidth - 1)) == 0 &&
         TypeWidth <= InlineWidth)
-    return "2"; // "always lock free"
-  // We cannot be certain what operations the lib calls might be
-  // able to implement as lock-free on future processors.
-  return "1"; // "sometimes lock free"
+      return Always;
+    // We cannot be certain what operations the lib calls might be able to
+    // implement as lock-free on future processors.
+    return Sometimes;
   }
 
+  static const char *getString(unsigned TypeWidth, unsigned TypeAlign,
+                               unsigned InlineWidth) {
+    static const char *str[] = {"0", "1", "2"};
+    return str[getValue(TypeWidth, TypeAlign, InlineWidth)];
+  }
+};
+
 /// \brief Add definitions required for a smooth interaction between
 /// Objective-C++ automated reference counting and libstdc++ (4.2).
 static void AddObjCXXARCLibstdcxxDefines(const LangOptions &LangOpts, 
                                          MacroBuilder &Builder) {
   Builder.defineMacro("_GLIBCXX_PREDEFINED_OBJC_ARC_IS_SCALAR");
   
   std::string Result;
   {
if (LangOpts.CPlusPlus14) {
     Builder.defineMacro("__cpp_digit_separators", "201309");
     Builder.defineMacro("__cpp_init_captures", "201304");
     Builder.defineMacro("__cpp_generic_lambdas", "201304");
     Builder.defineMacro("__cpp_decltype_auto", "201304");
     Builder.defineMacro("__cpp_return_type_deduction", "201304");
     Builder.defineMacro("__cpp_aggregate_nsdmi", "201304");
     Builder.defineMacro("__cpp_variable_templates", "201304");
   }
+
+  // C++17 features.
+  if (LangOpts.CPlusPlus1z) {
+    Builder.defineMacro("__cpp_lib_atomic_is_always_lock_free", "201603");
+  }
+
   if (LangOpts.SizedDeallocation)
     Builder.defineMacro("__cpp_sized_deallocation", "201309");
   if (LangOpts.ConceptsTS)
     Builder.defineMacro("__cpp_experimental_concepts", "1");
   if (LangOpts.Coroutines)
     Builder.defineMacro("__cpp_coroutines", "1");
 }
 
else
       Builder.defineMacro("__GNUC_STDC_INLINE__");
 
     // The value written by __atomic_test_and_set.
     // FIXME: This is target-dependent.
     Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
 
     // Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE.
     unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth();
-#define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \
-    Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \
-                        getLockFreeValue(TI.get##Type##Width(), \
-                                         TI.get##Type##Align(), \
+#define DEFINE_LOCK_FREE_MACRO(TYPE, Type)                                     \
+  Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE",                      \
+                      LockFree::getString(TI.get##Type##Width(),               \
+                                          TI.get##Type##Align(),               \
                                           InlineWidthBits));
     DEFINE_LOCK_FREE_MACRO(BOOL, Bool);
     DEFINE_LOCK_FREE_MACRO(CHAR, Char);
     DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16);
     DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32);
     DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar);
     DEFINE_LOCK_FREE_MACRO(SHORT, Short);
     DEFINE_LOCK_FREE_MACRO(INT, Int);
     DEFINE_LOCK_FREE_MACRO(LONG, Long);
     DEFINE_LOCK_FREE_MACRO(LLONG, LongLong);
+    DEFINE_LOCK_FREE_MACRO(FLOAT, Float);
+    DEFINE_LOCK_FREE_MACRO(DOUBLE, Double);
+    DEFINE_LOCK_FREE_MACRO(LDOUBLE, LongDouble);
     Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE",
-                        getLockFreeValue(TI.getPointerWidth(0),
+                        LockFree::getString(TI.getPointerWidth(0),
                                             TI.getPointerAlign(0),
                                             InlineWidthBits));
 #undef DEFINE_LOCK_FREE_MACRO
+
+    // Used by libc++ to implement constexpr is_always_lock_free.
+    Builder.defineMacro("__LLVM_LOCK_FREE_IS_SIZE_BASED",
+                        LockFree::getIsSizeBased() ? "1" : "0");
+#define DEFINE_LOCK_FREE_MACRO(BYTES)                                          \
+  Builder.defineMacro(                                                         \
+      "__LLVM_ATOMIC_" #BYTES "_BYTES_LOCK_FREE",                              \
+      LockFree::getString(BYTES * 8, BYTES * 8, InlineWidthBits));
+    if (LockFree::getIsSizeBased()) {
+      DEFINE_LOCK_FREE_MACRO(1);
+      DEFINE_LOCK_FREE_MACRO(2);
+      DEFINE_LOCK_FREE_MACRO(4);
+      DEFINE_LOCK_FREE_MACRO(8);
+      DEFINE_LOCK_FREE_MACRO(16);
+      // constexpr is_always_lock_free is optimistic, it's therefore acceptable
+      // to state "0" even if the implementation is actually always
+      // lock-free. If architectures support wider lock-free operations then
+      // more macro definitions can be appended.
+    }
+#undef DEFINE_LOCK_FREE_MACRO
   }
 
   if (LangOpts.NoInlineDefine)
     Builder.defineMacro("__NO_INLINE__");
 
   if (unsigned PICLevel = LangOpts.PICLevel) {
     Builder.defineMacro("__PIC__", Twine(PICLevel));
     Builder.defineMacro("__pic__", Twine(PICLevel));

test/Lexer/cxx-features.cpp

 // RUN: %clang_cc1 -std=c++98 -verify %s
 // RUN: %clang_cc1 -std=c++11 -verify %s
 // RUN: %clang_cc1 -std=c++1y -fsized-deallocation -verify %s
-// RUN: %clang_cc1 -std=c++1y -fsized-deallocation -fconcepts-ts -DCONCEPTS_TS=1 -verify %s
+// RUN: %clang_cc1 -std=c++14 -fsized-deallocation -verify %s
+// RUN: %clang_cc1 -std=c++1z -fsized-deallocation -verify %s
+// RUN: %clang_cc1 -std=c++1z -fsized-deallocation -fconcepts-ts -DCONCEPTS_TS=1 -verify %s
 // RUN: %clang_cc1 -fcoroutines -DCOROUTINES -verify %s
 
 // expected-no-diagnostics
 
 // FIXME using `defined` in a macro has undefined behavior.
 #if __cplusplus < 201103L
-#define check(macro, cxx98, cxx11, cxx1y) cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98
-#elif __cplusplus < 201304L
-#define check(macro, cxx98, cxx11, cxx1y) cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11
+#define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98
+#elif __cplusplus < 201402L
+#define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11
+#elif __cplusplus < 201406L
+#define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx14 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx14
 #else
-#define check(macro, cxx98, cxx11, cxx1y) cxx1y == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx1y
+#define check(macro, cxx98, cxx11, cxx14, cxx1z) cxx1z == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx1z
 #endif
 
-#if check(binary_literals, 0, 0, 201304)
+#if check(binary_literals, 0, 0, 201304, 201304)
 #error "wrong value for __cpp_binary_literals"
 #endif
 
-#if check(digit_separators, 0, 0, 201309)
+#if check(digit_separators, 0, 0, 201309, 201309)
 #error "wrong value for __cpp_digit_separators"
 #endif
 
-#if check(init_captures, 0, 0, 201304)
+#if check(init_captures, 0, 0, 201304, 201304)
 #error "wrong value for __cpp_init_captures"
 #endif
 
-#if check(generic_lambdas, 0, 0, 201304)
+#if check(generic_lambdas, 0, 0, 201304, 201304)
 #error "wrong value for __cpp_generic_lambdas"
 #endif
 
-#if check(sized_deallocation, 0, 0, 201309)
+#if check(sized_deallocation, 0, 0, 201309, 201309)
 #error "wrong value for __cpp_sized_deallocation"
 #endif
 
-#if check(constexpr, 0, 200704, 201304)
+#if check(constexpr, 0, 200704, 201304, 201304)
 #error "wrong value for __cpp_constexpr"
 #endif
 
-#if check(decltype_auto, 0, 0, 201304)
+#if check(decltype_auto, 0, 0, 201304, 201304)
 #error "wrong value for __cpp_decltype_auto"
 #endif
 
-#if check(return_type_deduction, 0, 0, 201304)
+#if check(return_type_deduction, 0, 0, 201304, 201304)
 #error "wrong value for __cpp_return_type_deduction"
 #endif
 
-#if check(runtime_arrays, 0, 0, 0)
+#if check(runtime_arrays, 0, 0, 0, 0)
 #error "wrong value for __cpp_runtime_arrays"
 #endif
 
-#if check(aggregate_nsdmi, 0, 0, 201304)
+#if check(aggregate_nsdmi, 0, 0, 201304, 201304)
 #error "wrong value for __cpp_aggregate_nsdmi"
 #endif
 
-#if check(variable_templates, 0, 0, 201304)
+#if check(variable_templates, 0, 0, 201304, 201304)
 #error "wrong value for __cpp_variable_templates"
 #endif
 
-#if check(unicode_characters, 0, 200704, 200704)
+#if check(unicode_characters, 0, 200704, 200704, 200704)
 #error "wrong value for __cpp_unicode_characters"
 #endif
 
-#if check(raw_strings, 0, 200710, 200710)
+#if check(raw_strings, 0, 200710, 200710, 200710)
 #error "wrong value for __cpp_raw_strings"
 #endif
 
-#if check(unicode_literals, 0, 200710, 200710)
+#if check(unicode_literals, 0, 200710, 200710, 200710)
 #error "wrong value for __cpp_unicode_literals"
 #endif
 
-#if check(user_defined_literals, 0, 200809, 200809)
+#if check(user_defined_literals, 0, 200809, 200809, 200809)
 #error "wrong value for __cpp_user_defined_literals"
 #endif
 
-#if check(lambdas, 0, 200907, 200907)
+#if check(lambdas, 0, 200907, 200907, 200907)
 #error "wrong value for __cpp_lambdas"
 #endif
 
-#if check(range_based_for, 0, 200907, 200907)
+#if check(range_based_for, 0, 200907, 200907, 200907)
 #error "wrong value for __cpp_range_based_for"
 #endif
 
-#if check(static_assert, 0, 200410, 200410)
+#if check(static_assert, 0, 200410, 200410, 200410)
 #error "wrong value for __cpp_static_assert"
 #endif
 
-#if check(decltype, 0, 200707, 200707)
+#if check(decltype, 0, 200707, 200707, 200707)
 #error "wrong value for __cpp_decltype"
 #endif
 
-#if check(attributes, 0, 200809, 200809)
+#if check(attributes, 0, 200809, 200809, 200809)
 #error "wrong value for __cpp_attributes"
 #endif
 
-#if check(rvalue_references, 0, 200610, 200610)
+#if check(rvalue_references, 0, 200610, 200610, 200610)
 #error "wrong value for __cpp_rvalue_references"
 #endif
 
-#if check(variadic_templates, 0, 200704, 200704)
+#if check(variadic_templates, 0, 200704, 200704, 200704)
 #error "wrong value for __cpp_variadic_templates"
 #endif
 
-#if check(initializer_lists, 0, 200806, 200806)
+#if check(initializer_lists, 0, 200806, 200806, 200806)
 #error "wrong value for __cpp_initializer_lists"
 #endif
 
-#if check(delegating_constructors, 0, 200604, 200604)
+#if check(delegating_constructors, 0, 200604, 200604, 200604)
 #error "wrong value for __cpp_delegating_constructors"
 #endif
 
-#if check(nsdmi, 0, 200809, 200809)
+#if check(nsdmi, 0, 200809, 200809, 200809)
 #error "wrong value for __cpp_nsdmi"
 #endif
 
-#if check(inheriting_constructors, 0, 200802, 200802)
+#if check(inheriting_constructors, 0, 200802, 200802, 200802)
 #error "wrong value for __cpp_inheriting_constructors"
 #endif
 
-#if check(ref_qualifiers, 0, 200710, 200710)
+#if check(ref_qualifiers, 0, 200710, 200710, 200710)
 #error "wrong value for __cpp_ref_qualifiers"
 #endif
 
-#if check(alias_templates, 0, 200704, 200704)
+#if check(alias_templates, 0, 200704, 200704, 200704)
 #error "wrong value for __cpp_alias_templates"
 #endif
 
-#if check(experimental_concepts, 0, 0, CONCEPTS_TS)
+#if check(lib_atomic_is_always_lock_free, 0, 0, 0, 201603)
+#error "wrong value for __cpp_lib_atomic_is_always_lock_free"
+#endif
+
+#if check(experimental_concepts, 0, 0, CONCEPTS_TS, CONCEPTS_TS)
 #error "wrong value for __cpp_experimental_concepts"
 #endif
 
 #if (COROUTINES && !__cpp_coroutines) || (!COROUTINES && __cpp_coroutines)
 #error "wrong value for __cpp_coroutines"
 #endif

test/Preprocessor/init.c

 // MIPSN32BE: #define __FLT_MIN_10_EXP__ (-37)
 // MIPSN32BE: #define __FLT_MIN_EXP__ (-125)
 // MIPSN32BE: #define __FLT_MIN__ 1.17549435e-38F
 // MIPSN32BE: #define __FLT_RADIX__ 2
 // MIPSN32BE: #define __GCC_ATOMIC_BOOL_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_CHAR_LOCK_FREE 2
+// MIPSN32BE: #define __GCC_ATOMIC_DOUBLE_LOCK_FREE 2
+// MIPSN32BE: #define __GCC_ATOMIC_FLOAT_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_INT_LOCK_FREE 2
+// MIPSN32BE: #define __GCC_ATOMIC_LDOUBLE_LOCK_FREE 1
 // MIPSN32BE: #define __GCC_ATOMIC_LLONG_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_LONG_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_POINTER_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_SHORT_LOCK_FREE 2
 // MIPSN32BE: #define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
 // MIPSN32BE: #define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
 // MIPSN32BE: #define __GNUC_MINOR__ 2
 // MIPSN32BE: #define __GNUC_PATCHLEVEL__ 1

 // MIPSN32BE: #define __LDBL_HAS_QUIET_NAN__ 1
 // MIPSN32BE: #define __LDBL_MANT_DIG__ 113
 // MIPSN32BE: #define __LDBL_MAX_10_EXP__ 4932
 // MIPSN32BE: #define __LDBL_MAX_EXP__ 16384
 // MIPSN32BE: #define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L
 // MIPSN32BE: #define __LDBL_MIN_10_EXP__ (-4931)
 // MIPSN32BE: #define __LDBL_MIN_EXP__ (-16381)
 // MIPSN32BE: #define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
+// MIPSN32BE: #define __LLVM_ATOMIC_16_BYTES_LOCK_FREE 1
+// MIPSN32BE: #define __LLVM_ATOMIC_1_BYTES_LOCK_FREE 2
+// MIPSN32BE: #define __LLVM_ATOMIC_2_BYTES_LOCK_FREE 2
+// MIPSN32BE: #define __LLVM_ATOMIC_4_BYTES_LOCK_FREE 2
+// MIPSN32BE: #define __LLVM_ATOMIC_8_BYTES_LOCK_FREE 2
+// MIPSN32BE: #define __LLVM_LOCK_FREE_IS_SIZE_BASED 1
 // MIPSN32BE: #define __LONG_LONG_MAX__ 9223372036854775807LL
 // MIPSN32BE: #define __LONG_MAX__ 2147483647L
 // MIPSN32BE: #define __MIPSEB 1
 // MIPSN32BE: #define __MIPSEB__ 1
 // MIPSN32BE: #define __NO_INLINE__ 1
 // MIPSN32BE: #define __ORDER_BIG_ENDIAN__ 4321
 // MIPSN32BE: #define __ORDER_LITTLE_ENDIAN__ 1234
 // MIPSN32BE: #define __ORDER_PDP_ENDIAN__ 3412

 // MIPSN32EL: #define __FLT_MIN_10_EXP__ (-37)
 // MIPSN32EL: #define __FLT_MIN_EXP__ (-125)
 // MIPSN32EL: #define __FLT_MIN__ 1.17549435e-38F
 // MIPSN32EL: #define __FLT_RADIX__ 2
 // MIPSN32EL: #define __GCC_ATOMIC_BOOL_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_CHAR_LOCK_FREE 2
+// MIPSN32EL: #define __GCC_ATOMIC_DOUBLE_LOCK_FREE 2
+// MIPSN32EL: #define __GCC_ATOMIC_FLOAT_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_INT_LOCK_FREE 2
+// MIPSN32EL: #define __GCC_ATOMIC_LDOUBLE_LOCK_FREE 1
 // MIPSN32EL: #define __GCC_ATOMIC_LLONG_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_LONG_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_POINTER_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_SHORT_LOCK_FREE 2
 // MIPSN32EL: #define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
 // MIPSN32EL: #define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
 // MIPSN32EL: #define __GNUC_MINOR__ 2
 // MIPSN32EL: #define __GNUC_PATCHLEVEL__ 1

 // MIPSN32EL: #define __LDBL_MANT_DIG__ 113
 // MIPSN32EL: #define __LDBL_MAX_10_EXP__ 4932
 // MIPSN32EL: #define __LDBL_MAX_EXP__ 16384
 // MIPSN32EL: #define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L
 // MIPSN32EL: #define __LDBL_MIN_10_EXP__ (-4931)
 // MIPSN32EL: #define __LDBL_MIN_EXP__ (-16381)
 // MIPSN32EL: #define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
 // MIPSN32EL: #define __LITTLE_ENDIAN__ 1
+// MIPSN32EL: #define __LLVM_ATOMIC_16_BYTES_LOCK_FREE 1
+// MIPSN32EL: #define __LLVM_ATOMIC_1_BYTES_LOCK_FREE 2
+// MIPSN32EL: #define __LLVM_ATOMIC_2_BYTES_LOCK_FREE 2
+// MIPSN32EL: #define __LLVM_ATOMIC_4_BYTES_LOCK_FREE 2
+// MIPSN32EL: #define __LLVM_ATOMIC_8_BYTES_LOCK_FREE 2
+// MIPSN32EL: #define __LLVM_LOCK_FREE_IS_SIZE_BASED 1
 // MIPSN32EL: #define __LONG_LONG_MAX__ 9223372036854775807LL
 // MIPSN32EL: #define __LONG_MAX__ 2147483647L
 // MIPSN32EL: #define __MIPSEL 1
 // MIPSN32EL: #define __MIPSEL__ 1
 // MIPSN32EL: #define __NO_INLINE__ 1
 // MIPSN32EL: #define __ORDER_BIG_ENDIAN__ 4321
 // MIPSN32EL: #define __ORDER_LITTLE_ENDIAN__ 1234
 // MIPSN32EL: #define __ORDER_PDP_ENDIAN__ 3412

 // X86_64-CLOUDABI:#define __FLT_MIN_10_EXP__ (-37)
 // X86_64-CLOUDABI:#define __FLT_MIN_EXP__ (-125)
 // X86_64-CLOUDABI:#define __FLT_MIN__ 1.17549435e-38F
 // X86_64-CLOUDABI:#define __FLT_RADIX__ 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __GCC_ATOMIC_DOUBLE_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __GCC_ATOMIC_FLOAT_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_INT_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __GCC_ATOMIC_LDOUBLE_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_LLONG_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_LONG_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
 // X86_64-CLOUDABI:#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
 // X86_64-CLOUDABI:#define __GNUC_MINOR__ 2
 // X86_64-CLOUDABI:#define __GNUC_PATCHLEVEL__ 1

 // X86_64-CLOUDABI:#define __LDBL_MANT_DIG__ 64
 // X86_64-CLOUDABI:#define __LDBL_MAX_10_EXP__ 4932
 // X86_64-CLOUDABI:#define __LDBL_MAX_EXP__ 16384
 // X86_64-CLOUDABI:#define __LDBL_MAX__ 1.18973149535723176502e+4932L
 // X86_64-CLOUDABI:#define __LDBL_MIN_10_EXP__ (-4931)
 // X86_64-CLOUDABI:#define __LDBL_MIN_EXP__ (-16381)
 // X86_64-CLOUDABI:#define __LDBL_MIN__ 3.36210314311209350626e-4932L
 // X86_64-CLOUDABI:#define __LITTLE_ENDIAN__ 1
+// X86_64-CLOUDABI:#define __LLVM_ATOMIC_16_BYTES_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __LLVM_ATOMIC_1_BYTES_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __LLVM_ATOMIC_2_BYTES_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __LLVM_ATOMIC_4_BYTES_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __LLVM_ATOMIC_8_BYTES_LOCK_FREE 2
+// X86_64-CLOUDABI:#define __LLVM_LOCK_FREE_IS_SIZE_BASED 1
 // X86_64-CLOUDABI:#define __LONG_LONG_MAX__ 9223372036854775807LL
 // X86_64-CLOUDABI:#define __LONG_MAX__ 9223372036854775807L
 // X86_64-CLOUDABI:#define __LP64__ 1
 // X86_64-CLOUDABI:#define __MMX__ 1
 // X86_64-CLOUDABI:#define __NO_INLINE__ 1
 // X86_64-CLOUDABI:#define __NO_MATH_INLINES 1
 // X86_64-CLOUDABI:#define __ORDER_BIG_ENDIAN__ 4321
 // X86_64-CLOUDABI:#define __ORDER_LITTLE_ENDIAN__ 1234

 // WEBASSEMBLY32-NEXT:#define __FLT_MIN_10_EXP__ (-37)
 // WEBASSEMBLY32-NEXT:#define __FLT_MIN_EXP__ (-125)
 // WEBASSEMBLY32-NEXT:#define __FLT_MIN__ 1.17549435e-38F
 // WEBASSEMBLY32-NEXT:#define __FLT_RADIX__ 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_DOUBLE_LOCK_FREE 1
+// WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_FLOAT_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_INT_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_LDOUBLE_LOCK_FREE 1
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_LLONG_LOCK_FREE 1
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_LONG_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
 // WEBASSEMBLY32-NEXT:#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __GNUC_MINOR__ {{.*}}
 // WEBASSEMBLY32-NEXT:#define __GNUC_PATCHLEVEL__ {{.*}}

 // WEBASSEMBLY32-NEXT:#define __LDBL_MANT_DIG__ 113
 // WEBASSEMBLY32-NEXT:#define __LDBL_MAX_10_EXP__ 4932
 // WEBASSEMBLY32-NEXT:#define __LDBL_MAX_EXP__ 16384
 // WEBASSEMBLY32-NEXT:#define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L
 // WEBASSEMBLY32-NEXT:#define __LDBL_MIN_10_EXP__ (-4931)
 // WEBASSEMBLY32-NEXT:#define __LDBL_MIN_EXP__ (-16381)
 // WEBASSEMBLY32-NEXT:#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
 // WEBASSEMBLY32-NEXT:#define __LITTLE_ENDIAN__ 1
+// WEBASSEMBLY32-NEXT:#define __LLVM_ATOMIC_16_BYTES_LOCK_FREE 1
+// WEBASSEMBLY32-NEXT:#define __LLVM_ATOMIC_1_BYTES_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __LLVM_ATOMIC_2_BYTES_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __LLVM_ATOMIC_4_BYTES_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __LLVM_ATOMIC_8_BYTES_LOCK_FREE 1
+// WEBASSEMBLY32-NEXT:#define __LLVM_LOCK_FREE_IS_SIZE_BASED 1
 // WEBASSEMBLY32-NEXT:#define __LONG_LONG_MAX__ 9223372036854775807LL
 // WEBASSEMBLY32-NEXT:#define __LONG_MAX__ 2147483647L
 // WEBASSEMBLY32-NOT:#define __LP64__
 // WEBASSEMBLY32-NEXT:#define __NO_INLINE__ 1
 // WEBASSEMBLY32-NEXT:#define __ORDER_BIG_ENDIAN__ 4321
 // WEBASSEMBLY32-NEXT:#define __ORDER_LITTLE_ENDIAN__ 1234
 // WEBASSEMBLY32-NEXT:#define __ORDER_PDP_ENDIAN__ 3412
 // WEBASSEMBLY32-NEXT:#define __POINTER_WIDTH__ 32

 // WEBASSEMBLY64-NEXT:#define __FLT_MIN_10_EXP__ (-37)
 // WEBASSEMBLY64-NEXT:#define __FLT_MIN_EXP__ (-125)
 // WEBASSEMBLY64-NEXT:#define __FLT_MIN__ 1.17549435e-38F
 // WEBASSEMBLY64-NEXT:#define __FLT_RADIX__ 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_DOUBLE_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_FLOAT_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_INT_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_LDOUBLE_LOCK_FREE 1
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_LLONG_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_LONG_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
 // WEBASSEMBLY64-NEXT:#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __GNUC_MINOR__ {{.*}}
 // WEBASSEMBLY64-NEXT:#define __GNUC_PATCHLEVEL__ {{.*}}

 // WEBASSEMBLY64-NEXT:#define __LDBL_MANT_DIG__ 113
 // WEBASSEMBLY64-NEXT:#define __LDBL_MAX_10_EXP__ 4932
 // WEBASSEMBLY64-NEXT:#define __LDBL_MAX_EXP__ 16384
 // WEBASSEMBLY64-NEXT:#define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L
 // WEBASSEMBLY64-NEXT:#define __LDBL_MIN_10_EXP__ (-4931)
 // WEBASSEMBLY64-NEXT:#define __LDBL_MIN_EXP__ (-16381)
 // WEBASSEMBLY64-NEXT:#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
 // WEBASSEMBLY64-NEXT:#define __LITTLE_ENDIAN__ 1
+// WEBASSEMBLY64-NEXT:#define __LLVM_ATOMIC_16_BYTES_LOCK_FREE 1
+// WEBASSEMBLY64-NEXT:#define __LLVM_ATOMIC_1_BYTES_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __LLVM_ATOMIC_2_BYTES_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __LLVM_ATOMIC_4_BYTES_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __LLVM_ATOMIC_8_BYTES_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __LLVM_LOCK_FREE_IS_SIZE_BASED 1
 // WEBASSEMBLY64-NEXT:#define __LONG_LONG_MAX__ 9223372036854775807LL
 // WEBASSEMBLY64-NEXT:#define __LONG_MAX__ 9223372036854775807L
 // WEBASSEMBLY64-NEXT:#define __LP64__ 1
 // WEBASSEMBLY64-NEXT:#define __NO_INLINE__ 1
 // WEBASSEMBLY64-NEXT:#define __ORDER_BIG_ENDIAN__ 4321
 // WEBASSEMBLY64-NEXT:#define __ORDER_LITTLE_ENDIAN__ 1234
 // WEBASSEMBLY64-NEXT:#define __ORDER_PDP_ENDIAN__ 3412
 // WEBASSEMBLY64-NEXT:#define __POINTER_WIDTH__ 64

 // WEBASSEMBLY64-NEXT:#define __wasm64__ 1
 // WEBASSEMBLY64-NEXT:#define __wasm__ 1
 
 // RUN: %clang_cc1 -E -dM -ffreestanding -triple i686-windows-cygnus < /dev/null | FileCheck -match-full-lines -check-prefix CYGWIN-X32 %s
 // CYGWIN-X32: #define __USER_LABEL_PREFIX__ _
 
 // RUN: %clang_cc1 -E -dM -ffreestanding -triple x86_64-windows-cygnus < /dev/null | FileCheck -match-full-lines -check-prefix CYGWIN-X64 %s
 // CYGWIN-X64: #define __USER_LABEL_PREFIX__
-