Merge pull request #289 from boostorg/gcc9

Add gcc-9, clang-8, xcode-10 to test matrix.

.travis.yml

@@ -124,6 +124,17 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
+    - os: linux
+      dist: trusty
+      compiler: g++-9
+      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - ubuntu-toolchain-r-test
+
     - os: linux
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
 
@@ -250,9 +261,24 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-xenial-7
 
+    - os: linux
+      compiler: clang++-8
+      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-8
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,17,2a
+      osx_image: xcode10.2
+
     - os: osx
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode9.1
+      osx_image: xcode9.4
 
     - os: osx
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z

include/boost/config/detail/suffix.hpp

@@ -999,7 +999,7 @@ namespace std{ using ::type_info; }
 #if __has_cpp_attribute(nodiscard)
 # define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]]
 #endif
-#if __has_cpp_attribute(no_unique_address)
+#if __has_cpp_attribute(no_unique_address) && !(defined(__GNUC__) && (__cplusplus < 201100))
 # define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]
 #endif
 #endif

test/boost_no_cxx11_hdr_atomic.ipp

@@ -21,72 +21,78 @@
 
 namespace boost_no_cxx11_hdr_atomic {
 
-int test()
+   void consume(std::memory_order)
-{
+   {}
-   std::memory_order m = static_cast<std::memory_order>(std::memory_order_relaxed | std::memory_order_consume | std::memory_order_acquire | std::memory_order_release 
-                           | std::memory_order_acq_rel | std::memory_order_seq_cst);
-   (void)m;
 
-   std::atomic<int> a1;
+   int test()
-   std::atomic<unsigned> a2;
+   {
-   std::atomic<int*>    a3;
+      consume(std::memory_order_relaxed);
-   a1.is_lock_free();
+      consume(std::memory_order_consume);
-   a1.store(1);
+      consume(std::memory_order_acquire);
-   a1.load();
+      consume(std::memory_order_release);
-   a1.exchange(2);
+      consume(std::memory_order_acq_rel);
-   int v;
+      consume(std::memory_order_seq_cst);
-   a1.compare_exchange_weak(v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
-   a1.compare_exchange_strong(v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
-   a1.fetch_add(2);
-   a1.fetch_sub(3);
-   a1.fetch_and(3);
-   a1.fetch_or(1);
-   a1.fetch_xor(1);
-   a1++;
-   ++a1;
-   a1--;
-   --a1;
-   a1 += 2;
-   a1 -= 2;
-   a1 &= 1;
-   a1 |= 2;
-   a1 ^= 3;
 
-   a2 = 0u;
+      std::atomic<int> a1;
+      std::atomic<unsigned> a2;
+      std::atomic<int*>    a3;
+      a1.is_lock_free();
+      a1.store(1);
+      a1.load();
+      a1.exchange(2);
+      int v;
+      a1.compare_exchange_weak(v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
+      a1.compare_exchange_strong(v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
+      a1.fetch_add(2);
+      a1.fetch_sub(3);
+      a1.fetch_and(3);
+      a1.fetch_or(1);
+      a1.fetch_xor(1);
+      a1++;
+      ++a1;
+      a1--;
+      --a1;
+      a1 += 2;
+      a1 -= 2;
+      a1 &= 1;
+      a1 |= 2;
+      a1 ^= 3;
 
-   a3.store(&v);
+      a2 = 0u;
-   a3.fetch_add(1);
-   a3.fetch_sub(1);
-   ++a3;
-   --a3;
-   a3++;
-   a3--;
-   a3 += 1;
-   a3 -= 1;
 
-   std::atomic_is_lock_free(&a1);
+      a3.store(&v);
-   // This produces linker errors on Mingw32 for some reason, probably not required anyway for most uses??
+      a3.fetch_add(1);
-   //std::atomic_init(&a1, 2);
+      a3.fetch_sub(1);
-   std::atomic_store(&a1, 3);
+      ++a3;
-   std::atomic_store_explicit(&a1, 3, std::memory_order_relaxed);
+      --a3;
-   std::atomic_load(&a1);
+      a3++;
-   std::atomic_load_explicit(&a1, std::memory_order_relaxed);
+      a3--;
-   std::atomic_exchange(&a1, 3);
+      a3 += 1;
-   std::atomic_compare_exchange_weak(&a1, &v, 2);
+      a3 -= 1;
-   std::atomic_compare_exchange_strong(&a1, &v, 2);
-   std::atomic_compare_exchange_weak_explicit(&a1, &v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
-   std::atomic_compare_exchange_strong_explicit(&a1, &v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
 
-   std::atomic_flag f = ATOMIC_FLAG_INIT;
+      std::atomic_is_lock_free(&a1);
-   f.test_and_set(std::memory_order_relaxed);
+      // This produces linker errors on Mingw32 for some reason, probably not required anyway for most uses??
-   f.test_and_set();
+      //std::atomic_init(&a1, 2);
-   f.clear(std::memory_order_relaxed);
+      std::atomic_store(&a1, 3);
-   f.clear();
+      std::atomic_store_explicit(&a1, 3, std::memory_order_relaxed);
+      std::atomic_load(&a1);
+      std::atomic_load_explicit(&a1, std::memory_order_relaxed);
+      std::atomic_exchange(&a1, 3);
+      std::atomic_compare_exchange_weak(&a1, &v, 2);
+      std::atomic_compare_exchange_strong(&a1, &v, 2);
+      std::atomic_compare_exchange_weak_explicit(&a1, &v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
+      std::atomic_compare_exchange_strong_explicit(&a1, &v, 2, std::memory_order_relaxed, std::memory_order_relaxed);
 
-   std::atomic_thread_fence(std::memory_order_relaxed);
+      std::atomic_flag f = ATOMIC_FLAG_INIT;
-   std::atomic_signal_fence(std::memory_order_relaxed);
+      f.test_and_set(std::memory_order_relaxed);
+      f.test_and_set();
+      f.clear(std::memory_order_relaxed);
+      f.clear();
 
-   return 0;
+      std::atomic_thread_fence(std::memory_order_relaxed);
-}
+      std::atomic_signal_fence(std::memory_order_relaxed);
+
+      return 0;
+   }
 
 }

test/boost_no_unicode_literals.ipp

@@ -17,7 +17,7 @@ void quiet_warning(const CharT*){}
 
 int test()
 {
-#ifdef __cpp_char8_type
+#if defined(__cpp_char8_type) || defined(__cpp_char8_t)
    // The change to char8_t in C++20 is a breaking change to the std:
    const char8_t* c8 = u8"";
 #else

test/config_info.cpp

@@ -1231,25 +1231,6 @@ void print_boost_macros()
    PRINT_MACRO(BOOST_NO_USING_TEMPLATE);
    PRINT_MACRO(BOOST_NO_VOID_RETURNS);
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    // END GENERATED BLOCK
 
    PRINT_MACRO(BOOST_INTEL);
@@ -1267,12 +1248,26 @@ void print_boost_macros()
    PRINT_MACRO(BOOST_FALLTHROUGH);
    PRINT_MACRO(BOOST_MAY_ALIAS);
    PRINT_MACRO(BOOST_NO_MAY_ALIAS);
+   PRINT_MACRO(BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS);
+   PRINT_MACRO(BOOST_ATTRIBUTE_UNUSED);
+   PRINT_MACRO(BOOST_UNLIKELY);
+   PRINT_MACRO(BOOST_NORETURN);
 }
 
 void print_sd6_macros()
 {
     // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0096r5.html
 
+    // C++20:
+    PRINT_MACRO(__cpp_aggregate_paren_init);
+    PRINT_MACRO(__cpp_char8_t);
+    PRINT_MACRO(__cpp_char8_type);
+    PRINT_MACRO(__cpp_conditional_explicit);
+    PRINT_MACRO(__cpp_coroutines);
+    PRINT_MACRO(__cpp_impl_destroying_delete);
+    PRINT_MACRO(__cpp_impl_three_way_comparison);
+    PRINT_MACRO(__cpp_nontype_template_parameter_class);
+
     // C++17:
     PRINT_MACRO(__cpp_hex_float);
     PRINT_MACRO(__cpp_inline_variables);