Add __CLANG_ATOMIC_<TYPE>_LOCK_FREE macros for use in MSVC compatibility mode.

[EricWF]

Summary

Libc++ currently implements the ATOMIC_<TYPE>_LOCK_FREE macros using the __GCC_ATOMIC_<TYPE>_LOCK_FREE macros. However these are not available when MSVC compatibility is enabled even though C11 _Atomic is. This prevents libc++ from correctly implementing ATOMIC_<TYPE>_LOCK_FREE.

This patch adds an alternative spelling __CLANG_ATOMIC_<TYPE>_LOCK_FREE that is enabled with -fms-compatibility.

[smeenai]

This looks good to me, but I'm not familiar enough with this part of clang to be comfortable accepting.

[jfb]

Is it a goal to support Microsoft's STL with this? If so, how does MSVC's STL implement is_always_lock_free at the moment? CL 19 2017 RTW doesn't seem to have anything? Presumably they'll have to do *something*.

[EricWF]

In D32265#731709, @jfb wrote:

Is it a goal to support Microsoft's STL with this? If so, how does MSVC's STL implement is_always_lock_free at the moment? CL 19 2017 RTW doesn't seem to have anything? Presumably they'll have to do *something*.

The goal is to allow libc++ to implement`ATOMIC_<TYPE>_LOCK_FREE` on Windows using Clang. As you know libc++ currently uses the __GCC_ATOMIC_FOO macros, but those aren't available on Windows.

Also AFAIK MSVC leaves the implementation of atomics up to the library, not the frontend. So W/E MSVC's STL does it's likely not sane or desirable.

[jfb]

In D32265#731710, @EricWF wrote:

In D32265#731709, @jfb wrote:

Is it a goal to support Microsoft's STL with this? If so, how does MSVC's STL implement is_always_lock_free at the moment? CL 19 2017 RTW doesn't seem to have anything? Presumably they'll have to do *something*.

The goal is to allow libc++ to implement`ATOMIC_<TYPE>_LOCK_FREE` on Windows using Clang. As you know libc++ currently uses the __GCC_ATOMIC_FOO macros, but those aren't available on Windows.

OK so it's just a hygiene question of blanket-avoiding __GCC_* macros in clang-ms mode, but using __CLANG_* macros are OK? That sounds fine then. Would you all-out switch libc++ to use __CLANG_* then?

Also AFAIK MSVC leaves the implementation of atomics up to the library, not the frontend. So W/E MSVC's STL does it's likely not sane or desirable.

Wait what? How does that even work? This calls for a Twitter ping of Billy!

[jfb]

It looks like Billy is going to do something somewhat similar when he rewrites it: https://twitter.com/jfbastien/status/855168230918307840
For now it's kinda #define IS_LOCK_FREE ¯\_(ツ)_/¯

[EricWF]

In D32265#732649, @jfb wrote:

In D32265#731710, @EricWF wrote:

In D32265#731709, @jfb wrote:

Is it a goal to support Microsoft's STL with this? If so, how does MSVC's STL implement is_always_lock_free at the moment? CL 19 2017 RTW doesn't seem to have anything? Presumably they'll have to do *something*.

The goal is to allow libc++ to implement`ATOMIC_<TYPE>_LOCK_FREE` on Windows using Clang. As you know libc++ currently uses the __GCC_ATOMIC_FOO macros, but those aren't available on Windows.

OK so it's just a hygiene question of blanket-avoiding __GCC_* macros in clang-ms mode, but using __CLANG_* macros are OK? That sounds fine then. Would you all-out switch libc++ to use __CLANG_* then?

__CLANG macros are fine on libc++'s end; So as long as they're not uncouth for Clang it should be OK.

I would switch libc++ to do

#ifdef __CLANG_ATOMIC_FOO
# define ATOMIC_FOO __CLANG_ATOMIC_FOO
# define ATOMIC_BAR __CLANG_ATOMIC_BAR
#else
# define ATOMIC_FOO __GCC_ATOMIC_FOO
...
#endif

Also AFAIK MSVC leaves the implementation of atomics up to the library, not the frontend. So W/E MSVC's STL does it's likely not sane or desirable.

Wait what? How does that even work? This calls for a Twitter ping of Billy!

[BillyONeal]

In D32265#732657, @jfb wrote:

It looks like Billy is going to do something somewhat similar when he rewrites it: https://twitter.com/jfbastien/status/855168230918307840
For now it's kinda #define IS_LOCK_FREE ¯\_(ツ)_/¯

Note that my rewrite of our <atomic> didn't touch the XXX_IS_LOCK_FREE macros. All of those for both implementations are hardcoded to 2 since any piece of hardware we ever plan to support has lock free ops for all those. I did add conditional DCAS support for amd64 though in v.Next.

Billy3

[BillyONeal]

(sorry for double post)

And of course since you folks don't care about supporting pre-Vista you probably also don't care about supporting Opterons from 2005, in which case you'd want unconditional cmpxchg16b on amd64 :). In our next major version I added a configuration macro _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B users can set to ask for that.

[BillyONeal]

In D32265#731709, @jfb wrote:

Is it a goal to support Microsoft's STL with this? If so, how does MSVC's STL implement is_always_lock_free at the moment? CL 19 2017 RTW doesn't seem to have anything? Presumably they'll have to do *something*.

Our STL implements <atomic> entirely as a library feature (on top of the _InterlockedXxx intrinsics and alignas).

[rsmith]

I'm not thrilled about adding yet more predefined macros, but it really doesn't make sense for libc++ to depend on __GCC_* macros when targeting Windows, nor for these to be Windows-only, so let's do it.

lib/Frontend/InitPreprocessor.cpp

910–912

I'd sink the _ into the prefix too, but this looks fine either way.

[EricWF]

• Address inline comments.

lib/Frontend/InitPreprocessor.cpp

if (!LangOpts.MSVCCompat) {
     if (LangOpts.GNUInline || LangOpts.CPlusPlus)
       Builder.defineMacro("__GNUC_GNU_INLINE__");
     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");
+  }
 
+  auto addLockFreeMacros = [&](const llvm::Twine &Prefix) {
     // Used by libc++ and 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(), \
-                                         InlineWidthBits));
+#define DEFINE_LOCK_FREE_MACRO(TYPE, Type)                                     \
+  Builder.defineMacro(Prefix + #TYPE "_LOCK_FREE",                             \
+                      getLockFreeValue(TI.get##Type##Width(),                  \
+                                       TI.get##Type##Align(),                  \
     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);
-    Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE",
+    Builder.defineMacro(Prefix + "POINTER_LOCK_FREE",
                         getLockFreeValue(TI.getPointerWidth(0),
                                          TI.getPointerAlign(0),
                                          InlineWidthBits));
 #undef DEFINE_LOCK_FREE_MACRO
-  }
+  };
+  addLockFreeMacros("__CLANG_ATOMIC_");
+  if (!LangOpts.MSVCCompat)
+    addLockFreeMacros("__GCC_ATOMIC_");
 
   if (LangOpts.NoInlineDefine)
     Builder.defineMacro("__NO_INLINE__");
 
   if (unsigned PICLevel = LangOpts.PICLevel) {
     Builder.defineMacro("__PIC__", Twine(PICLevel));
     Builder.defineMacro("__pic__", Twine(PICLevel));
     if (LangOpts.PIE) {

test/Preprocessor/init.c

 // WEBASSEMBLY32-NEXT:#define __ATOMIC_RELEASE 3
 // WEBASSEMBLY32-NEXT:#define __ATOMIC_SEQ_CST 5
 // WEBASSEMBLY32-NEXT:#define __BIGGEST_ALIGNMENT__ 16
 // WEBASSEMBLY32-NEXT:#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 // WEBASSEMBLY32-NEXT:#define __CHAR16_TYPE__ unsigned short
 // WEBASSEMBLY32-NEXT:#define __CHAR32_TYPE__ unsigned int
 // WEBASSEMBLY32-NEXT:#define __CHAR_BIT__ 8
 // WEBASSEMBLY32-NOT:#define __CHAR_UNSIGNED__
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_BOOL_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_CHAR_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_INT_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_LLONG_LOCK_FREE 1
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_LONG_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_POINTER_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_SHORT_LOCK_FREE 2
+// WEBASSEMBLY32-NEXT:#define __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 2
 // WEBASSEMBLY32-NEXT:#define __CONSTANT_CFSTRINGS__ 1
 // WEBASSEMBLY32-NEXT:#define __DBL_DECIMAL_DIG__ 17
 // WEBASSEMBLY32-NEXT:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
 // WEBASSEMBLY32-NEXT:#define __DBL_DIG__ 15
 // WEBASSEMBLY32-NEXT:#define __DBL_EPSILON__ 2.2204460492503131e-16
 // WEBASSEMBLY32-NEXT:#define __DBL_HAS_DENORM__ 1
 // WEBASSEMBLY32-NEXT:#define __DBL_HAS_INFINITY__ 1
 // WEBASSEMBLY32-NEXT:#define __DBL_HAS_QUIET_NAN__ 1

 // WEBASSEMBLY64-NEXT:#define __ATOMIC_RELEASE 3
 // WEBASSEMBLY64-NEXT:#define __ATOMIC_SEQ_CST 5
 // WEBASSEMBLY64-NEXT:#define __BIGGEST_ALIGNMENT__ 16
 // WEBASSEMBLY64-NEXT:#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 // WEBASSEMBLY64-NEXT:#define __CHAR16_TYPE__ unsigned short
 // WEBASSEMBLY64-NEXT:#define __CHAR32_TYPE__ unsigned int
 // WEBASSEMBLY64-NEXT:#define __CHAR_BIT__ 8
 // WEBASSEMBLY64-NOT:#define __CHAR_UNSIGNED__
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_BOOL_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_CHAR_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_INT_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_LLONG_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_LONG_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_POINTER_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_SHORT_LOCK_FREE 2
+// WEBASSEMBLY64-NEXT:#define __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 2
 // WEBASSEMBLY64-NEXT:#define __CONSTANT_CFSTRINGS__ 1
 // WEBASSEMBLY64-NEXT:#define __DBL_DECIMAL_DIG__ 17
 // WEBASSEMBLY64-NEXT:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
 // WEBASSEMBLY64-NEXT:#define __DBL_DIG__ 15
 // WEBASSEMBLY64-NEXT:#define __DBL_EPSILON__ 2.2204460492503131e-16
 // WEBASSEMBLY64-NEXT:#define __DBL_HAS_DENORM__ 1
 // WEBASSEMBLY64-NEXT:#define __DBL_HAS_INFINITY__ 1
 // WEBASSEMBLY64-NEXT:#define __DBL_HAS_QUIET_NAN__ 1

 // AVR:#define __UINT_LEAST64_MAX__ 18446744073709551615ULL
 // AVR:#define __UINT_LEAST64_TYPE__ long long unsigned int
 // AVR:#define __UINT_LEAST8_MAX__ 255
 // AVR:#define __UINT_LEAST8_TYPE__ unsigned char
 // AVR:#define __USER_LABEL_PREFIX__ 
 // AVR:#define __WCHAR_MAX__ 32767
 // AVR:#define __WCHAR_TYPE__ int
 // AVR:#define __WINT_TYPE__ int
+
+
+// RUN: %clang_cc1 -E -dM -ffreestanding \
+// RUN:    -triple i686-windows-msvc -fms-compatibility < /dev/null \
+// RUN:  | FileCheck -match-full-lines -check-prefix MSVC-X32 %s
+
+// RUN: %clang_cc1 -E -dM -ffreestanding \
+// RUN:    -triple x86_64-windows-msvc -fms-compatibility < /dev/null \
+// RUN:  | FileCheck -match-full-lines -check-prefix MSVC-X64 %s
+
+// MSVC-X32:#define __CLANG_ATOMIC_BOOL_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_CHAR_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_INT_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_LLONG_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_LONG_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_POINTER_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_SHORT_LOCK_FREE 2
+// MSVC-X32-NEXT:#define __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 2
+// MSVC-X32-NOT:#define __GCC_ATOMIC{{.*}}
+
+// MSVC-X64:#define __CLANG_ATOMIC_BOOL_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_CHAR_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_INT_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_LLONG_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_LONG_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_POINTER_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_SHORT_LOCK_FREE 2
+// MSVC-X64-NEXT:#define __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 2
+// MSVC-X86-NOT:#define __GCC_ATOMIC{{.*}}

test/Sema/atomic-ops.c

 // RUN: %clang_cc1 %s -verify -ffreestanding -fsyntax-only -triple=i686-linux-gnu -std=c11
 
 // Basic parsing/Sema tests for __c11_atomic_*
 
 #include <stdatomic.h>
 
 struct S { char c[3]; };
 
 _Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == __CLANG_ATOMIC_BOOL_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == __CLANG_ATOMIC_CHAR_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == __CLANG_ATOMIC_CHAR16_T_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == __CLANG_ATOMIC_CHAR32_T_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == __CLANG_ATOMIC_WCHAR_T_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == __CLANG_ATOMIC_SHORT_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == __CLANG_ATOMIC_INT_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == __CLANG_ATOMIC_LONG_LOCK_FREE, "");
 #ifdef __i386__
 _Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 1, "");
 #else
 _Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 2, "");
 #endif
+_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == __CLANG_ATOMIC_LLONG_LOCK_FREE, "");
 _Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == 2, "");
+_Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == __CLANG_ATOMIC_POINTER_LOCK_FREE, "");
 
 _Static_assert(__c11_atomic_is_lock_free(1), "");
 _Static_assert(__c11_atomic_is_lock_free(2), "");
 _Static_assert(__c11_atomic_is_lock_free(3), ""); // expected-error {{not an integral constant expression}}
 _Static_assert(__c11_atomic_is_lock_free(4), "");
 _Static_assert(__c11_atomic_is_lock_free(8), "");
 _Static_assert(__c11_atomic_is_lock_free(16), ""); // expected-error {{not an integral constant expression}}
 _Static_assert(__c11_atomic_is_lock_free(17), ""); // expected-error {{not an integral constant expression}}