Fix more uses of dynamic exception specifications in C++17

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@289356 91177308-0d34-0410-b5e6-96231b3b80d8

test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp

@@ -22,6 +22,8 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 constexpr auto OverAligned = alignof(std::max_align_t) * 2;
 
 int unsized_delete_called = 0;
@@ -34,19 +36,19 @@ void reset() {
     aligned_delete_called = 0;
 }
 
-void operator delete(void* p) throw()
+void operator delete(void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete(void* p, const std::nothrow_t&) throw()
+void operator delete(void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete [] (void* p, std::align_val_t a) throw()
+void operator delete [] (void* p, std::align_val_t a) TEST_NOEXCEPT
 {
     ++aligned_delete_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp

@@ -20,6 +20,8 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
+
 constexpr auto OverAligned = alignof(std::max_align_t) * 2;
 
 int A_constructed = 0;
@@ -41,7 +43,7 @@ struct B {
 int new_called = 0;
 alignas(OverAligned) char Buff[OverAligned * 3];
 
-void* operator new[](std::size_t s, std::align_val_t a) throw(std::bad_alloc)
+void* operator new[](std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
 {
     assert(!new_called);
     assert(s <= sizeof(Buff));
@@ -50,7 +52,7 @@ void* operator new[](std::size_t s, std::align_val_t a) throw(std::bad_alloc)
     return Buff;
 }
 
-void  operator delete[](void* p, std::align_val_t a) throw()
+void  operator delete[](void* p, std::align_val_t a) TEST_NOEXCEPT
 {
     assert(p == Buff);
     assert(static_cast<std::size_t>(a) == OverAligned);

test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp

@@ -21,6 +21,8 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
+
 constexpr auto OverAligned = alignof(std::max_align_t) * 2;
 
 int A_constructed = 0;
@@ -44,7 +46,7 @@ int new_called = 0;
 
 alignas(OverAligned) char DummyData[OverAligned * 4];
 
-void* operator new[](std::size_t s, std::align_val_t a) throw(std::bad_alloc)
+void* operator new[](std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
 {
     assert(new_called == 0); // We already allocated
     assert(s <= sizeof(DummyData));
@@ -53,7 +55,7 @@ void* operator new[](std::size_t s, std::align_val_t a) throw(std::bad_alloc)
     return DummyData;
 }
 
-void  operator delete[](void* p, std::align_val_t a) throw()
+void  operator delete[](void* p, std::align_val_t a) TEST_NOEXCEPT
 {
     assert(new_called == 1);
     --new_called;

test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp

@@ -17,9 +17,11 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
+
 int new_called = 0;
 
-void* operator new(std::size_t s) throw(std::bad_alloc)
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
 {
     ++new_called;
     void* ret = std::malloc(s);
@@ -27,7 +29,7 @@ void* operator new(std::size_t s) throw(std::bad_alloc)
     return  ret;
 }
 
-void  operator delete(void* p) throw()
+void  operator delete(void* p) TEST_NOEXCEPT
 {
     --new_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp

@@ -18,9 +18,11 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
+
 volatile int new_called = 0;
 
-void* operator new(std::size_t s) throw(std::bad_alloc)
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
 {
     ++new_called;
     void* ret = std::malloc(s);
@@ -28,7 +30,7 @@ void* operator new(std::size_t s) throw(std::bad_alloc)
     return  ret;
 }
 
-void  operator delete(void* p) throw()
+void  operator delete(void* p) TEST_NOEXCEPT
 {
     --new_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp

@@ -20,23 +20,25 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
 int sized_delete_called = 0;
 
-void operator delete[](void* p) throw()
+void operator delete[](void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete[](void* p, const std::nothrow_t&) throw()
+void operator delete[](void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete[](void* p, std::size_t) throw()
+void operator delete[](void* p, std::size_t) TEST_NOEXCEPT
 {
     ++sized_delete_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp

@@ -25,23 +25,25 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
 int sized_delete_called = 0;
 
-void operator delete[](void* p) throw()
+void operator delete[](void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete[](void* p, const std::nothrow_t&) throw()
+void operator delete[](void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete[](void* p, std::size_t) throw()
+void operator delete[](void* p, std::size_t) TEST_NOEXCEPT
 {
     ++sized_delete_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp

@@ -18,16 +18,18 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int delete_called = 0;
 int delete_nothrow_called = 0;
 
-void operator delete[](void* p) throw()
+void operator delete[](void* p) TEST_NOEXCEPT
 {
     ++delete_called;
     std::free(p);
 }
 
-void operator delete[](void* p, const std::nothrow_t&) throw()
+void operator delete[](void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++delete_nothrow_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp

@@ -33,23 +33,25 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
 int sized_delete_called = 0;
 
-void operator delete[](void* p) throw()
+void operator delete[](void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete[](void* p, const std::nothrow_t&) throw()
+void operator delete[](void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete[](void* p, std::size_t) throw()
+void operator delete[](void* p, std::size_t) TEST_NOEXCEPT
 {
     ++sized_delete_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp

@@ -23,6 +23,8 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 constexpr auto OverAligned = alignof(std::max_align_t) * 2;
 
 int unsized_delete_called = 0;
@@ -35,19 +37,19 @@ void reset() {
     aligned_delete_called = 0;
 }
 
-void operator delete(void* p) throw()
+void operator delete(void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete(void* p, const std::nothrow_t&) throw()
+void operator delete(void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete(void* p, std::align_val_t a) throw()
+void operator delete(void* p, std::align_val_t a) TEST_NOEXCEPT
 {
     ++aligned_delete_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp

@@ -20,6 +20,7 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
 
 constexpr auto OverAligned = alignof(std::max_align_t) * 2;
 
@@ -42,7 +43,7 @@ struct B {
 int new_called = 0;
 alignas(OverAligned) char Buff[OverAligned * 2];
 
-void* operator new(std::size_t s, std::align_val_t a) throw(std::bad_alloc)
+void* operator new(std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
 {
     assert(!new_called);
     assert(s <= sizeof(Buff));
@@ -51,7 +52,7 @@ void* operator new(std::size_t s, std::align_val_t a) throw(std::bad_alloc)
     return Buff;
 }
 
-void  operator delete(void* p, std::align_val_t a) throw()
+void  operator delete(void* p, std::align_val_t a) TEST_NOEXCEPT
 {
     assert(p == Buff);
     assert(static_cast<std::size_t>(a) == OverAligned);

test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp

@@ -21,6 +21,8 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
+
 constexpr auto OverAligned = alignof(std::max_align_t) * 2;
 
 bool A_constructed = false;
@@ -44,7 +46,7 @@ int new_called = 0;
 
 alignas(OverAligned) char DummyData[OverAligned];
 
-void* operator new(std::size_t s, std::align_val_t a) throw(std::bad_alloc)
+void* operator new(std::size_t s, std::align_val_t a) TEST_THROW_SPEC(std::bad_alloc)
 {
     assert(new_called == 0); // We already allocated
     assert(s <= sizeof(DummyData));
@@ -53,7 +55,7 @@ void* operator new(std::size_t s, std::align_val_t a) throw(std::bad_alloc)
     return DummyData;
 }
 
-void  operator delete(void* p, std::align_val_t a) throw()
+void  operator delete(void* p, std::align_val_t a) TEST_NOEXCEPT
 {
     assert(new_called == 1);
     --new_called;

test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp

@@ -17,9 +17,11 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
+
 int new_called = 0;
 
-void* operator new(std::size_t s) throw(std::bad_alloc)
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
 {
     ++new_called;
     void* ret = std::malloc(s);
@@ -27,7 +29,7 @@ void* operator new(std::size_t s) throw(std::bad_alloc)
     return ret;
 }
 
-void  operator delete(void* p) throw()
+void  operator delete(void* p) TEST_NOEXCEPT
 {
     --new_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp

@@ -17,9 +17,11 @@
 #include <cassert>
 #include <limits>
 
+#include "test_macros.h"
+
 int new_called = 0;
 
-void* operator new(std::size_t s) throw(std::bad_alloc)
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
 {
     ++new_called;
     void* ret = std::malloc(s);
@@ -27,7 +29,7 @@ void* operator new(std::size_t s) throw(std::bad_alloc)
     return ret;
 }
 
-void  operator delete(void* p) throw()
+void  operator delete(void* p) TEST_NOEXCEPT
 {
     --new_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp

@@ -20,23 +20,25 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
 int sized_delete_called = 0;
 
-void operator delete(void* p) throw()
+void operator delete(void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete(void* p, const std::nothrow_t&) throw()
+void operator delete(void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete(void* p, std::size_t) throw()
+void operator delete(void* p, std::size_t) TEST_NOEXCEPT
 {
     ++sized_delete_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp

@@ -25,23 +25,25 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
 int sized_delete_called = 0;
 
-void operator delete(void* p) throw()
+void operator delete(void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete(void* p, const std::nothrow_t&) throw()
+void operator delete(void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete(void* p, std::size_t) throw()
+void operator delete(void* p, std::size_t) TEST_NOEXCEPT
 {
     ++sized_delete_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp

@@ -18,16 +18,18 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int delete_called = 0;
 int delete_nothrow_called = 0;
 
-void operator delete(void* p) throw()
+void operator delete(void* p) TEST_NOEXCEPT
 {
     ++delete_called;
     std::free(p);
 }
 
-void operator delete(void* p, const std::nothrow_t&) throw()
+void operator delete(void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++delete_nothrow_called;
     std::free(p);

test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp

@@ -33,23 +33,25 @@
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
 int sized_delete_called = 0;
 
-void operator delete(void* p) throw()
+void operator delete(void* p) TEST_NOEXCEPT
 {
     ++unsized_delete_called;
     std::free(p);
 }
 
-void operator delete(void* p, const std::nothrow_t&) throw()
+void operator delete(void* p, const std::nothrow_t&) TEST_NOEXCEPT
 {
     ++unsized_delete_nothrow_called;
     std::free(p);
 }
 
-void operator delete(void* p, std::size_t) throw()
+void operator delete(void* p, std::size_t) TEST_NOEXCEPT
 {
     ++sized_delete_called;
     std::free(p);

test/support/count_new.hpp

@@ -234,10 +234,7 @@ public:
 MemCounter globalMemCounter((MemCounter::MemCounterCtorArg_()));
 
 #ifndef DISABLE_NEW_COUNT
-void* operator new(std::size_t s)
+void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-#if TEST_STD_VER < 11
-    throw(std::bad_alloc)
-#endif
 {
     globalMemCounter.newCalled(s);
     void* ret = std::malloc(s);
@@ -246,34 +243,21 @@ void* operator new(std::size_t s)
     return ret;
 }
 
-void  operator delete(void* p)
+void  operator delete(void* p) TEST_NOEXCEPT
-#if TEST_STD_VER < 11
-    throw()
-#else
-    noexcept
-#endif
 {
     globalMemCounter.deleteCalled(p);
     std::free(p);
 }
 
 
-void* operator new[](std::size_t s)
+void* operator new[](std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-#if TEST_STD_VER < 11
-    throw(std::bad_alloc)
-#endif
 {
     globalMemCounter.newArrayCalled(s);
     return operator new(s);
 }
 
 
-void operator delete[](void* p)
+void operator delete[](void* p) TEST_NOEXCEPT
-#if TEST_STD_VER < 11
-    throw()
-#else
-    noexcept
-#endif
 {
     globalMemCounter.deleteArrayCalled(p);
     operator delete(p);

test/support/test_allocator.h

@@ -61,13 +61,13 @@ public:
 
     template <class U> struct rebind {typedef test_allocator<U> other;};
 
-    test_allocator() throw() : data_(0) {++count;}
+    test_allocator() TEST_NOEXCEPT : data_(0) {++count;}
-    explicit test_allocator(int i) throw() : data_(i) {++count;}
+    explicit test_allocator(int i) TEST_NOEXCEPT : data_(i) {++count;}
-    test_allocator(const test_allocator& a) throw()
+    test_allocator(const test_allocator& a) TEST_NOEXCEPT
         : data_(a.data_) {++count;}
-    template <class U> test_allocator(const test_allocator<U>& a) throw()
+    template <class U> test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
         : data_(a.data_) {++count;}
-    ~test_allocator() throw() {assert(data_ >= 0); --count; data_ = -1;}
+    ~test_allocator() TEST_NOEXCEPT {assert(data_ >= 0); --count; data_ = -1;}
     pointer address(reference x) const {return &x;}
     const_pointer address(const_reference x) const {return &x;}
     pointer allocate(size_type n, const void* = 0)
@@ -86,7 +86,7 @@ public:
         }
     void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p);}
-    size_type max_size() const throw()
+    size_type max_size() const TEST_NOEXCEPT
         {return UINT_MAX / sizeof(T);}
 #if TEST_STD_VER < 11
     void construct(pointer p, const T& val)
@@ -122,13 +122,13 @@ public:
 
     template <class U> struct rebind {typedef non_default_test_allocator<U> other;};
 
-//    non_default_test_allocator() throw() : data_(0) {++count;}
+//    non_default_test_allocator() TEST_NOEXCEPT : data_(0) {++count;}
-    explicit non_default_test_allocator(int i) throw() : data_(i) {++count;}
+    explicit non_default_test_allocator(int i) TEST_NOEXCEPT : data_(i) {++count;}
-    non_default_test_allocator(const non_default_test_allocator& a) throw()
+    non_default_test_allocator(const non_default_test_allocator& a) TEST_NOEXCEPT
         : data_(a.data_) {++count;}
-    template <class U> non_default_test_allocator(const non_default_test_allocator<U>& a) throw()
+    template <class U> non_default_test_allocator(const non_default_test_allocator<U>& a) TEST_NOEXCEPT
         : data_(a.data_) {++count;}
-    ~non_default_test_allocator() throw() {assert(data_ >= 0); --count; data_ = -1;}
+    ~non_default_test_allocator() TEST_NOEXCEPT {assert(data_ >= 0); --count; data_ = -1;}
     pointer address(reference x) const {return &x;}
     const_pointer address(const_reference x) const {return &x;}
     pointer allocate(size_type n, const void* = 0)
@@ -147,7 +147,7 @@ public:
         }
     void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p); }
-    size_type max_size() const throw()
+    size_type max_size() const TEST_NOEXCEPT
         {return UINT_MAX / sizeof(T);}
 #if TEST_STD_VER < 11
     void construct(pointer p, const T& val)
@@ -181,13 +181,13 @@ public:
 
     template <class U> struct rebind {typedef test_allocator<U> other;};
 
-    test_allocator() throw() : data_(0) {}
+    test_allocator() TEST_NOEXCEPT : data_(0) {}
-    explicit test_allocator(int i) throw() : data_(i) {}
+    explicit test_allocator(int i) TEST_NOEXCEPT : data_(i) {}
-    test_allocator(const test_allocator& a) throw()
+    test_allocator(const test_allocator& a) TEST_NOEXCEPT
         : data_(a.data_) {}
-    template <class U> test_allocator(const test_allocator<U>& a) throw()
+    template <class U> test_allocator(const test_allocator<U>& a) TEST_NOEXCEPT
         : data_(a.data_) {}
-    ~test_allocator() throw() {data_ = -1;}
+    ~test_allocator() TEST_NOEXCEPT {data_ = -1;}
 
     friend bool operator==(const test_allocator& x, const test_allocator& y)
         {return x.data_ == y.data_;}

test/support/test_macros.h

@@ -86,6 +86,8 @@
 #endif
 
 #if TEST_STD_VER >= 11
+#define TEST_ALIGNOF(...) alignof(__VA_ARGS__)
+#define TEST_ALIGNAS(...) alignas(__VA_ARGS__)
 #define TEST_CONSTEXPR constexpr
 #define TEST_NOEXCEPT noexcept
 #define TEST_NOEXCEPT_COND(...) noexcept(__VA_ARGS__)
@@ -94,15 +96,19 @@
 # else
 #   define TEST_CONSTEXPR_CXX14
 # endif
-#define TEST_ALIGNOF(...) alignof(__VA_ARGS__)
+# if TEST_STD_VER > 14
-#define TEST_ALIGNAS(...) alignas(__VA_ARGS__)
+#   define TEST_THROW_SPEC(...)
 # else
+#   define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
+# endif
+#else
+#define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
+#define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
 #define TEST_CONSTEXPR
 #define TEST_CONSTEXPR_CXX14
 #define TEST_NOEXCEPT throw()
 #define TEST_NOEXCEPT_COND(...)
-#define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
+#define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
-#define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
 #endif
 
 #define TEST_ALIGNAS_TYPE(...) TEST_ALIGNAS(TEST_ALIGNOF(__VA_ARGS__))