[libcxx] Allow <atomic> to be used in c++03.

[EricWF]

Summary

There are many places where libc++ want to use <atomic> internally in C++03 code. Unfortunately <atomic> currently only supports C++11 and later. This patch extends <atomic> so that everything except ATOMIC_VAR_INIT and ATOMIC_FLAG_INIT can be used in c++03 code.

This patch introduces the macros:

• _LIBCPP_HAS_C11_ATOMICS: Defined if __has_extension(c_atomic) is true.
• _LIBCPP_HAS_CXX_ATOMICS: Defined if we have C11 atomics from clang or the __atomic_* builtin family from GCC and libc++ is configured for threads. If _LIBCPP_HAS_CXX_ATOMICS is defined then the <atomic> header should be safe to include.

Other Misc changes:

• __gcc_atomic_t default constructs the stored value. This make it perform the same as _Atomic.
• constexpr -> _LIBCPP_CONSTEXPR
• noexcept -> TEST_NOEXCEPT in the tests.
• re-implement std::atomic::is_lock_free() to prevent needing libatomic with GCC.

Everything in atomic works in C++03 except for ATOMIC_VAR_INIT and ATOMIC_FLAG_INIT. These macros are required to allow:

std::atomic_flag f = ATOMIC_FLAG_INIT;

// ATOMIC_VAR_INIT is defined as
#define ATOMIC_VAR_INIT {false}

In c++11 f is aggregate-initialized but in C++03 f is copy-initialized. Since atomic types are not copy-able this results in a compile error in C++03. For this reason the macros are not defined in C++03 mode.

Furthermore initialization of static storage duration atomics using the macros takes place during constant-initialization.(http://en.cppreference.com/w/cpp/language/constant_initialization). This makes statically initialized atomic's safe and easy to use in other static initialization expressions.

There doesn't seem to be a way to implement these macros in C++03. For that reason they are simply removed when __cplusplus < 201103L.

[EricWF]

Added missing tests.

[danalbert]

Not sure what our policy is on allowing C++11 features in pre-C++11 code. I think I'd prefer that people just be required to upgrade to C++11 rather than allowing them to keep living in the past.

I also don't like that we're not implementing a complete <atomic> in C++03 mode. Sounds like another good reason to not support it to me.

I'll defer to mclow on this one. Just my two cents.

[EricWF]

In D6284#6, @danalbert wrote:

Not sure what our policy is on allowing C++11 features in pre-C++11 code. I think I'd prefer that people just be required to upgrade to C++11 rather than allowing them to keep living in the past.

libc++ is a C++11 standard library with C++03 compatibility (or at least that is what I've been told). <atomic> is currently the only header that explicitly causes a compile error when included in C++03. Almost every other header seems to give a best effort approach to providing c++03 compatibility. <atomic> works almost perfectly in C++03 already so I don't see why we forbid it.

I also don't like that we're not implementing a complete <atomic> in C++03 mode. Sounds like another good reason to not support it to me.

Fair point. The only lost functionality is initialization with an = sign in it. This is more a loss of syntax than it is functionality.

I'll defer to mclow on this one. Just my two cents.

Thanks for the input. I would just like to know what to do with the tests in C++03 mode :)

[EricWF]

@mclow.lists: Ping.

[EricWF]

@mclow.lists: Ping. We should make a decision on this.

[EricWF]

@chandlerc made me aware of the static initialization issues. I don't think it is possible to make static initialization happen during constant initialization in c++03. This makes backporting atomic non-viable.

For this reason I am abandoning the revision.

include/atomic

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !__has_feature(cxx_atomic) && _GNUC_VER < 407
+#if !__has_extension(c_atomic) && _GNUC_VER < 407
 #error <atomic> is not implemented
 #else
 

 typedef atomic<intmax_t>  atomic_intmax_t;
 typedef atomic<uintmax_t> atomic_uintmax_t;
 
-#define ATOMIC_FLAG_INIT {false}
-#define ATOMIC_VAR_INIT(__v) {__v}
+#if __cplusplus >= 201103L
+#  define ATOMIC_FLAG_INIT {false}
+#  define ATOMIC_VAR_INIT(__v) {__v}
+#endif
 
 // lock-free property
 

test/atomics/atomics.flag/init.pass.cpp

 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// NOTE: ATOMIC_FLAG_INIT is only defined for c++ >= 11
+// XFAIL: c++98, c++03
+
 // <atomic>
 
 // struct atomic_flag

test/atomics/atomics.flag/init_defined.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
+
+#include <atomic>
+
+#if __cplusplus < 201103L
+#  if defined(ATOMIC_FLAG_INIT)
+#    error ATOMIC_FLAG_INIT should not be defined when c++ < 11
+#  endif
+#else
+#  if !defined(ATOMIC_FLAG_INIT)
+#    error ATOMIC_FLAG_INIT should be defined when c++ >= 11
+#  endif
+#endif
+
+int main()
+{
+}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) _NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp

 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// NOTE: ATOMIC_VAR_INIT is only defined for c++ >= 11
+// XFAIL: c++98, c++03
+
 // <atomic>
 
 // #define ATOMIC_VAR_INIT(value)

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init_defined.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
+
+// <atomic>
+
+// #define ATOMIC_VAR_INIT(value)
+
+#include <atomic>
+
+#if __cplusplus < 201103L
+#  if defined(ATOMIC_VAR_INIT)
+#    error ATOMIC_VAR_INIT should not be defined when c++ < 11
+#  endif
+#else
+#  if !defined(ATOMIC_VAR_INIT)
+#    error ATOMIC_VAR_INIT must be defined when c++ >= 11
+#  endif
+#endif
+
+int main()
+{
+}