[libc++/abi] Replace uses of _NOEXCEPT in src/ by noexcept

[ldionne]

Summary

We always build the libraries in a Standard mode that supports noexcept,
so there's no need to use the _NOEXCEPT macro.

libcxx/src/any.cpp

 //===---------------------------- any.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "any"
 
 namespace std {
-const char* bad_any_cast::what() const _NOEXCEPT {
+const char* bad_any_cast::what() const noexcept {
     return "bad any cast";
 }
 }
 
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::any_bad_cast for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
 {
 public:
-    virtual const char* what() const _NOEXCEPT;
+    virtual const char* what() const noexcept;
 };
 
-const char* bad_any_cast::what() const _NOEXCEPT {
+const char* bad_any_cast::what() const noexcept {
     return "bad any cast";
 }
 
 _LIBCPP_END_NAMESPACE_LFTS

libcxx/src/charconv.cpp

append8_no_zeros(char* buffer, T v) noexcept
     {
         buffer = append4_no_zeros(buffer, v / 10000);
         buffer = append4(buffer, v % 10000);
     }
     return buffer;
 }
 
 char*
-__u32toa(uint32_t value, char* buffer) _NOEXCEPT
+__u32toa(uint32_t value, char* buffer) noexcept
 {
     if (value < 100000000)
     {
         buffer = append8_no_zeros(buffer, value);
     }
     else
     {
         // value = aabbbbcccc in decimal
         const uint32_t a = value / 100000000;  // 1 to 42
         value %= 100000000;
 
         buffer = append2_no_zeros(buffer, a);
         buffer = append4(buffer, value / 10000);
         buffer = append4(buffer, value % 10000);
     }
 
     return buffer;
 }
 
 char*
-__u64toa(uint64_t value, char* buffer) _NOEXCEPT
+__u64toa(uint64_t value, char* buffer) noexcept
 {
     if (value < 100000000)
     {
         uint32_t v = static_cast<uint32_t>(value);
         buffer = append8_no_zeros(buffer, v);
     }
     else if (value < 10000000000000000)
     {

libcxx/src/chrono.cpp

static system_clock::time_point __libcpp_system_clock_now() {
     return system_clock::time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
 }
 
 #endif
 
 const bool system_clock::is_steady;
 
 system_clock::time_point
-system_clock::now() _NOEXCEPT
+system_clock::now() noexcept
 {
     return __libcpp_system_clock_now();
 }
 
 time_t
-system_clock::to_time_t(const time_point& t) _NOEXCEPT
+system_clock::to_time_t(const time_point& t) noexcept
 {
     return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
 }
 
 system_clock::time_point
-system_clock::from_time_t(time_t t) _NOEXCEPT
+system_clock::from_time_t(time_t t) noexcept
 {
     return system_clock::time_point(seconds(t));
 }
 
 //
 // steady_clock
 //
 // Warning:  If this is not truly steady, then it is non-conforming.  It is

 
 #else
 #   error "Monotonic clock not implemented on this platform"
 #endif
 
 const bool steady_clock::is_steady;
 
 steady_clock::time_point
-steady_clock::now() _NOEXCEPT
+steady_clock::now() noexcept
 {
     return __libcpp_steady_clock_now();
 }
 
 #endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK
 
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/condition_variable.cpp

 #pragma comment(lib, "pthread")
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // ~condition_variable is defined elsewhere.
 
 void
-condition_variable::notify_one() _NOEXCEPT
+condition_variable::notify_one() noexcept
 {
     __libcpp_condvar_signal(&__cv_);
 }
 
 void
-condition_variable::notify_all() _NOEXCEPT
+condition_variable::notify_all() noexcept
 {
     __libcpp_condvar_broadcast(&__cv_);
 }
 
 void
-condition_variable::wait(unique_lock<mutex>& lk) _NOEXCEPT
+condition_variable::wait(unique_lock<mutex>& lk) noexcept
 {
     if (!lk.owns_lock())
         __throw_system_error(EPERM,
                                   "condition_variable::wait: mutex not locked");
     int ec = __libcpp_condvar_wait(&__cv_, lk.mutex()->native_handle());
     if (ec)
         __throw_system_error(ec, "condition_variable wait failed");
 }
 
 void
 condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
-     chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) _NOEXCEPT
+     chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) noexcept
 {
     using namespace chrono;
     if (!lk.owns_lock())
         __throw_system_error(EPERM,
                             "condition_variable::timed wait: mutex not locked");
     nanoseconds d = tp.time_since_epoch();
     if (d > nanoseconds(0x59682F000000E941))
         d = nanoseconds(0x59682F000000E941);

libcxx/src/experimental/memory_resource.cpp

 #endif
         return _VSTD::__libcpp_allocate(size, align);
     }
 
     void do_deallocate(void *p, size_t n, size_t align) override {
       _VSTD::__libcpp_deallocate(p, n, align);
     }
 
-    bool do_is_equal(memory_resource const & other) const _NOEXCEPT override
+    bool do_is_equal(memory_resource const & other) const noexcept override
         { return &other == this; }
 
 public:
     ~__new_delete_memory_resource_imp() override = default;
 };
 
 // null_memory_resource()
 
 class _LIBCPP_TYPE_VIS __null_memory_resource_imp
     : public memory_resource
 {
 public:
     ~__null_memory_resource_imp() = default;
 
 protected:
     virtual void* do_allocate(size_t, size_t) {
         __throw_bad_alloc();
     }
     virtual void do_deallocate(void *, size_t, size_t) {}
-    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
+    virtual bool do_is_equal(memory_resource const & __other) const noexcept
     { return &__other == this; }
 };
 
 namespace {
 
 union ResourceInitHelper {
   struct {
     __new_delete_memory_resource_imp new_delete_res;
     __null_memory_resource_imp       null_res;
   } resources;
   char dummy;
   _LIBCPP_CONSTEXPR_AFTER_CXX11 ResourceInitHelper() : resources() {}
   ~ResourceInitHelper() {}
 };
 
 _LIBCPP_SAFE_STATIC ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;
 
 } // end namespace
 
 
-memory_resource * new_delete_resource() _NOEXCEPT {
+memory_resource * new_delete_resource() noexcept {
     return &res_init.resources.new_delete_res;
 }
 
-memory_resource * null_memory_resource() _NOEXCEPT {
+memory_resource * null_memory_resource() noexcept {
     return &res_init.resources.null_res;
 }
 
 // default_memory_resource()
 
 static memory_resource *
-__default_memory_resource(bool set = false, memory_resource * new_res = nullptr) _NOEXCEPT
+__default_memory_resource(bool set = false, memory_resource * new_res = nullptr) noexcept
 {
 #ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
     _LIBCPP_SAFE_STATIC static atomic<memory_resource*> __res =
         ATOMIC_VAR_INIT(&res_init.resources.new_delete_res);
     if (set) {
         new_res = new_res ? new_res : new_delete_resource();
         // TODO: Can a weaker ordering be used?
         return _VSTD::atomic_exchange_explicit(
if (set) {
         res = new_res;
         return old_res;
     } else {
         return res;
     }
 #endif
 }
 
-memory_resource * get_default_resource() _NOEXCEPT
+memory_resource * get_default_resource() noexcept
 {
     return __default_memory_resource();
 }
 
-memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT
+memory_resource * set_default_resource(memory_resource * __new_res) noexcept
 {
     return __default_memory_resource(true, __new_res);
 }
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR

libcxx/src/functional.cpp

 //===----------------------- functional.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "functional"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
-bad_function_call::~bad_function_call() _NOEXCEPT
+bad_function_call::~bad_function_call() noexcept
 {
 }
 
 const char*
-bad_function_call::what() const _NOEXCEPT
+bad_function_call::what() const noexcept
 {
     return "std::bad_function_call";
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/future.cpp

 #include "string"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __future_error_category
     : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const noexcept;
     virtual string message(int ev) const;
 };
 
 const char*
-__future_error_category::name() const _NOEXCEPT
+__future_error_category::name() const noexcept
 {
     return "future";
 }
 
 #if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wswitch"
 #elif defined(__GNUC__) || defined(__GNUG__)

 
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #elif defined(__GNUC__) || defined(__GNUG__)
 #pragma GCC diagnostic pop
 #endif
 
 const error_category&
-future_category() _NOEXCEPT
+future_category() noexcept
 {
     static __future_error_category __f;
     return __f;
 }
 
 future_error::future_error(error_code __ec)
     : logic_error(__ec.message()),
       __ec_(__ec)
 {
 }
 
-future_error::~future_error() _NOEXCEPT
+future_error::~future_error() noexcept
 {
 }
 
 void
-__assoc_sub_state::__on_zero_shared() _NOEXCEPT
+__assoc_sub_state::__on_zero_shared() noexcept
 {
     delete this;
 }
 
 void
 __assoc_sub_state::set_value()
 {
     unique_lock<mutex> __lk(__mut_);

libcxx/src/include/refstring.h

 
 inline char * data_from_rep(_Rep_base *rep) noexcept {
     char *data = reinterpret_cast<char *>(rep);
     return data + sizeof(*rep);
 }
 
 #if defined(_LIBCPP_CHECK_FOR_GCC_EMPTY_STRING_STORAGE)
 inline
-const char* compute_gcc_empty_string_storage() _NOEXCEPT
+const char* compute_gcc_empty_string_storage() noexcept
 {
     void* handle = dlopen("/usr/lib/libstdc++.6.dylib", RTLD_NOLOAD);
     if (handle == nullptr)
         return nullptr;
     void* sym = dlsym(handle, "_ZNSs4_Rep20_S_empty_rep_storageE");
     if (sym == nullptr)
         return nullptr;
     return data_from_rep(reinterpret_cast<_Rep_base *>(sym));
 }
 
 inline
 const char*
-get_gcc_empty_string_storage() _NOEXCEPT
+get_gcc_empty_string_storage() noexcept
 {
     static const char* p = compute_gcc_empty_string_storage();
     return p;
 }
 #endif
 
 }} // namespace __refstring_imp
 
 using namespace __refstring_imp;
 
 inline
 __libcpp_refstring::__libcpp_refstring(const char* msg) {
     std::size_t len = strlen(msg);
     _Rep_base* rep = static_cast<_Rep_base *>(::operator new(sizeof(*rep) + len + 1));
     rep->len = len;
     rep->cap = len;
     rep->count = 0;
     char *data = data_from_rep(rep);
     std::memcpy(data, msg, len + 1);
     __imp_ = data;
 }
 
 inline
-__libcpp_refstring::__libcpp_refstring(const __libcpp_refstring &s) _NOEXCEPT
+__libcpp_refstring::__libcpp_refstring(const __libcpp_refstring &s) noexcept
     : __imp_(s.__imp_)
 {
     if (__uses_refcount())
         __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
 }
 
 inline
-__libcpp_refstring& __libcpp_refstring::operator=(__libcpp_refstring const& s) _NOEXCEPT {
+__libcpp_refstring& __libcpp_refstring::operator=(__libcpp_refstring const& s) noexcept {
     bool adjust_old_count = __uses_refcount();
     struct _Rep_base *old_rep = rep_from_data(__imp_);
     __imp_ = s.__imp_;
     if (__uses_refcount())
         __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
     if (adjust_old_count)
     {
         if (__libcpp_atomic_add(&old_rep->count, count_t(-1)) < 0)

libcxx/src/ios.cpp

 #include "__undef_macros"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __iostream_category
     : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const noexcept;
     virtual string message(int ev) const;
 };
 
 const char*
-__iostream_category::name() const _NOEXCEPT
+__iostream_category::name() const noexcept
 {
     return "iostream";
 }
 
 string
 __iostream_category::message(int ev) const
 {
     if (ev != static_cast<int>(io_errc::stream)
 #ifdef _LIBCPP_ELAST
         && ev <= _LIBCPP_ELAST
 #endif  // _LIBCPP_ELAST
         )
         return __do_message::message(ev);
     return string("unspecified iostream_category error");
 }
 
 const error_category&
-iostream_category() _NOEXCEPT
+iostream_category() noexcept
 {
     static __iostream_category s;
     return s;
 }
 
 // ios_base::failure
 
 ios_base::failure::failure(const string& msg, const error_code& ec)
ios_base::move(ios_base& rhs)
     rhs.__parray_ = 0;
     __parray_size_ = rhs.__parray_size_;
     rhs.__parray_size_ = 0;
     __parray_cap_ = rhs.__parray_cap_;
     rhs.__parray_cap_ = 0;
 }
 
 void
-ios_base::swap(ios_base& rhs) _NOEXCEPT
+ios_base::swap(ios_base& rhs) noexcept
 {
     _VSTD::swap(__fmtflags_, rhs.__fmtflags_);
     _VSTD::swap(__precision_, rhs.__precision_);
     _VSTD::swap(__width_, rhs.__width_);
     _VSTD::swap(__rdstate_, rhs.__rdstate_);
     _VSTD::swap(__exceptions_, rhs.__exceptions_);
     locale& lhs_loc = *reinterpret_cast<locale*>(&__loc_);
     locale& rhs_loc = *reinterpret_cast<locale*>(&rhs.__loc_);

libcxx/src/locale.cpp

 
 locale&
 locale::__global()
 {
     static locale& g = __imp::make_global();
     return g;
 }
 
-locale::locale()  _NOEXCEPT
+locale::locale() noexcept
     : __locale_(__global().__locale_)
 {
     __locale_->__add_shared();
 }
 
-locale::locale(const locale& l)  _NOEXCEPT
+locale::locale(const locale& l) noexcept
     : __locale_(l.__locale_)
 {
     __locale_->__add_shared();
 }
 
 locale::~locale()
 {
     __locale_->__release_shared();
 }
 
 const locale&
-locale::operator=(const locale& other)  _NOEXCEPT
+locale::operator=(const locale& other) noexcept
 {
     other.__locale_->__add_shared();
     __locale_->__release_shared();
     __locale_ = other.__locale_;
     return *this;
 }
 
 locale::locale(const char* name)

 
 // locale::facet
 
 locale::facet::~facet()
 {
 }
 
 void
-locale::facet::__on_zero_shared() _NOEXCEPT
+locale::facet::__on_zero_shared() noexcept
 {
     delete this;
 }
 
 // locale::id
 
 int32_t locale::id::__next_id = 0;
 

 #if defined(__EMSCRIPTEN__)
 extern "C" const unsigned short ** __ctype_b_loc();
 extern "C" const int ** __ctype_tolower_loc();
 extern "C" const int ** __ctype_toupper_loc();
 #endif
 
 #ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 const ctype<char>::mask*
-ctype<char>::classic_table()  _NOEXCEPT
+ctype<char>::classic_table() noexcept
 {
     static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl | space | blank,
         cntrl | space,                  cntrl | space,
static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
     };
     return builtin_table;
 }
 #else
 const ctype<char>::mask*
-ctype<char>::classic_table()  _NOEXCEPT
+ctype<char>::classic_table() noexcept
 {
 #if defined(__APPLE__) || defined(__FreeBSD__)
     return _DefaultRuneLocale.__runetype;
 #elif defined(__NetBSD__)
     return _C_ctype_tab_ + 1;
 #elif defined(__GLIBC__)
     return _LIBCPP_GET_C_LOCALE->__ctype_b;
 #elif __sun__
# warning  ctype<char>::classic_table() is not implemented
     abort();
     return NULL;
 #endif
 }
 #endif
 
 #if defined(__GLIBC__)
 const int*
-ctype<char>::__classic_lower_table() _NOEXCEPT
+ctype<char>::__classic_lower_table() noexcept
 {
     return _LIBCPP_GET_C_LOCALE->__ctype_tolower;
 }
 
 const int*
-ctype<char>::__classic_upper_table() _NOEXCEPT
+ctype<char>::__classic_upper_table() noexcept
 {
     return _LIBCPP_GET_C_LOCALE->__ctype_toupper;
 }
 #elif defined(__NetBSD__)
 const short*
-ctype<char>::__classic_lower_table() _NOEXCEPT
+ctype<char>::__classic_lower_table() noexcept
 {
     return _C_tolower_tab_ + 1;
 }
 
 const short*
-ctype<char>::__classic_upper_table() _NOEXCEPT
+ctype<char>::__classic_upper_table() noexcept
 {
     return _C_toupper_tab_ + 1;
 }
 
 #elif defined(__EMSCRIPTEN__)
 const int*
-ctype<char>::__classic_lower_table() _NOEXCEPT
+ctype<char>::__classic_lower_table() noexcept
 {
     return *__ctype_tolower_loc();
 }
 
 const int*
-ctype<char>::__classic_upper_table() _NOEXCEPT
+ctype<char>::__classic_upper_table() noexcept
 {
     return *__ctype_toupper_loc();
 }
 #endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__
 
 // template <> class ctype_byname<char>
 
 ctype_byname<char>::ctype_byname(const char* name, size_t refs)

 codecvt<char, char, mbstate_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-codecvt<char, char, mbstate_t>::do_encoding() const  _NOEXCEPT
+codecvt<char, char, mbstate_t>::do_encoding() const noexcept
 {
     return 1;
 }
 
 bool
-codecvt<char, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+codecvt<char, char, mbstate_t>::do_always_noconv() const noexcept
 {
     return true;
 }
 
 int
 codecvt<char, char, mbstate_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* end, size_t mx) const
 {
     return static_cast<int>(min<size_t>(mx, static_cast<size_t>(end-frm)));
 }
 
 int
-codecvt<char, char, mbstate_t>::do_max_length() const  _NOEXCEPT
+codecvt<char, char, mbstate_t>::do_max_length() const noexcept
 {
     return 1;
 }
 
 // template <> class codecvt<wchar_t, char, mbstate_t>
 
 locale::id codecvt<wchar_t, char, mbstate_t>::id;
 
codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
     if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
         return partial;
     for (extern_type* p = tmp; n; --n)  // write it
         *to_nxt++ = *p++;
     return ok;
 }
 
 int
-codecvt<wchar_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
+codecvt<wchar_t, char, mbstate_t>::do_encoding() const noexcept
 {
     if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0)
         return -1;
 
     // stateless encoding
     if (__l == 0 || __libcpp_mb_cur_max_l(__l) == 1)  // there are no known constant length encodings
         return 1;                // which take more than 1 char to form a wchar_t
     return 0;
 }
 
 bool
-codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t)
             frm += n;
             break;
         }
     }
     return nbytes;
 }
 
 int
-codecvt<wchar_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
+codecvt<wchar_t, char, mbstate_t>::do_max_length() const noexcept
 {
     return __l == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l));
 }
 
 //                                     Valid UTF ranges
 //     UTF-32               UTF-16                          UTF-8               # of code points
 //                     first      second       first   second    third   fourth
 // 000000 - 00007F  0000 - 007F               00 - 7F                                 127

 codecvt<char16_t, char, mbstate_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-codecvt<char16_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
+codecvt<char16_t, char, mbstate_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-codecvt<char16_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+codecvt<char16_t, char, mbstate_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 codecvt<char16_t, char, mbstate_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_utf16_length(_frm, _frm_end, mx);
 }
 
 int
-codecvt<char16_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
+codecvt<char16_t, char, mbstate_t>::do_max_length() const noexcept
 {
     return 4;
 }
 
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
 
 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 

 codecvt<char16_t, char8_t, mbstate_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-codecvt<char16_t, char8_t, mbstate_t>::do_encoding() const  _NOEXCEPT
+codecvt<char16_t, char8_t, mbstate_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-codecvt<char16_t, char8_t, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+codecvt<char16_t, char8_t, mbstate_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 codecvt<char16_t, char8_t, mbstate_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_utf16_length(_frm, _frm_end, mx);
 }
 
 int
-codecvt<char16_t, char8_t, mbstate_t>::do_max_length() const  _NOEXCEPT
+codecvt<char16_t, char8_t, mbstate_t>::do_max_length() const noexcept
 {
     return 4;
 }
 
 #endif
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 

 codecvt<char32_t, char, mbstate_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-codecvt<char32_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
+codecvt<char32_t, char, mbstate_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-codecvt<char32_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+codecvt<char32_t, char, mbstate_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 codecvt<char32_t, char, mbstate_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_ucs4_length(_frm, _frm_end, mx);
 }
 
 int
-codecvt<char32_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
+codecvt<char32_t, char, mbstate_t>::do_max_length() const noexcept
 {
     return 4;
 }
 
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
 
 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 

 codecvt<char32_t, char8_t, mbstate_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-codecvt<char32_t, char8_t, mbstate_t>::do_encoding() const  _NOEXCEPT
+codecvt<char32_t, char8_t, mbstate_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-codecvt<char32_t, char8_t, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+codecvt<char32_t, char8_t, mbstate_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 codecvt<char32_t, char8_t, mbstate_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_ucs4_length(_frm, _frm_end, mx);
 }
 
 int
-codecvt<char32_t, char8_t, mbstate_t>::do_max_length() const  _NOEXCEPT
+codecvt<char32_t, char8_t, mbstate_t>::do_max_length() const noexcept
 {
     return 4;
 }
 
 #endif
 
 // __codecvt_utf8<wchar_t>
 

 __codecvt_utf8<wchar_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf8<wchar_t>::do_encoding() const  _NOEXCEPT
+__codecvt_utf8<wchar_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf8<wchar_t>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf8<wchar_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf8<wchar_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf8<wchar_t>::do_max_length() const  _NOEXCEPT
+__codecvt_utf8<wchar_t>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 7;
     return 4;
 }
 
 // __codecvt_utf8<char16_t>
 

 __codecvt_utf8<char16_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf8<char16_t>::do_encoding() const  _NOEXCEPT
+__codecvt_utf8<char16_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf8<char16_t>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf8<char16_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf8<char16_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf8<char16_t>::do_max_length() const  _NOEXCEPT
+__codecvt_utf8<char16_t>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 6;
     return 3;
 }
 
 // __codecvt_utf8<char32_t>
 

 __codecvt_utf8<char32_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf8<char32_t>::do_encoding() const  _NOEXCEPT
+__codecvt_utf8<char32_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf8<char32_t>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf8<char32_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf8<char32_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf8<char32_t>::do_max_length() const  _NOEXCEPT
+__codecvt_utf8<char32_t>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 7;
     return 4;
 }
 
 // __codecvt_utf16<wchar_t, false>
 

 __codecvt_utf16<wchar_t, false>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf16<wchar_t, false>::do_encoding() const  _NOEXCEPT
+__codecvt_utf16<wchar_t, false>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf16<wchar_t, false>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf16<wchar_t, false>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf16<wchar_t, false>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf16<wchar_t, false>::do_max_length() const  _NOEXCEPT
+__codecvt_utf16<wchar_t, false>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 6;
     return 4;
 }
 
 // __codecvt_utf16<wchar_t, true>
 

 __codecvt_utf16<wchar_t, true>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf16<wchar_t, true>::do_encoding() const  _NOEXCEPT
+__codecvt_utf16<wchar_t, true>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf16<wchar_t, true>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf16<wchar_t, true>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf16<wchar_t, true>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf16<wchar_t, true>::do_max_length() const  _NOEXCEPT
+__codecvt_utf16<wchar_t, true>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 6;
     return 4;
 }
 
 // __codecvt_utf16<char16_t, false>
 

 __codecvt_utf16<char16_t, false>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf16<char16_t, false>::do_encoding() const  _NOEXCEPT
+__codecvt_utf16<char16_t, false>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf16<char16_t, false>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf16<char16_t, false>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf16<char16_t, false>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf16be_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf16<char16_t, false>::do_max_length() const  _NOEXCEPT
+__codecvt_utf16<char16_t, false>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 4;
     return 2;
 }
 
 // __codecvt_utf16<char16_t, true>
 

 __codecvt_utf16<char16_t, true>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf16<char16_t, true>::do_encoding() const  _NOEXCEPT
+__codecvt_utf16<char16_t, true>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf16<char16_t, true>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf16<char16_t, true>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf16<char16_t, true>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf16le_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf16<char16_t, true>::do_max_length() const  _NOEXCEPT
+__codecvt_utf16<char16_t, true>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 4;
     return 2;
 }
 
 // __codecvt_utf16<char32_t, false>
 

 __codecvt_utf16<char32_t, false>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf16<char32_t, false>::do_encoding() const  _NOEXCEPT
+__codecvt_utf16<char32_t, false>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf16<char32_t, false>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf16<char32_t, false>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf16<char32_t, false>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf16<char32_t, false>::do_max_length() const  _NOEXCEPT
+__codecvt_utf16<char32_t, false>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 6;
     return 4;
 }
 
 // __codecvt_utf16<char32_t, true>
 

 __codecvt_utf16<char32_t, true>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf16<char32_t, true>::do_encoding() const  _NOEXCEPT
+__codecvt_utf16<char32_t, true>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf16<char32_t, true>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf16<char32_t, true>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf16<char32_t, true>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf16<char32_t, true>::do_max_length() const  _NOEXCEPT
+__codecvt_utf16<char32_t, true>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 6;
     return 4;
 }
 
 // __codecvt_utf8_utf16<wchar_t>
 

 __codecvt_utf8_utf16<wchar_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf8_utf16<wchar_t>::do_encoding() const  _NOEXCEPT
+__codecvt_utf8_utf16<wchar_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf8_utf16<wchar_t>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf8_utf16<wchar_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf8_utf16<wchar_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf8_utf16<wchar_t>::do_max_length() const  _NOEXCEPT
+__codecvt_utf8_utf16<wchar_t>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 7;
     return 4;
 }
 
 // __codecvt_utf8_utf16<char16_t>
 

 __codecvt_utf8_utf16<char16_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf8_utf16<char16_t>::do_encoding() const  _NOEXCEPT
+__codecvt_utf8_utf16<char16_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf8_utf16<char16_t>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf8_utf16<char16_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf8_utf16<char16_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf8_utf16<char16_t>::do_max_length() const  _NOEXCEPT
+__codecvt_utf8_utf16<char16_t>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 7;
     return 4;
 }
 
 // __codecvt_utf8_utf16<char32_t>
 

 __codecvt_utf8_utf16<char32_t>::do_unshift(state_type&,
     extern_type* to, extern_type*, extern_type*& to_nxt) const
 {
     to_nxt = to;
     return noconv;
 }
 
 int
-__codecvt_utf8_utf16<char32_t>::do_encoding() const  _NOEXCEPT
+__codecvt_utf8_utf16<char32_t>::do_encoding() const noexcept
 {
     return 0;
 }
 
 bool
-__codecvt_utf8_utf16<char32_t>::do_always_noconv() const  _NOEXCEPT
+__codecvt_utf8_utf16<char32_t>::do_always_noconv() const noexcept
 {
     return false;
 }
 
 int
 __codecvt_utf8_utf16<char32_t>::do_length(state_type&,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
     const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
     const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
     return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
 }
 
 int
-__codecvt_utf8_utf16<char32_t>::do_max_length() const  _NOEXCEPT
+__codecvt_utf8_utf16<char32_t>::do_max_length() const noexcept
 {
     if (_Mode_ & consume_header)
         return 7;
     return 4;
 }
 
 // __narrow_to_utf8<16>
 

libcxx/src/memory.cpp

 #endif
 #endif
 #include "include/atomic_support.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 const allocator_arg_t allocator_arg = allocator_arg_t();
 
-bad_weak_ptr::~bad_weak_ptr() _NOEXCEPT {}
+bad_weak_ptr::~bad_weak_ptr() noexcept {}
 
 const char*
-bad_weak_ptr::what() const _NOEXCEPT
+bad_weak_ptr::what() const noexcept
 {
     return "bad_weak_ptr";
 }
 
 __shared_count::~__shared_count()
 {
 }
 
 __shared_weak_count::~__shared_weak_count()
 {
 }
 
 #if defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
 void
-__shared_count::__add_shared() _NOEXCEPT
+__shared_count::__add_shared() noexcept
 {
     __libcpp_atomic_refcount_increment(__shared_owners_);
 }
 
 bool
-__shared_count::__release_shared() _NOEXCEPT
+__shared_count::__release_shared() noexcept
 {
     if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1)
     {
         __on_zero_shared();
         return true;
     }
     return false;
 }
 
 void
-__shared_weak_count::__add_shared() _NOEXCEPT
+__shared_weak_count::__add_shared() noexcept
 {
     __shared_count::__add_shared();
 }
 
 void
-__shared_weak_count::__add_weak() _NOEXCEPT
+__shared_weak_count::__add_weak() noexcept
 {
     __libcpp_atomic_refcount_increment(__shared_weak_owners_);
 }
 
 void
-__shared_weak_count::__release_shared() _NOEXCEPT
+__shared_weak_count::__release_shared() noexcept
 {
     if (__shared_count::__release_shared())
         __release_weak();
 }
 
 #endif // _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
 
 void
-__shared_weak_count::__release_weak() _NOEXCEPT
+__shared_weak_count::__release_weak() noexcept
 {
     // NOTE: The acquire load here is an optimization of the very
     // common case where a shared pointer is being destructed while
     // having no other contended references.
     //
     // BENEFIT: We avoid expensive atomic stores like XADD and STREX
     // in a common case.  Those instructions are slow and do nasty
     // things to caches.
if (__libcpp_atomic_load(&__shared_weak_owners_, _AO_Acquire) == 0)
         //__libcpp_atomic_store(&__shared_weak_owners_, -1, _AO_Release);
         __on_zero_shared_weak();
     }
     else if (__libcpp_atomic_refcount_decrement(__shared_weak_owners_) == -1)
         __on_zero_shared_weak();
 }
 
 __shared_weak_count*
-__shared_weak_count::lock() _NOEXCEPT
+__shared_weak_count::lock() noexcept
 {
     long object_owners = __libcpp_atomic_load(&__shared_owners_);
     while (object_owners != -1)
     {
         if (__libcpp_atomic_compare_exchange(&__shared_owners_,
                                              &object_owners,
                                              object_owners+1))
             return this;
     }
     return nullptr;
 }
 
 const void*
-__shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT
+__shared_weak_count::__get_deleter(const type_info&) const noexcept
 {
     return nullptr;
 }
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 _LIBCPP_SAFE_STATIC static const std::size_t __sp_mut_count = 16;
 _LIBCPP_SAFE_STATIC static __libcpp_mutex_t mut_back[__sp_mut_count] =
 {
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER
 };
 
-_LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) _NOEXCEPT
+_LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) noexcept
    : __lx(p)
 {
 }
 
 void
-__sp_mut::lock() _NOEXCEPT
+__sp_mut::lock() noexcept
 {
     auto m = static_cast<__libcpp_mutex_t*>(__lx);
     unsigned count = 0;
     while (!__libcpp_mutex_trylock(m))
     {
         if (++count > 16)
         {
             __libcpp_mutex_lock(m);
             break;
         }
         this_thread::yield();
     }
 }
 
 void
-__sp_mut::unlock() _NOEXCEPT
+__sp_mut::unlock() noexcept
 {
     __libcpp_mutex_unlock(static_cast<__libcpp_mutex_t*>(__lx));
 }
 
 __sp_mut&
 __get_sp_mut(const void* p)
 {
     static __sp_mut muts[__sp_mut_count]

 }
 
 void
 undeclare_no_pointers(char*, size_t)
 {
 }
 
 #if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE)
-pointer_safety get_pointer_safety() _NOEXCEPT
+pointer_safety get_pointer_safety() noexcept
 {
     return pointer_safety::relaxed;
 }
 #endif
 
 void*
 __undeclare_reachable(void* p)
 {

libcxx/src/mutex.cpp

 mutex::lock()
 {
     int ec = __libcpp_mutex_lock(&__m_);
     if (ec)
         __throw_system_error(ec, "mutex lock failed");
 }
 
 bool
-mutex::try_lock() _NOEXCEPT
+mutex::try_lock() noexcept
 {
     return __libcpp_mutex_trylock(&__m_);
 }
 
 void
-mutex::unlock() _NOEXCEPT
+mutex::unlock() noexcept
 {
     int ec = __libcpp_mutex_unlock(&__m_);
     (void)ec;
     _LIBCPP_ASSERT(ec == 0, "call to mutex::unlock failed");
 }
 
 // recursive_mutex
 

 recursive_mutex::lock()
 {
     int ec = __libcpp_recursive_mutex_lock(&__m_);
     if (ec)
         __throw_system_error(ec, "recursive_mutex lock failed");
 }
 
 void
-recursive_mutex::unlock() _NOEXCEPT
+recursive_mutex::unlock() noexcept
 {
     int e = __libcpp_recursive_mutex_unlock(&__m_);
     (void)e;
     _LIBCPP_ASSERT(e == 0, "call to recursive_mutex::unlock() failed");
 }
 
 bool
-recursive_mutex::try_lock() _NOEXCEPT
+recursive_mutex::try_lock() noexcept
 {
     return __libcpp_recursive_mutex_trylock(&__m_);
 }
 
 // timed_mutex
 
 timed_mutex::timed_mutex()
     : __locked_(false)

 {
     unique_lock<mutex> lk(__m_);
     while (__locked_)
         __cv_.wait(lk);
     __locked_ = true;
 }
 
 bool
-timed_mutex::try_lock() _NOEXCEPT
+timed_mutex::try_lock() noexcept
 {
     unique_lock<mutex> lk(__m_, try_to_lock);
     if (lk.owns_lock() && !__locked_)
     {
         __locked_ = true;
         return true;
     }
     return false;
 }
 
 void
-timed_mutex::unlock() _NOEXCEPT
+timed_mutex::unlock() noexcept
 {
     lock_guard<mutex> _(__m_);
     __locked_ = false;
     __cv_.notify_one();
 }
 
 // recursive_timed_mutex
 
recursive_timed_mutex::lock()
     }
     while (__count_ != 0)
         __cv_.wait(lk);
     __count_ = 1;
     __id_ = id;
 }
 
 bool
-recursive_timed_mutex::try_lock() _NOEXCEPT
+recursive_timed_mutex::try_lock() noexcept
 {
     __thread_id id = this_thread::get_id();
     unique_lock<mutex> lk(__m_, try_to_lock);
     if (lk.owns_lock() && (__count_ == 0 || id == __id_))
     {
         if (__count_ == numeric_limits<size_t>::max())
             return false;
         ++__count_;
         __id_ = id;
         return true;
     }
     return false;
 }
 
 void
-recursive_timed_mutex::unlock() _NOEXCEPT
+recursive_timed_mutex::unlock() noexcept
 {
     unique_lock<mutex> lk(__m_);
     if (--__count_ == 0)
     {
         __id_.__reset();
         lk.unlock();
         __cv_.notify_one();
     }

libcxx/src/mutex_destructor.cpp

public:
     _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
     constexpr mutex() = default;
     mutex(const mutex&) = delete;
     mutex& operator=(const mutex&) = delete;
     ~mutex() noexcept;
 };
 
 
-mutex::~mutex() _NOEXCEPT
+mutex::~mutex() noexcept
 {
     __libcpp_mutex_destroy(&__m_);
 }
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/new.cpp

#else
             break;
 #endif
     }
     return p;
 }
 
 _LIBCPP_WEAK
 void*
-operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
+operator new(size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         p = ::operator new(size);
 #ifndef _LIBCPP_NO_EXCEPTIONS

 void*
 operator new[](size_t size) _THROW_BAD_ALLOC
 {
     return ::operator new(size);
 }
 
 _LIBCPP_WEAK
 void*
-operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
+operator new[](size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         p = ::operator new[](size);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return p;
 }
 
 _LIBCPP_WEAK
 void
-operator delete(void* ptr) _NOEXCEPT
+operator delete(void* ptr) noexcept
 {
     ::free(ptr);
 }
 
 _LIBCPP_WEAK
 void
-operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
+operator delete(void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr);
 }
 
 _LIBCPP_WEAK
 void
-operator delete(void* ptr, size_t) _NOEXCEPT
+operator delete(void* ptr, size_t) noexcept
 {
     ::operator delete(ptr);
 }
 
 _LIBCPP_WEAK
 void
-operator delete[] (void* ptr) _NOEXCEPT
+operator delete[] (void* ptr) noexcept
 {
     ::operator delete(ptr);
 }
 
 _LIBCPP_WEAK
 void
-operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
+operator delete[] (void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr);
 }
 
 _LIBCPP_WEAK
 void
-operator delete[] (void* ptr, size_t) _NOEXCEPT
+operator delete[] (void* ptr, size_t) noexcept
 {
     ::operator delete[](ptr);
 }
 
 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
 
 _LIBCPP_WEAK
 void *

 #endif
         }
     }
     return p;
 }
 
 _LIBCPP_WEAK
 void*
-operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         p = ::operator new(size, alignment);
 #ifndef _LIBCPP_NO_EXCEPTIONS

 void*
 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
     return ::operator new(size, alignment);
 }
 
 _LIBCPP_WEAK
 void*
-operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         p = ::operator new[](size, alignment);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return p;
 }
 
 _LIBCPP_WEAK
 void
-operator delete(void* ptr, std::align_val_t) _NOEXCEPT
+operator delete(void* ptr, std::align_val_t) noexcept
 {
     std::__libcpp_aligned_free(ptr);
 }
 
 _LIBCPP_WEAK
 void
-operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
 _LIBCPP_WEAK
 void
-operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
+operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
 _LIBCPP_WEAK
 void
-operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
+operator delete[] (void* ptr, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
 _LIBCPP_WEAK
 void
-operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
 
 _LIBCPP_WEAK
 void
-operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
+operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
 
 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
 #endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS

libcxx/src/optional.cpp

 //===------------------------ optional.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "optional"
 #include "__availability"
 
 namespace std
 {
 
-bad_optional_access::~bad_optional_access() _NOEXCEPT = default;
+bad_optional_access::~bad_optional_access() noexcept = default;
 
-const char* bad_optional_access::what() const _NOEXCEPT {
+const char* bad_optional_access::what() const noexcept {
   return "bad_optional_access";
   }
 
 } // std
 
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::bad_optional_access for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
     : public std::logic_error
 {
 public:
   bad_optional_access() : std::logic_error("Bad optional Access") {}
 
 //  Get the key function ~bad_optional_access() into the dylib
-    virtual ~bad_optional_access() _NOEXCEPT;
+    virtual ~bad_optional_access() noexcept;
 };
 
-bad_optional_access::~bad_optional_access() _NOEXCEPT = default;
+bad_optional_access::~bad_optional_access() noexcept = default;
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL

libcxx/src/random.cpp

random_device::operator()()
     return r;
 }
 
 #else
 #error "Random device not implemented for this architecture"
 #endif
 
 double
-random_device::entropy() const _NOEXCEPT
+random_device::entropy() const noexcept
 {
 #if defined(_LIBCPP_USING_DEV_RANDOM) && defined(RNDGETENTCNT)
   int ent;
   if (::ioctl(__f_, RNDGETENTCNT, &ent) < 0)
     return 0;
 
   if (ent < 0)
     return 0;

libcxx/src/support/runtime/exception_fallback.ipp

 namespace std {
 
 _LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler;
 _LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
 
 
 // libcxxrt provides implementations of these functions itself.
 unexpected_handler
-set_unexpected(unexpected_handler func) _NOEXCEPT
+set_unexpected(unexpected_handler func) noexcept
 {
   return __libcpp_atomic_exchange(&__unexpected_handler, func);
 }
 
 unexpected_handler
-get_unexpected() _NOEXCEPT
+get_unexpected() noexcept
 {
   return __libcpp_atomic_load(&__unexpected_handler);
 
 }
 
 _LIBCPP_NORETURN
 void unexpected()
 {
     (*get_unexpected())();
     // unexpected handler should not return
     terminate();
 }
 
 terminate_handler
-set_terminate(terminate_handler func) _NOEXCEPT
+set_terminate(terminate_handler func) noexcept
 {
   return __libcpp_atomic_exchange(&__terminate_handler, func);
 }
 
 terminate_handler
-get_terminate() _NOEXCEPT
+get_terminate() noexcept
 {
   return __libcpp_atomic_load(&__terminate_handler);
 }
 
 _LIBCPP_NORETURN
 void
-terminate() _NOEXCEPT
+terminate() noexcept
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         (*get_terminate())();
         // handler should not return
         fprintf(stderr, "terminate_handler unexpectedly returned\n");
         ::abort();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
         fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
         ::abort();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
+bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
 
-int uncaught_exceptions() _NOEXCEPT
+int uncaught_exceptions() noexcept
 {
 #warning uncaught_exception not yet implemented
   fprintf(stderr, "uncaught_exceptions not yet implemented\n");
   ::abort();
 }
 
 
-exception::~exception() _NOEXCEPT
+exception::~exception() noexcept
 {
 }
 
-const char* exception::what() const _NOEXCEPT
+const char* exception::what() const noexcept
 {
   return "std::exception";
 }
 
-bad_exception::~bad_exception() _NOEXCEPT
+bad_exception::~bad_exception() noexcept
 {
 }
 
-const char* bad_exception::what() const _NOEXCEPT
+const char* bad_exception::what() const noexcept
 {
   return "std::bad_exception";
 }
 
 
-bad_alloc::bad_alloc() _NOEXCEPT
+bad_alloc::bad_alloc() noexcept
 {
 }
 
-bad_alloc::~bad_alloc() _NOEXCEPT
+bad_alloc::~bad_alloc() noexcept
 {
 }
 
 const char*
-bad_alloc::what() const _NOEXCEPT
+bad_alloc::what() const noexcept
 {
     return "std::bad_alloc";
 }
 
-bad_array_new_length::bad_array_new_length() _NOEXCEPT
+bad_array_new_length::bad_array_new_length() noexcept
 {
 }
 
-bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+bad_array_new_length::~bad_array_new_length() noexcept
 {
 }
 
 const char*
-bad_array_new_length::what() const _NOEXCEPT
+bad_array_new_length::what() const noexcept
 {
     return "bad_array_new_length";
 }
 
-bad_cast::bad_cast() _NOEXCEPT
+bad_cast::bad_cast() noexcept
 {
 }
 
-bad_typeid::bad_typeid() _NOEXCEPT
+bad_typeid::bad_typeid() noexcept
 {
 }
 
-bad_cast::~bad_cast() _NOEXCEPT
+bad_cast::~bad_cast() noexcept
 {
 }
 
 const char*
-bad_cast::what() const _NOEXCEPT
+bad_cast::what() const noexcept
 {
   return "std::bad_cast";
 }
 
-bad_typeid::~bad_typeid() _NOEXCEPT
+bad_typeid::~bad_typeid() noexcept
 {
 }
 
 const char*
-bad_typeid::what() const _NOEXCEPT
+bad_typeid::what() const noexcept
 {
   return "std::bad_typeid";
 }
 
 } // namespace std

libcxx/src/support/runtime/exception_glibcxx.ipp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __GLIBCXX__
 #error header can only be used when targeting libstdc++ or libsupc++
 #endif
 
 namespace std {
 
-bad_alloc::bad_alloc() _NOEXCEPT
+bad_alloc::bad_alloc() noexcept
 {
 }
 
-bad_array_new_length::bad_array_new_length() _NOEXCEPT
+bad_array_new_length::bad_array_new_length() noexcept
 {
 }
 
-bad_cast::bad_cast() _NOEXCEPT
+bad_cast::bad_cast() noexcept
 {
 }
 
-bad_typeid::bad_typeid() _NOEXCEPT
+bad_typeid::bad_typeid() noexcept
 {
 }
 
 } // namespace std

libcxx/src/support/runtime/exception_libcxxabi.ipp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPPABI_VERSION
 #error this header can only be used with libc++abi
 #endif
 
 namespace std {
 
-bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
+bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
 
-int uncaught_exceptions() _NOEXCEPT
+int uncaught_exceptions() noexcept
 {
 # if _LIBCPPABI_VERSION > 1001
     return __cxa_uncaught_exceptions();
 # else
     return __cxa_uncaught_exception() ? 1 : 0;
 # endif
 }
 
 } // namespace std

libcxx/src/support/runtime/exception_libcxxrt.ipp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIBCXXRT
 #error this header may only be used when targeting libcxxrt
 #endif
 
 namespace std {
 
-bad_exception::~bad_exception() _NOEXCEPT
+bad_exception::~bad_exception() noexcept
 {
 }
 
-const char* bad_exception::what() const _NOEXCEPT
+const char* bad_exception::what() const noexcept
 {
   return "std::bad_exception";
 }
 
 } // namespace std

libcxx/src/support/runtime/exception_msvc.ipp

 unexpected_handler __cdecl _get_unexpected();
 
 int __cdecl __uncaught_exceptions();
 }
 
 namespace std {
 
 unexpected_handler
-set_unexpected(unexpected_handler func) _NOEXCEPT {
+set_unexpected(unexpected_handler func) noexcept {
   return ::set_unexpected(func);
 }
 
-unexpected_handler get_unexpected() _NOEXCEPT {
+unexpected_handler get_unexpected() noexcept {
   return ::_get_unexpected();
 }
 
 _LIBCPP_NORETURN
 void unexpected() {
     (*get_unexpected())();
     // unexpected handler should not return
     terminate();
 }
 
-terminate_handler set_terminate(terminate_handler func) _NOEXCEPT {
+terminate_handler set_terminate(terminate_handler func) noexcept {
   return ::set_terminate(func);
 }
 
-terminate_handler get_terminate() _NOEXCEPT {
+terminate_handler get_terminate() noexcept {
   return ::_get_terminate();
 }
 
 _LIBCPP_NORETURN
-void terminate() _NOEXCEPT
+void terminate() noexcept
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         (*get_terminate())();
         // handler should not return
         fprintf(stderr, "terminate_handler unexpectedly returned\n");
         ::abort();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
         fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
         ::abort();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
-bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
+bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
 
-int uncaught_exceptions() _NOEXCEPT {
+int uncaught_exceptions() noexcept {
     return __uncaught_exceptions();
 }
 
 #if !defined(_LIBCPP_ABI_VCRUNTIME)
-bad_cast::bad_cast() _NOEXCEPT
+bad_cast::bad_cast() noexcept
 {
 }
 
-bad_cast::~bad_cast() _NOEXCEPT
+bad_cast::~bad_cast() noexcept
 {
 }
 
 const char *
-bad_cast::what() const _NOEXCEPT
+bad_cast::what() const noexcept
 {
   return "std::bad_cast";
 }
 
-bad_typeid::bad_typeid() _NOEXCEPT
+bad_typeid::bad_typeid() noexcept
 {
 }
 
-bad_typeid::~bad_typeid() _NOEXCEPT
+bad_typeid::~bad_typeid() noexcept
 {
 }
 
 const char *
-bad_typeid::what() const _NOEXCEPT
+bad_typeid::what() const noexcept
 {
   return "std::bad_typeid";
 }
 
-exception::~exception() _NOEXCEPT
+exception::~exception() noexcept
 {
 }
 
-const char* exception::what() const _NOEXCEPT
+const char* exception::what() const noexcept
 {
   return "std::exception";
 }
 
 
-bad_exception::~bad_exception() _NOEXCEPT
+bad_exception::~bad_exception() noexcept
 {
 }
 
-const char* bad_exception::what() const _NOEXCEPT
+const char* bad_exception::what() const noexcept
 {
   return "std::bad_exception";
 }
 
 
-bad_alloc::bad_alloc() _NOEXCEPT
+bad_alloc::bad_alloc() noexcept
 {
 }
 
-bad_alloc::~bad_alloc() _NOEXCEPT
+bad_alloc::~bad_alloc() noexcept
 {
 }
 
 const char*
-bad_alloc::what() const _NOEXCEPT
+bad_alloc::what() const noexcept
 {
     return "std::bad_alloc";
 }
 
-bad_array_new_length::bad_array_new_length() _NOEXCEPT
+bad_array_new_length::bad_array_new_length() noexcept
 {
 }
 
-bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+bad_array_new_length::~bad_array_new_length() noexcept
 {
 }
 
 const char*
-bad_array_new_length::what() const _NOEXCEPT
+bad_array_new_length::what() const noexcept
 {
     return "bad_array_new_length";
 }
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 } // namespace std

libcxx/src/support/runtime/exception_pointer_cxxabi.ipp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef HAVE_DEPENDENT_EH_ABI
 #error this header may only be used with libc++abi or libcxxrt
 #endif
 
 namespace std {
 
-exception_ptr::~exception_ptr() _NOEXCEPT {
+exception_ptr::~exception_ptr() noexcept {
   __cxa_decrement_exception_refcount(__ptr_);
 }
 
-exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
+exception_ptr::exception_ptr(const exception_ptr& other) noexcept
     : __ptr_(other.__ptr_)
 {
     __cxa_increment_exception_refcount(__ptr_);
 }
 
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
 {
     if (__ptr_ != other.__ptr_)
     {
         __cxa_increment_exception_refcount(other.__ptr_);
         __cxa_decrement_exception_refcount(__ptr_);
         __ptr_ = other.__ptr_;
     }
     return *this;
 }
 
-nested_exception::nested_exception() _NOEXCEPT
+nested_exception::nested_exception() noexcept
     : __ptr_(current_exception())
 {
 }
 
-nested_exception::~nested_exception() _NOEXCEPT
+nested_exception::~nested_exception() noexcept
 {
 }
 
 _LIBCPP_NORETURN
 void
 nested_exception::rethrow_nested() const
 {
     if (__ptr_ == nullptr)
         terminate();
     rethrow_exception(__ptr_);
 }
 
-exception_ptr current_exception() _NOEXCEPT
+exception_ptr current_exception() noexcept
 {
     // be nicer if there was a constructor that took a ptr, then
     // this whole function would be just:
     //    return exception_ptr(__cxa_current_primary_exception());
     exception_ptr ptr;
     ptr.__ptr_ = __cxa_current_primary_exception();
     return ptr;
 }

libcxx/src/support/runtime/exception_pointer_glibcxx.ipp

 
 namespace __exception_ptr
 {
 
 struct exception_ptr
 {
     void* __ptr_;
 
-    exception_ptr(const exception_ptr&) _NOEXCEPT;
-    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
-    ~exception_ptr() _NOEXCEPT;
+    exception_ptr(const exception_ptr&) noexcept;
+    exception_ptr& operator=(const exception_ptr&) noexcept;
+    ~exception_ptr() noexcept;
 };
 
 }
 
 _LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
 
-exception_ptr::~exception_ptr() _NOEXCEPT
+exception_ptr::~exception_ptr() noexcept
 {
     reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
 }
 
-exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
+exception_ptr::exception_ptr(const exception_ptr& other) noexcept
     : __ptr_(other.__ptr_)
 {
     new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
         reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
 }
 
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
 {
     *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
         reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
     return *this;
 }
 
-nested_exception::nested_exception() _NOEXCEPT
+nested_exception::nested_exception() noexcept
     : __ptr_(current_exception())
 {
 }
 
 
 _LIBCPP_NORETURN
 void
 nested_exception::rethrow_nested() const

libcxx/src/support/runtime/exception_pointer_msvc.ipp

 _LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrSwap(void*, void*);
 _LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrCurrentException(void*);
 [[noreturn]] _LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrRethrow(const void*);
 _LIBCPP_CRT_FUNC void __cdecl
 __ExceptionPtrCopyException(void*, const void*, const void*);
 
 namespace std {
 
-exception_ptr::exception_ptr() _NOEXCEPT { __ExceptionPtrCreate(this); }
-exception_ptr::exception_ptr(nullptr_t) _NOEXCEPT { __ExceptionPtrCreate(this); }
+exception_ptr::exception_ptr() noexcept { __ExceptionPtrCreate(this); }
+exception_ptr::exception_ptr(nullptr_t) noexcept { __ExceptionPtrCreate(this); }
 
-exception_ptr::exception_ptr(const exception_ptr& __other) _NOEXCEPT {
+exception_ptr::exception_ptr(const exception_ptr& __other) noexcept {
   __ExceptionPtrCopy(this, &__other);
 }
-exception_ptr& exception_ptr::operator=(const exception_ptr& __other) _NOEXCEPT {
+exception_ptr& exception_ptr::operator=(const exception_ptr& __other) noexcept {
   __ExceptionPtrAssign(this, &__other);
   return *this;
 }
 
-exception_ptr& exception_ptr::operator=(nullptr_t) _NOEXCEPT {
+exception_ptr& exception_ptr::operator=(nullptr_t) noexcept {
   exception_ptr dummy;
   __ExceptionPtrAssign(this, &dummy);
   return *this;
 }
 
-exception_ptr::~exception_ptr() _NOEXCEPT { __ExceptionPtrDestroy(this); }
+exception_ptr::~exception_ptr() noexcept { __ExceptionPtrDestroy(this); }
 
-exception_ptr::operator bool() const _NOEXCEPT {
+exception_ptr::operator bool() const noexcept {
   return __ExceptionPtrToBool(this);
 }
 
-bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT {
+bool operator==(const exception_ptr& __x, const exception_ptr& __y) noexcept {
   return __ExceptionPtrCompare(&__x, &__y);
 }
 
 
-void swap(exception_ptr& lhs, exception_ptr& rhs) _NOEXCEPT {
+void swap(exception_ptr& lhs, exception_ptr& rhs) noexcept {
   __ExceptionPtrSwap(&rhs, &lhs);
 }
 
 exception_ptr __copy_exception_ptr(void* __except, const void* __ptr) {
   exception_ptr __ret = nullptr;
   if (__ptr)
     __ExceptionPtrCopyException(&__ret, __except, __ptr);
   return __ret;
 }
 
-exception_ptr current_exception() _NOEXCEPT {
+exception_ptr current_exception() noexcept {
   exception_ptr __ret;
   __ExceptionPtrCurrentException(&__ret);
   return __ret;
 }
 
 _LIBCPP_NORETURN
 void rethrow_exception(exception_ptr p) { __ExceptionPtrRethrow(&p); }
 
-nested_exception::nested_exception() _NOEXCEPT : __ptr_(current_exception()) {}
+nested_exception::nested_exception() noexcept : __ptr_(current_exception()) {}
 
-nested_exception::~nested_exception() _NOEXCEPT {}
+nested_exception::~nested_exception() noexcept {}
 
 _LIBCPP_NORETURN
 void nested_exception::rethrow_nested() const {
   if (__ptr_ == nullptr)
     terminate();
   rethrow_exception(__ptr_);
 }
 
 } // namespace std

libcxx/src/support/runtime/exception_pointer_unimplemented.ipp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 #include <stdlib.h>
 
 namespace std {
 
-exception_ptr::~exception_ptr() _NOEXCEPT
+exception_ptr::~exception_ptr() noexcept
 {
 #  warning exception_ptr not yet implemented
   fprintf(stderr, "exception_ptr not yet implemented\n");
   ::abort();
 }
 
-exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
+exception_ptr::exception_ptr(const exception_ptr& other) noexcept
     : __ptr_(other.__ptr_)
 {
 #  warning exception_ptr not yet implemented
   fprintf(stderr, "exception_ptr not yet implemented\n");
   ::abort();
 }
 
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
 {
 #  warning exception_ptr not yet implemented
   fprintf(stderr, "exception_ptr not yet implemented\n");
   ::abort();
 }
 
-nested_exception::nested_exception() _NOEXCEPT
+nested_exception::nested_exception() noexcept
     : __ptr_(current_exception())
 {
 }
 
 #if !defined(__GLIBCXX__)
 
-nested_exception::~nested_exception() _NOEXCEPT
+nested_exception::~nested_exception() noexcept
 {
 }
 
 #endif
 
 _LIBCPP_NORETURN
 void
 nested_exception::rethrow_nested() const
 {
 #  warning exception_ptr not yet implemented
   fprintf(stderr, "exception_ptr not yet implemented\n");
   ::abort();
 #if 0
   if (__ptr_ == nullptr)
       terminate();
   rethrow_exception(__ptr_);
 #endif // FIXME
 }
 
-exception_ptr current_exception() _NOEXCEPT
+exception_ptr current_exception() noexcept
 {
 #  warning exception_ptr not yet implemented
   fprintf(stderr, "exception_ptr not yet implemented\n");
   ::abort();
 }
 
 _LIBCPP_NORETURN
 void rethrow_exception(exception_ptr p)
 {
 #  warning exception_ptr not yet implemented
   fprintf(stderr, "exception_ptr not yet implemented\n");
   ::abort();
 }
 
 } // namespace std

libcxx/src/support/runtime/new_handler_fallback.ipp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 namespace std {
 
 _LIBCPP_SAFE_STATIC static std::new_handler __new_handler;
 
 new_handler
-set_new_handler(new_handler handler) _NOEXCEPT
+set_new_handler(new_handler handler) noexcept
 {
     return __libcpp_atomic_exchange(&__new_handler, handler);
 }
 
 new_handler
-get_new_handler() _NOEXCEPT
+get_new_handler() noexcept
 {
     return __libcpp_atomic_load(&__new_handler);
 }
 
 } // namespace std

libcxx/src/support/runtime/stdexcept_default.ipp

 
 namespace std // purposefully not using versioning namespace
 {
 
 logic_error::logic_error(const string& msg) : __imp_(msg.c_str()) {}
 
 logic_error::logic_error(const char* msg) : __imp_(msg) {}
 
-logic_error::logic_error(const logic_error& le) _NOEXCEPT : __imp_(le.__imp_) {}
+logic_error::logic_error(const logic_error& le) noexcept : __imp_(le.__imp_) {}
 
-logic_error& logic_error::operator=(const logic_error& le) _NOEXCEPT {
+logic_error& logic_error::operator=(const logic_error& le) noexcept {
   __imp_ = le.__imp_;
   return *this;
 }
 
 runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {}
 
 runtime_error::runtime_error(const char* msg) : __imp_(msg) {}
 
-runtime_error::runtime_error(const runtime_error& re) _NOEXCEPT
+runtime_error::runtime_error(const runtime_error& re) noexcept
     : __imp_(re.__imp_) {}
 
-runtime_error& runtime_error::operator=(const runtime_error& re) _NOEXCEPT {
+runtime_error& runtime_error::operator=(const runtime_error& re) noexcept {
   __imp_ = re.__imp_;
   return *this;
 }
 
 #if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
 
-const char* logic_error::what() const _NOEXCEPT { return __imp_.c_str(); }
+const char* logic_error::what() const noexcept { return __imp_.c_str(); }
 
-const char* runtime_error::what() const _NOEXCEPT { return __imp_.c_str(); }
+const char* runtime_error::what() const noexcept { return __imp_.c_str(); }
 
-logic_error::~logic_error() _NOEXCEPT {}
-domain_error::~domain_error() _NOEXCEPT {}
-invalid_argument::~invalid_argument() _NOEXCEPT {}
-length_error::~length_error() _NOEXCEPT {}
-out_of_range::~out_of_range() _NOEXCEPT {}
-
-runtime_error::~runtime_error() _NOEXCEPT {}
-range_error::~range_error() _NOEXCEPT {}
-overflow_error::~overflow_error() _NOEXCEPT {}
-underflow_error::~underflow_error() _NOEXCEPT {}
+logic_error::~logic_error() noexcept {}
+domain_error::~domain_error() noexcept {}
+invalid_argument::~invalid_argument() noexcept {}
+length_error::~length_error() noexcept {}
+out_of_range::~out_of_range() noexcept {}
+
+runtime_error::~runtime_error() noexcept {}
+range_error::~range_error() noexcept {}
+overflow_error::~overflow_error() noexcept {}
+underflow_error::~underflow_error() noexcept {}
 
 #endif
 
 } // namespace std

libcxx/src/system_error.cpp

 #include <android/api-level.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // class error_category
 
 #if defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
-error_category::error_category() _NOEXCEPT
+error_category::error_category() noexcept
 {
 }
 #endif
 
-error_category::~error_category() _NOEXCEPT
+error_category::~error_category() noexcept
 {
 }
 
 error_condition
-error_category::default_error_condition(int ev) const _NOEXCEPT
+error_category::default_error_condition(int ev) const noexcept
 {
     return error_condition(ev, *this);
 }
 
 bool
-error_category::equivalent(int code, const error_condition& condition) const _NOEXCEPT
+error_category::equivalent(int code, const error_condition& condition) const noexcept
 {
     return default_error_condition(code) == condition;
 }
 
 bool
-error_category::equivalent(const error_code& code, int condition) const _NOEXCEPT
+error_category::equivalent(const error_code& code, int condition) const noexcept
 {
     return *this == code.category() && code.value() == condition;
 }
 
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 namespace {
 
 //  GLIBC also uses 1024 as the maximum buffer size internally.
#else
     return do_strerror_r(ev);
 #endif
 }
 
 class _LIBCPP_HIDDEN __generic_error_category
     : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const noexcept;
     virtual string message(int ev) const;
 };
 
 const char*
-__generic_error_category::name() const _NOEXCEPT
+__generic_error_category::name() const noexcept
 {
     return "generic";
 }
 
 string
 __generic_error_category::message(int ev) const
 {
 #ifdef _LIBCPP_ELAST
     if (ev > _LIBCPP_ELAST)
       return string("unspecified generic_category error");
 #endif  // _LIBCPP_ELAST
     return __do_message::message(ev);
 }
 
 const error_category&
-generic_category() _NOEXCEPT
+generic_category() noexcept
 {
     static __generic_error_category s;
     return s;
 }
 
 class _LIBCPP_HIDDEN __system_error_category
     : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const noexcept;
     virtual string message(int ev) const;
-    virtual error_condition default_error_condition(int ev) const _NOEXCEPT;
+    virtual error_condition default_error_condition(int ev) const noexcept;
 };
 
 const char*
-__system_error_category::name() const _NOEXCEPT
+__system_error_category::name() const noexcept
 {
     return "system";
 }
 
 string
 __system_error_category::message(int ev) const
 {
 #ifdef _LIBCPP_ELAST
     if (ev > _LIBCPP_ELAST)
       return string("unspecified system_category error");
 #endif  // _LIBCPP_ELAST
     return __do_message::message(ev);
 }
 
 error_condition
-__system_error_category::default_error_condition(int ev) const _NOEXCEPT
+__system_error_category::default_error_condition(int ev) const noexcept
 {
 #ifdef _LIBCPP_ELAST
     if (ev > _LIBCPP_ELAST)
       return error_condition(ev, system_category());
 #endif  // _LIBCPP_ELAST
     return error_condition(ev, generic_category());
 }
 
 const error_category&
-system_category() _NOEXCEPT
+system_category() noexcept
 {
     static __system_error_category s;
     return s;
 }
 
 // error_condition
 
 string

 }
 
 system_error::system_error(int ev, const error_category& ecat)
     : runtime_error(__init(error_code(ev, ecat), "")),
       __ec_(error_code(ev, ecat))
 {
 }
 
-system_error::~system_error() _NOEXCEPT
+system_error::~system_error() noexcept
 {
 }
 
 void
 __throw_system_error(int ev, const char* what_arg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw system_error(error_code(ev, system_category()), what_arg);
 #else
     (void)ev;
     (void)what_arg;
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/thread.cpp

if (!__libcpp_thread_isnull(&__t_))
             __t_ = _LIBCPP_NULL_THREAD;
     }
 
     if (ec)
         __throw_system_error(ec, "thread::detach failed");
 }
 
 unsigned
-thread::hardware_concurrency() _NOEXCEPT
+thread::hardware_concurrency() noexcept
 {
 #if defined(_SC_NPROCESSORS_ONLN)
     long result = sysconf(_SC_NPROCESSORS_ONLN);
     // sysconf returns -1 if the name is invalid, the option does not exist or
     // does not have a definite limit.
     // if sysconf returns some other negative number, we have no idea
     // what is going on. Default to something safe.
     if (result < 0)

libcxx/src/typeinfo.cpp

 //===------------------------- typeinfo.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "typeinfo"
 
 #if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_ABI_VCRUNTIME)
 #include <string.h>
 
-int std::type_info::__compare(const type_info &__rhs) const _NOEXCEPT {
+int std::type_info::__compare(const type_info &__rhs) const noexcept {
   if (&__data == &__rhs.__data)
     return 0;
   return strcmp(&__data.__decorated_name[1], &__rhs.__data.__decorated_name[1]);
 }
 
-const char *std::type_info::name() const _NOEXCEPT {
+const char *std::type_info::name() const noexcept {
   // TODO(compnerd) cache demangled &__data.__decorated_name[1]
   return &__data.__decorated_name[1];
 }
 
-size_t std::type_info::hash_code() const _NOEXCEPT {
+size_t std::type_info::hash_code() const noexcept {
 #if defined(_WIN64)
   constexpr size_t fnv_offset_basis = 14695981039346656037ull;
   constexpr size_t fnv_prime = 10995116282110ull;
 #else
   constexpr size_t fnv_offset_basis = 2166136261ull;
   constexpr size_t fnv_prime = 16777619ull;
 #endif
 

libcxxabi/src/cxa_default_handlers.cpp

 
 _LIBCXXABI_DATA_VIS
 _LIBCPP_SAFE_STATIC std::unexpected_handler __cxa_unexpected_handler = default_unexpected_handler;
 
 namespace std
 {
 
 unexpected_handler
-set_unexpected(unexpected_handler func) _NOEXCEPT
+set_unexpected(unexpected_handler func) noexcept
 {
     if (func == 0)
         func = default_unexpected_handler;
     return __libcpp_atomic_exchange(&__cxa_unexpected_handler, func,
                                     _AO_Acq_Rel);
 }
 
 terminate_handler
-set_terminate(terminate_handler func) _NOEXCEPT
+set_terminate(terminate_handler func) noexcept
 {
     if (func == 0)
         func = default_terminate_handler;
     return __libcpp_atomic_exchange(&__cxa_terminate_handler, func,
                                     _AO_Acq_Rel);
 }
 
 }

libcxxabi/src/cxa_handlers.h

 {
 
 _LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
 void
 __unexpected(unexpected_handler func);
 
 _LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
 void
-__terminate(terminate_handler func) _NOEXCEPT;
+__terminate(terminate_handler func) noexcept;
 
 }  // std
 
 extern "C"
 {
 
 _LIBCXXABI_DATA_VIS extern void (*__cxa_terminate_handler)();
 _LIBCXXABI_DATA_VIS extern void (*__cxa_unexpected_handler)();

libcxxabi/src/cxa_handlers.cpp

 #include "cxa_exception.h"
 #include "private_typeinfo.h"
 #include "include/atomic_support.h"
 
 namespace std
 {
 
 unexpected_handler
-get_unexpected() _NOEXCEPT
+get_unexpected() noexcept
 {
     return __libcpp_atomic_load(&__cxa_unexpected_handler, _AO_Acquire);
 }
 
 void
 __unexpected(unexpected_handler func)
 {
     func();
     // unexpected handler should not return
     abort_message("unexpected_handler unexpectedly returned");
 }
 
 __attribute__((noreturn))
 void
 unexpected()
 {
     __unexpected(get_unexpected());
 }
 
 terminate_handler
-get_terminate() _NOEXCEPT
+get_terminate() noexcept
 {
     return __libcpp_atomic_load(&__cxa_terminate_handler, _AO_Acquire);
 }
 
 void
-__terminate(terminate_handler func) _NOEXCEPT
+__terminate(terminate_handler func) noexcept
 {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
         func();
         // handler should not return
         abort_message("terminate_handler unexpectedly returned");
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
         abort_message("terminate_handler unexpectedly threw an exception");
     }
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
 }
 
 __attribute__((noreturn))
 void
-terminate() _NOEXCEPT
+terminate() noexcept
 {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     // If there might be an uncaught exception
     using namespace __cxxabiv1;
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
     if (globals)
     {
         __cxa_exception* exception_header = globals->caughtExceptions;
#endif
     __terminate(get_terminate());
 }
 
 extern "C" {
 new_handler __cxa_new_handler = 0;
 }
 
 new_handler
-set_new_handler(new_handler handler) _NOEXCEPT
+set_new_handler(new_handler handler) noexcept
 {
     return __libcpp_atomic_exchange(&__cxa_new_handler, handler, _AO_Acq_Rel);
 }
 
 new_handler
-get_new_handler() _NOEXCEPT
+get_new_handler() noexcept
 {
     return __libcpp_atomic_load(&__cxa_new_handler, _AO_Acquire);
 }
 
 }  // std

libcxxabi/src/stdlib_exception.cpp

 //===---------------------------- exception.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <new>
 #include <exception>
 
 namespace std
 {
 
 // exception
 
-exception::~exception() _NOEXCEPT
+exception::~exception() noexcept
 {
 }
 
-const char* exception::what() const _NOEXCEPT
+const char* exception::what() const noexcept
 {
   return "std::exception";
 }
 
 // bad_exception
 
-bad_exception::~bad_exception() _NOEXCEPT
+bad_exception::~bad_exception() noexcept
 {
 }
 
-const char* bad_exception::what() const _NOEXCEPT
+const char* bad_exception::what() const noexcept
 {
   return "std::bad_exception";
 }
 
 
 //  bad_alloc
 
-bad_alloc::bad_alloc() _NOEXCEPT
+bad_alloc::bad_alloc() noexcept
 {
 }
 
-bad_alloc::~bad_alloc() _NOEXCEPT
+bad_alloc::~bad_alloc() noexcept
 {
 }
 
 const char*
-bad_alloc::what() const _NOEXCEPT
+bad_alloc::what() const noexcept
 {
     return "std::bad_alloc";
 }
 
 // bad_array_new_length
 
-bad_array_new_length::bad_array_new_length() _NOEXCEPT
+bad_array_new_length::bad_array_new_length() noexcept
 {
 }
 
-bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+bad_array_new_length::~bad_array_new_length() noexcept
 {
 }
 
 const char*
-bad_array_new_length::what() const _NOEXCEPT
+bad_array_new_length::what() const noexcept
 {
     return "bad_array_new_length";
 }
 
 }  // std

libcxxabi/src/stdlib_new_delete.cpp

 //===--------------------- stdlib_new_delete.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //
 // This file implements the new and delete operators.
 //===----------------------------------------------------------------------===//
 
 #include "__cxxabi_config.h"
 #include <new>
 #include <cstdlib>
 
-#if !defined(_THROW_BAD_ALLOC) || !defined(_NOEXCEPT) || !defined(_LIBCXXABI_WEAK)
-#error The _THROW_BAD_ALLOC, _NOEXCEPT, and _LIBCXXABI_WEAK libc++ macros must \
+#if !defined(_THROW_BAD_ALLOC) || !defined(_LIBCXXABI_WEAK)
+#error The _THROW_BAD_ALLOC and _LIBCXXABI_WEAK libc++ macros must \
        already be defined by libc++.
 #endif
 // Implement all new and delete operators as weak definitions
 // in this shared library, so that they can be overridden by programs
 // that define non-weak copies of the functions.
 
 _LIBCXXABI_WEAK
 void *
#else
             break;
 #endif
     }
     return p;
 }
 
 _LIBCXXABI_WEAK
 void*
-operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
+operator new(size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
         p = ::operator new(size);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS

 void*
 operator new[](size_t size) _THROW_BAD_ALLOC
 {
     return ::operator new(size);
 }
 
 _LIBCXXABI_WEAK
 void*
-operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
+operator new[](size_t size, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
         p = ::operator new[](size);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
     return p;
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete(void* ptr) _NOEXCEPT
+operator delete(void* ptr) noexcept
 {
     ::free(ptr);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
+operator delete(void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete(void* ptr, size_t) _NOEXCEPT
+operator delete(void* ptr, size_t) noexcept
 {
     ::operator delete(ptr);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete[] (void* ptr) _NOEXCEPT
+operator delete[] (void* ptr) noexcept
 {
     ::operator delete(ptr);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
+operator delete[] (void* ptr, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete[] (void* ptr, size_t) _NOEXCEPT
+operator delete[] (void* ptr, size_t) noexcept
 {
     ::operator delete[](ptr);
 }
 
 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
 
 _LIBCXXABI_WEAK
 void *

 #endif
         }
     }
     return p;
 }
 
 _LIBCXXABI_WEAK
 void*
-operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
         p = ::operator new(size, alignment);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS

 void*
 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 {
     return ::operator new(size, alignment);
 }
 
 _LIBCXXABI_WEAK
 void*
-operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     void* p = nullptr;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
         p = ::operator new[](size, alignment);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
     return p;
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete(void* ptr, std::align_val_t) _NOEXCEPT
+operator delete(void* ptr, std::align_val_t) noexcept
 {
     std::__libcpp_aligned_free(ptr);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
+operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
+operator delete[] (void* ptr, std::align_val_t alignment) noexcept
 {
     ::operator delete(ptr, alignment);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
+operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
 
 _LIBCXXABI_WEAK
 void
-operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
+operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
 {
     ::operator delete[](ptr, alignment);
 }
 
 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION

libcxxabi/src/stdlib_stdexcept.cpp

 // This includes an implementation file from libc++.
 #include "src/include/refstring.h"
 
 static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char *), "");
 
 namespace std  // purposefully not using versioning namespace
 {
 
-logic_error::~logic_error() _NOEXCEPT {}
+logic_error::~logic_error() noexcept {}
 
 const char*
-logic_error::what() const _NOEXCEPT
+logic_error::what() const noexcept
 {
     return __imp_.c_str();
 }
 
-runtime_error::~runtime_error() _NOEXCEPT {}
+runtime_error::~runtime_error() noexcept {}
 
 const char*
-runtime_error::what() const _NOEXCEPT
+runtime_error::what() const noexcept
 {
     return __imp_.c_str();
 }
 
-domain_error::~domain_error() _NOEXCEPT {}
-invalid_argument::~invalid_argument() _NOEXCEPT {}
-length_error::~length_error() _NOEXCEPT {}
-out_of_range::~out_of_range() _NOEXCEPT {}
-
-range_error::~range_error() _NOEXCEPT {}
-overflow_error::~overflow_error() _NOEXCEPT {}
-underflow_error::~underflow_error() _NOEXCEPT {}
+domain_error::~domain_error() noexcept {}
+invalid_argument::~invalid_argument() noexcept {}
+length_error::~length_error() noexcept {}
+out_of_range::~out_of_range() noexcept {}
+
+range_error::~range_error() noexcept {}
+overflow_error::~overflow_error() noexcept {}
+underflow_error::~underflow_error() noexcept {}
 
 }  // std

libcxxabi/src/stdlib_typeinfo.cpp

 // type_info
 
 type_info::~type_info()
 {
 }
 
 // bad_cast
 
-bad_cast::bad_cast() _NOEXCEPT
+bad_cast::bad_cast() noexcept
 {
 }
 
-bad_cast::~bad_cast() _NOEXCEPT
+bad_cast::~bad_cast() noexcept
 {
 }
 
 const char*
-bad_cast::what() const _NOEXCEPT
+bad_cast::what() const noexcept
 {
   return "std::bad_cast";
 }
 
 // bad_typeid
 
-bad_typeid::bad_typeid() _NOEXCEPT
+bad_typeid::bad_typeid() noexcept
 {
 }
 
-bad_typeid::~bad_typeid() _NOEXCEPT
+bad_typeid::~bad_typeid() noexcept
 {
 }
 
 const char*
-bad_typeid::what() const _NOEXCEPT
+bad_typeid::what() const noexcept
 {
   return "std::bad_typeid";
 }
 
 }  // std