Index: include/ext/throw_allocator.h =================================================================== --- include/ext/throw_allocator.h (revision 174912) +++ include/ext/throw_allocator.h (working copy) @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 +// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -618,14 +618,16 @@ public: size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return _M_allocator.max_size(); } pointer - address(reference __x) const { return std::__addressof(__x); } + address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } const_pointer - address(const_reference __x) const { return std::__addressof(__x); } + address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } pointer allocate(size_type __n, std::allocator::const_pointer hint = 0) @@ -699,14 +701,16 @@ struct rebind { typedef throw_allocator_limit<_Tp1> other; }; - throw_allocator_limit() throw() { } + throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { } - throw_allocator_limit(const throw_allocator_limit&) throw() { } + throw_allocator_limit(const throw_allocator_limit&) + _GLIBCXX_USE_NOEXCEPT { } template - throw_allocator_limit(const throw_allocator_limit<_Tp1>&) throw() { } + throw_allocator_limit(const throw_allocator_limit<_Tp1>&) + _GLIBCXX_USE_NOEXCEPT { } - ~throw_allocator_limit() throw() { } + ~throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { } }; /// Allocator throwing via random condition. @@ -718,14 +722,16 @@ struct rebind { typedef throw_allocator_random<_Tp1> other; }; - throw_allocator_random() throw() { } + throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { } - throw_allocator_random(const throw_allocator_random&) throw() { } + throw_allocator_random(const throw_allocator_random&) + _GLIBCXX_USE_NOEXCEPT { } template - throw_allocator_random(const throw_allocator_random<_Tp1>&) throw() { } + throw_allocator_random(const throw_allocator_random<_Tp1>&) + _GLIBCXX_USE_NOEXCEPT { } - ~throw_allocator_random() throw() { } + ~throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { } }; _GLIBCXX_END_NAMESPACE_VERSION Index: include/ext/pool_allocator.h =================================================================== --- include/ext/pool_allocator.h (revision 174912) +++ include/ext/pool_allocator.h (working copy) @@ -1,6 +1,7 @@ // Allocators -*- C++ -*- -// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, +// 2010, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -139,23 +140,25 @@ struct rebind { typedef __pool_alloc<_Tp1> other; }; - __pool_alloc() throw() { } + __pool_alloc() _GLIBCXX_USE_NOEXCEPT { } - __pool_alloc(const __pool_alloc&) throw() { } + __pool_alloc(const __pool_alloc&) _GLIBCXX_USE_NOEXCEPT { } template - __pool_alloc(const __pool_alloc<_Tp1>&) throw() { } + __pool_alloc(const __pool_alloc<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { } - ~__pool_alloc() throw() { } + ~__pool_alloc() _GLIBCXX_USE_NOEXCEPT { } pointer - address(reference __x) const { return std::__addressof(__x); } + address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } const_pointer - address(const_reference __x) const { return std::__addressof(__x); } + address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_t(-1) / sizeof(_Tp); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ Index: include/ext/bitmap_allocator.h =================================================================== --- include/ext/bitmap_allocator.h (revision 174912) +++ include/ext/bitmap_allocator.h (working copy) @@ -997,17 +997,17 @@ } public: - bitmap_allocator() throw() + bitmap_allocator() _GLIBCXX_USE_NOEXCEPT { } - bitmap_allocator(const bitmap_allocator&) + bitmap_allocator(const bitmap_allocator&) _GLIBCXX_USE_NOEXCEPT { } template - bitmap_allocator(const bitmap_allocator<_Tp1>&) throw() + bitmap_allocator(const bitmap_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { } - ~bitmap_allocator() throw() + ~bitmap_allocator() _GLIBCXX_USE_NOEXCEPT { } pointer @@ -1042,15 +1042,15 @@ } pointer - address(reference __r) const + address(reference __r) const _GLIBCXX_NOEXCEPT { return std::__addressof(__r); } const_pointer - address(const_reference __r) const + address(const_reference __r) const _GLIBCXX_NOEXCEPT { return std::__addressof(__r); } size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_type(-1) / sizeof(value_type); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ Index: include/ext/new_allocator.h =================================================================== --- include/ext/new_allocator.h (revision 174912) +++ include/ext/new_allocator.h (working copy) @@ -66,20 +66,22 @@ struct rebind { typedef new_allocator<_Tp1> other; }; - new_allocator() throw() { } + new_allocator() _GLIBCXX_USE_NOEXCEPT { } - new_allocator(const new_allocator&) throw() { } + new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { } template - new_allocator(const new_allocator<_Tp1>&) throw() { } + new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { } - ~new_allocator() throw() { } + ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } pointer - address(reference __x) const { return std::__addressof(__x); } + address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } const_pointer - address(const_reference __x) const { return std::__addressof(__x); } + address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } // NB: __n is permitted to be 0. The C++ standard says nothing // about what the return value is when __n == 0. @@ -98,7 +100,7 @@ { ::operator delete(__p); } size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_t(-1) / sizeof(_Tp); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ Index: include/ext/malloc_allocator.h =================================================================== --- include/ext/malloc_allocator.h (revision 174912) +++ include/ext/malloc_allocator.h (working copy) @@ -1,6 +1,7 @@ // Allocator that wraps "C" malloc -*- C++ -*- -// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, +// 2010, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -66,20 +67,23 @@ struct rebind { typedef malloc_allocator<_Tp1> other; }; - malloc_allocator() throw() { } + malloc_allocator() _GLIBCXX_USE_NOEXCEPT { } - malloc_allocator(const malloc_allocator&) throw() { } + malloc_allocator(const malloc_allocator&) _GLIBCXX_USE_NOEXCEPT { } template - malloc_allocator(const malloc_allocator<_Tp1>&) throw() { } + malloc_allocator(const malloc_allocator<_Tp1>&) + _GLIBCXX_USE_NOEXCEPT { } - ~malloc_allocator() throw() { } + ~malloc_allocator() _GLIBCXX_USE_NOEXCEPT { } pointer - address(reference __x) const { return std::__addressof(__x); } + address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } const_pointer - address(const_reference __x) const { return std::__addressof(__x); } + address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } // NB: __n is permitted to be 0. The C++ standard says nothing // about what the return value is when __n == 0. @@ -101,7 +105,7 @@ { std::free(static_cast(__p)); } size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_t(-1) / sizeof(_Tp); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ Index: include/ext/array_allocator.h =================================================================== --- include/ext/array_allocator.h (revision 174912) +++ include/ext/array_allocator.h (working copy) @@ -1,6 +1,6 @@ // array allocator -*- C++ -*- -// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -57,10 +57,12 @@ typedef _Tp value_type; pointer - address(reference __x) const { return std::__addressof(__x); } + address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } const_pointer - address(const_reference __x) const { return std::__addressof(__x); } + address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } void deallocate(pointer, size_type) @@ -69,7 +71,7 @@ } size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_t(-1) / sizeof(_Tp); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ @@ -120,17 +122,18 @@ struct rebind { typedef array_allocator<_Tp1, _Array1> other; }; - array_allocator(array_type* __array = 0) throw() + array_allocator(array_type* __array = 0) _GLIBCXX_USE_NOEXCEPT : _M_array(__array), _M_used(size_type()) { } - array_allocator(const array_allocator& __o) throw() + array_allocator(const array_allocator& __o) _GLIBCXX_USE_NOEXCEPT : _M_array(__o._M_array), _M_used(__o._M_used) { } template - array_allocator(const array_allocator<_Tp1, _Array1>&) throw() + array_allocator(const array_allocator<_Tp1, _Array1>&) + _GLIBCXX_USE_NOEXCEPT : _M_array(0), _M_used(size_type()) { } - ~array_allocator() throw() { } + ~array_allocator() _GLIBCXX_USE_NOEXCEPT { } pointer allocate(size_type __n, const void* = 0) Index: include/ext/mt_allocator.h =================================================================== --- include/ext/mt_allocator.h (revision 174912) +++ include/ext/mt_allocator.h (working copy) @@ -1,6 +1,6 @@ // MT-optimized allocator -*- C++ -*- -// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -577,15 +577,15 @@ typedef _Tp value_type; pointer - address(reference __x) const + address(reference __x) const _GLIBCXX_NOEXCEPT { return std::__addressof(__x); } const_pointer - address(const_reference __x) const + address(const_reference __x) const _GLIBCXX_NOEXCEPT { return std::__addressof(__x); } size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_t(-1) / sizeof(_Tp); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ @@ -648,14 +648,14 @@ typedef __mt_alloc<_Tp1, pol_type> other; }; - __mt_alloc() throw() { } + __mt_alloc() _GLIBCXX_USE_NOEXCEPT { } - __mt_alloc(const __mt_alloc&) throw() { } + __mt_alloc(const __mt_alloc&) _GLIBCXX_USE_NOEXCEPT { } template - __mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) throw() { } + __mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) _GLIBCXX_USE_NOEXCEPT { } - ~__mt_alloc() throw() { } + ~__mt_alloc() _GLIBCXX_USE_NOEXCEPT { } pointer allocate(size_type __n, const void* = 0); Index: include/ext/extptr_allocator.h =================================================================== --- include/ext/extptr_allocator.h (revision 174912) +++ include/ext/extptr_allocator.h (working copy) @@ -72,23 +72,24 @@ struct rebind { typedef _ExtPtr_allocator<_Up> other; }; - _ExtPtr_allocator() throw() + _ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT : _M_real_alloc() { } - _ExtPtr_allocator(const _ExtPtr_allocator &__rarg) throw() + _ExtPtr_allocator(const _ExtPtr_allocator& __rarg) _GLIBCXX_USE_NOEXCEPT : _M_real_alloc(__rarg._M_real_alloc) { } template - _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg) throw() + _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg) + _GLIBCXX_USE_NOEXCEPT : _M_real_alloc(__rarg._M_getUnderlyingImp()) { } - ~_ExtPtr_allocator() throw() + ~_ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT { } - pointer address(reference __x) const + pointer address(reference __x) const _GLIBCXX_NOEXCEPT { return std::__addressof(__x); } - const_pointer address(const_reference __x) const + const_pointer address(const_reference __x) const _GLIBCXX_NOEXCEPT { return std::__addressof(__x); } pointer allocate(size_type __n, void* __hint = 0) @@ -97,7 +98,7 @@ void deallocate(pointer __p, size_type __n) { _M_real_alloc.deallocate(__p.get(), __n); } - size_type max_size() const throw() + size_type max_size() const _GLIBCXX_USE_NOEXCEPT { return __numeric_traits::__max / sizeof(_Tp); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ Index: testsuite/util/testsuite_allocator.h =================================================================== --- testsuite/util/testsuite_allocator.h (revision 174912) +++ testsuite/util/testsuite_allocator.h (working copy) @@ -1,7 +1,7 @@ // -*- C++ -*- // Testing allocator for the C++ library testsuite. // -// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -28,11 +28,8 @@ #define _GLIBCXX_TESTSUITE_ALLOCATOR_H #include -#include - -#ifdef __GXX_EXPERIMENTAL_CXX0X__ #include -#endif +#include namespace __gnu_test { @@ -110,28 +107,28 @@ template struct rebind { typedef tracker_allocator other; }; pointer - address(reference value) const - { return &value; } - + address(reference value) const _GLIBCXX_NOEXCEPT + { return std::__addressof(value); } + const_pointer - address(const_reference value) const - { return &value; } - - tracker_allocator() throw() + address(const_reference value) const _GLIBCXX_NOEXCEPT + { return std::__addressof(value); } + + tracker_allocator() _GLIBCXX_USE_NOEXCEPT { } - tracker_allocator(const tracker_allocator&) throw() + tracker_allocator(const tracker_allocator&) _GLIBCXX_USE_NOEXCEPT { } template - tracker_allocator(const tracker_allocator&) throw() + tracker_allocator(const tracker_allocator&) _GLIBCXX_USE_NOEXCEPT { } - ~tracker_allocator() throw() + ~tracker_allocator() _GLIBCXX_USE_NOEXCEPT { } size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_type(-1) / sizeof(T); } pointer @@ -263,24 +260,29 @@ struct rebind { typedef uneq_allocator other; }; - uneq_allocator() throw() + uneq_allocator() _GLIBCXX_USE_NOEXCEPT : personality(0) { } - uneq_allocator(int person) throw() + uneq_allocator(int person) _GLIBCXX_USE_NOEXCEPT : personality(person) { } template - uneq_allocator(const uneq_allocator& b) throw() + uneq_allocator(const uneq_allocator& b) _GLIBCXX_USE_NOEXCEPT : personality(b.get_personality()) { } + ~uneq_allocator() _GLIBCXX_USE_NOEXCEPT + { } + int get_personality() const { return personality; } pointer - address(reference x) const { return &x; } + address(reference x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(x); } const_pointer - address(const_reference x) const { return &x; } - + address(const_reference x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(x); } + pointer allocate(size_type n, const void* = 0) { @@ -300,27 +302,29 @@ } return p; } - + void deallocate(pointer p, size_type) { - assert( p ); - + bool test __attribute__((unused)) = true; + + VERIFY( p ); + map_type::iterator it = get_map().find(reinterpret_cast(p)); - assert( it != get_map().end() ); + VERIFY( it != get_map().end() ); // Enforce requirements in Table 32 about deallocation vs // allocator equality. - assert( it->second == personality ); - + VERIFY( it->second == personality ); + get_map().erase(it); ::operator delete(p); } - + size_type - max_size() const throw() + max_size() const _GLIBCXX_USE_NOEXCEPT { return size_type(-1) / sizeof(Tp); } - + #ifdef __GXX_EXPERIMENTAL_CXX0X__ template void