OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove redundant std::allocator members for C++20

Browse Source 
C++20 removes a number of std::allocator members that have correct
defaults provided by std::allocator_traits, so aren't needed.

Several extensions including __gnu_cxx::hash_map and tr1 containers are
no longer usable with std::allocator in C++20 mode. They need to be
updated to use __gnu_cxx::__alloc_traits in a follow-up patch.

	* include/bits/alloc_traits.h
	(allocator_traits<allocator<T>>::allocate): Ignore hint for C++20.
	(allocator_traits<allocator<T>>::construct): Perform placement new
	directly for C++20, instead of calling allocator<T>::construct.
	(allocator_traits<allocator<T>>::destroy): Call destructor directly
	for C++20, instead of calling allocator<T>::destroy.
	(allocator_traits<allocator<T>>::max_size): Return value directly
	for C++20, instead of calling std::allocator<T>::max_size().
	(__do_alloc_on_copy, __do_alloc_on_move, __do_alloc_on_swap): Do not
	define for C++17 and up.
	(__alloc_on_copy, __alloc_on_move, __alloc_on_swap): Use if-constexpr
	for C++17 and up, instead of tag dispatching.
	* include/bits/allocator.h (allocator<void>): Remove for C++20.
	(allocator::pointer, allocator::const_pointer, allocator::reference)
	(allocator::const_reference, allocator::rebind): Remove for C++20.
	* include/bits/basic_string.h (basic_string): Use __alloc_traits to
	rebind allocator.
	* include/bits/memoryfwd.h (allocator<void>): Remove for C++20.
	* include/ext/debug_allocator.h: Use __alloc_traits for rebinding.
	* include/ext/malloc_allocator.h (malloc_allocator::~malloc_allocator)
	(malloc_allocator::pointer, malloc_allocator::const_pointer)
	(malloc_allocator::reference, malloc_allocator::const_reference)
	(malloc_allocator::rebind, malloc_allocator::max_size)
	(malloc_allocator::construct, malloc_allocator::destroy): Do not
	define for C++20.
	(malloc_allocator::_M_max_size): Define new function.
	* include/ext/new_allocator.h (new_allocator::~new_allocator)
	(new_allocator::pointer, new_allocator::const_pointer)
	(new_allocator::reference, new_allocator::const_reference)
	(new_allocator::rebind, new_allocator::max_size)
	(new_allocator::construct, new_allocator::destroy): Do not
	define for C++20.
	(new_allocator::_M_max_size): Define new function.
	* include/ext/rc_string_base.h (__rc_string_base::_Rep): Use
	__alloc_traits to rebind allocator.
	* include/ext/rope (_Rope_rep_base, _Rope_base): Likewise.
	(rope::rope(CharT, const allocator_type&)): Use __alloc_traits
	to construct character.
	* include/ext/slist (_Slist_base): Use __alloc_traits to rebind
	allocator.
	* include/ext/sso_string_base.h (__sso_string_base::_M_max_size):
	Use __alloc_traits.
	* include/ext/throw_allocator.h (throw_allocator): Do not use optional
	members of std::allocator, use __alloc_traits members instead.
	* include/ext/vstring.h (__versa_string): Use __alloc_traits.
	* include/ext/vstring_util.h (__vstring_utility): Likewise.
	* include/std/memory: Include <bits/alloc_traits.h>.
	* testsuite/20_util/allocator/8230.cc: Use __gnu_test::max_size.
	* testsuite/20_util/allocator/rebind_c++20.cc: New test.
	* testsuite/20_util/allocator/requirements/typedefs.cc: Do not check
	for pointer, const_pointer, reference, const_reference or rebind in
	C++20.
	* testsuite/20_util/allocator/requirements/typedefs_c++20.cc: New test.
	* testsuite/23_containers/deque/capacity/29134.cc: Use
	__gnu_test::max_size.
	* testsuite/23_containers/forward_list/capacity/1.cc: Likewise.
	* testsuite/23_containers/list/capacity/29134.cc: Likewise.
	* testsuite/23_containers/map/capacity/29134.cc: Likewise.
	* testsuite/23_containers/multimap/capacity/29134.cc: Likewise.
	* testsuite/23_containers/multiset/capacity/29134.cc: Likewise.
	* testsuite/23_containers/set/capacity/29134.cc: Likewise.
	* testsuite/23_containers/vector/capacity/29134.cc: Likewise.
	* testsuite/ext/malloc_allocator/variadic_construct.cc: Do not run
	test for C++20.
	* testsuite/ext/new_allocator/variadic_construct.cc: Likewise.
	* testsuite/ext/vstring/capacity/29134.cc: Use __gnu_test::max_size.
	* testsuite/util/replacement_memory_operators.h: Do not assume
	Alloc::pointer exists.
	* testsuite/util/testsuite_allocator.h (__gnu_test::max_size): Define
	helper to call max_size for any allocator.

From-SVN: r277300
This commit is contained in:
Jonathan Wakely 2019-10-22 22:48:39 +01:00 committed by Jonathan Wakely
parent 51940760d7
commit 2cae56bd61
33 changed files with 370 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,76 @@
2019-10-22 Jonathan Wakely <jwakely@redhat.com>
* include/bits/alloc_traits.h
(allocator_traits<allocator<T>>::allocate): Ignore hint for C++20.
(allocator_traits<allocator<T>>::construct): Perform placement new
directly for C++20, instead of calling allocator<T>::construct.
(allocator_traits<allocator<T>>::destroy): Call destructor directly
for C++20, instead of calling allocator<T>::destroy.
(allocator_traits<allocator<T>>::max_size): Return value directly
for C++20, instead of calling std::allocator<T>::max_size().
(__do_alloc_on_copy, __do_alloc_on_move, __do_alloc_on_swap): Do not
define for C++17 and up.
(__alloc_on_copy, __alloc_on_move, __alloc_on_swap): Use if-constexpr
for C++17 and up, instead of tag dispatching.
* include/bits/allocator.h (allocator<void>): Remove for C++20.
(allocator::pointer, allocator::const_pointer, allocator::reference)
(allocator::const_reference, allocator::rebind): Remove for C++20.
* include/bits/basic_string.h (basic_string): Use __alloc_traits to
rebind allocator.
* include/bits/memoryfwd.h (allocator<void>): Remove for C++20.
* include/ext/debug_allocator.h: Use __alloc_traits for rebinding.
* include/ext/malloc_allocator.h (malloc_allocator::~malloc_allocator)
(malloc_allocator::pointer, malloc_allocator::const_pointer)
(malloc_allocator::reference, malloc_allocator::const_reference)
(malloc_allocator::rebind, malloc_allocator::max_size)
(malloc_allocator::construct, malloc_allocator::destroy): Do not
define for C++20.
(malloc_allocator::_M_max_size): Define new function.
* include/ext/new_allocator.h (new_allocator::~new_allocator)
(new_allocator::pointer, new_allocator::const_pointer)
(new_allocator::reference, new_allocator::const_reference)
(new_allocator::rebind, new_allocator::max_size)
(new_allocator::construct, new_allocator::destroy): Do not
define for C++20.
(new_allocator::_M_max_size): Define new function.
* include/ext/rc_string_base.h (__rc_string_base::_Rep): Use
__alloc_traits to rebind allocator.
* include/ext/rope (_Rope_rep_base, _Rope_base): Likewise.
(rope::rope(CharT, const allocator_type&)): Use __alloc_traits
to construct character.
* include/ext/slist (_Slist_base): Use __alloc_traits to rebind
allocator.
* include/ext/sso_string_base.h (__sso_string_base::_M_max_size):
Use __alloc_traits.
* include/ext/throw_allocator.h (throw_allocator): Do not use optional
members of std::allocator, use __alloc_traits members instead.
* include/ext/vstring.h (__versa_string): Use __alloc_traits.
* include/ext/vstring_util.h (__vstring_utility): Likewise.
* include/std/memory: Include <bits/alloc_traits.h>.
* testsuite/20_util/allocator/8230.cc: Use __gnu_test::max_size.
* testsuite/20_util/allocator/rebind_c++20.cc: New test.
* testsuite/20_util/allocator/requirements/typedefs.cc: Do not check
for pointer, const_pointer, reference, const_reference or rebind in
C++20.
* testsuite/20_util/allocator/requirements/typedefs_c++20.cc: New test.
* testsuite/23_containers/deque/capacity/29134.cc: Use
__gnu_test::max_size.
* testsuite/23_containers/forward_list/capacity/1.cc: Likewise.
* testsuite/23_containers/list/capacity/29134.cc: Likewise.
* testsuite/23_containers/map/capacity/29134.cc: Likewise.
* testsuite/23_containers/multimap/capacity/29134.cc: Likewise.
* testsuite/23_containers/multiset/capacity/29134.cc: Likewise.
* testsuite/23_containers/set/capacity/29134.cc: Likewise.
* testsuite/23_containers/vector/capacity/29134.cc: Likewise.
* testsuite/ext/malloc_allocator/variadic_construct.cc: Do not run
test for C++20.
* testsuite/ext/new_allocator/variadic_construct.cc: Likewise.
* testsuite/ext/vstring/capacity/29134.cc: Use __gnu_test::max_size.
* testsuite/util/replacement_memory_operators.h: Do not assume
Alloc::pointer exists.
* testsuite/util/testsuite_allocator.h (__gnu_test::max_size): Define
helper to call max_size for any allocator.
2019-10-22 Andreas Schwab <schwab@suse.de>
* config/abi/post/aarch64-linux-gnu/baseline_symbols.txt: Update.

62
libstdc++-v3/include/bits/alloc_traits.h
View File

@ -393,6 +393,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
/// The allocator type
using allocator_type = allocator<_Tp>;
/// The allocated type
using value_type = _Tp;
@ -455,7 +456,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
_GLIBCXX_NODISCARD static pointer
allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
{ return __a.allocate(__n, __hint); }
{
#if __cplusplus <= 201703L
return __a.allocate(__n, __hint);
#else
return __a.allocate(__n);
#endif
}
/**
* @brief Deallocate memory.
@ -480,8 +487,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Up, typename... _Args>
static void
construct(allocator_type& __a, _Up* __p, _Args&&... __args)
noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
{ __a.construct(__p, std::forward<_Args>(__args)...); }
noexcept(noexcept(::new((void*)__p) _Up(std::forward<_Args>(__args)...)))
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
::new((void*)__p) _Up(std::forward<_Args>(__args)...);
#endif
}
/**
* @brief Destroy an object of type @a _Up
@ -493,8 +506,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Up>
static void
destroy(allocator_type& __a, _Up* __p)
noexcept(noexcept(__a.destroy(__p)))
{ __a.destroy(__p); }
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
__p->~_Up();
#endif
}
/**
* @brief The maximum supported allocation size
@ -503,7 +522,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
static size_type
max_size(const allocator_type& __a) noexcept
{ return __a.max_size(); }
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
}
/**
* @brief Obtain an allocator to use when copying a container.
@ -515,7 +540,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return __rhs; }
};
#if __cplusplus < 201703L
template<typename _Alloc>
inline void
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
@ -525,13 +550,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline void
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
{ }
#endif
template<typename _Alloc>
inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
{
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_copy_assignment __pocca;
#if __cplusplus >= 201703L
if constexpr (__pocca::value)
__one = __two;
#else
__do_alloc_on_copy(__one, __two, __pocca());
#endif
}
template<typename _Alloc>
@ -541,6 +572,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __traits::select_on_container_copy_construction(__a);
}
#if __cplusplus < 201703L
template<typename _Alloc>
inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
{ __one = std::move(__two); }
@ -548,15 +580,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
{ }
#endif
template<typename _Alloc>
inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
{
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_move_assignment __pocma;
#if __cplusplus >= 201703L
if constexpr (__pocma::value)
__one = std::move(__two);
#else
__do_alloc_on_move(__one, __two, __pocma());
#endif
}
#if __cplusplus < 201703L
template<typename _Alloc>
inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
{
@ -567,13 +606,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
{ }
#endif
template<typename _Alloc>
inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
{
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_swap __pocs;
#if __cplusplus >= 201703L
if constexpr (__pocs::value)
{
using std::swap;
swap(__one, __two);
}
#else
__do_alloc_on_swap(__one, __two, __pocs());
#endif
}
template<typename _Alloc, typename _Tp,

10
libstdc++-v3/include/bits/allocator.h
View File

@ -63,6 +63,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @{
*/
#if __cplusplus <= 201703L
/// allocator<void> specialization.
template<>
class allocator<void>
@ -97,8 +98,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
destroy(_Up* __p)
noexcept(noexcept(__p->~_Up()))
{ __p->~_Up(); }
#endif
#endif // C++11
};
#endif // ! C++20
/**
* @brief The @a standard allocator, as per [20.4].
@ -111,18 +113,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp>
class allocator : public __allocator_base<_Tp>
{
public:
public:
typedef _Tp value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
#if __cplusplus <= 201703L
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
#endif
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS

11
libstdc++-v3/include/bits/basic_string.h
View File

@ -3138,7 +3138,9 @@ _GLIBCXX_END_NAMESPACE_CXX11
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_CharT>::other _CharT_alloc_type;
typedef __gnu_cxx::__alloc_traits<_CharT_alloc_type> _CharT_alloc_traits;
// Types:
public:
@ -3154,8 +3156,8 @@ _GLIBCXX_END_NAMESPACE_CXX11
typedef value_type& reference;
typedef const value_type& const_reference;
#endif
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::const_pointer const_pointer;
typedef typename _CharT_alloc_traits::pointer pointer;
typedef typename _CharT_alloc_traits::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
const_iterator;
@ -3191,7 +3193,8 @@ _GLIBCXX_END_NAMESPACE_CXX11
struct _Rep : _Rep_base
{
// Types:
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<char>::other _Raw_bytes_alloc;
// (Public) Data members:

2
libstdc++-v3/include/bits/memoryfwd.h
View File

@ -63,8 +63,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename>
class allocator;
#if __cplusplus <= 201703L
template<>
class allocator<void>;
#endif
/// Declare uses_allocator so it can be specialized in \<queue\> etc.
template<typename, typename>

3
libstdc++-v3/include/ext/debug_allocator.h
View File

@ -89,7 +89,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Alloc _M_allocator;
template<typename _Alloc2,
typename = typename _Alloc2::template rebind<value_type>::other>
typename = typename __alloc_traits<_Alloc2>::template
rebind<value_type>::other>
struct __convertible
{ };

41
libstdc++-v3/include/ext/malloc_allocator.h
View File

@ -54,17 +54,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
class malloc_allocator
{
public:
typedef _Tp value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
#if __cplusplus <= 201703L
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
template<typename _Tp1>
struct rebind
{ typedef malloc_allocator<_Tp1> other; };
#endif
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
@ -83,6 +85,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
malloc_allocator(const malloc_allocator<_Tp1>&)
_GLIBCXX_USE_NOEXCEPT { }
#if __cplusplus <= 201703L
~malloc_allocator() _GLIBCXX_USE_NOEXCEPT { }
pointer
@ -92,16 +95,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
const_pointer
address(const_reference __x) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__x); }
#endif
// NB: __n is permitted to be 0. The C++ standard says nothing
// about what the return value is when __n == 0.
pointer
_Tp*
allocate(size_type __n, const void* = 0)
{
if (__n > this->max_size())
if (__n > this->_M_max_size())
std::__throw_bad_alloc();
pointer __ret = 0;
_Tp* __ret = 0;
#if __cpp_aligned_new
#if __cplusplus > 201402L && _GLIBCXX_HAVE_ALIGNED_ALLOC
if (alignof(_Tp) > alignof(std::max_align_t))
@ -131,18 +135,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// __p is not permitted to be a null pointer.
void
deallocate(pointer __p, size_type)
deallocate(_Tp* __p, size_type)
{ std::free(static_cast<void*>(__p)); }
#if __cplusplus <= 201703L
size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{
#if __PTRDIFF_MAX__ < __SIZE_MAX__
return std::size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
#else
return std::size_t(-1) / sizeof(_Tp);
#endif
}
{ return _M_max_size(); }
#if __cplusplus >= 201103L
template<typename _Up, typename... _Args>
@ -160,13 +159,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#else
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct
void
construct(pointer __p, const _Tp& __val)
void
construct(pointer __p, const _Tp& __val)
{ ::new((void *)__p) value_type(__val); }
void
void
destroy(pointer __p) { __p->~_Tp(); }
#endif
#endif // ! C++20
template<typename _Up>
friend bool
@ -179,6 +179,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
operator!=(const malloc_allocator&, const malloc_allocator<_Up>&)
_GLIBCXX_NOTHROW
{ return false; }
private:
_GLIBCXX_CONSTEXPR size_type
_M_max_size() const _GLIBCXX_USE_NOEXCEPT
{
#if __PTRDIFF_MAX__ < __SIZE_MAX__
return std::size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
#else
return std::size_t(-1) / sizeof(_Tp);
#endif
}
};
_GLIBCXX_END_NAMESPACE_VERSION

33
libstdc++-v3/include/ext/new_allocator.h
View File

@ -55,17 +55,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
class new_allocator
{
public:
typedef _Tp value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
#if __cplusplus <= 201703L
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
template<typename _Tp1>
struct rebind
{ typedef new_allocator<_Tp1> other; };
#endif
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
@ -83,6 +85,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX20_CONSTEXPR
new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
#if __cplusplus <= 201703L
~new_allocator() _GLIBCXX_USE_NOEXCEPT { }
pointer
@ -92,13 +95,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
const_pointer
address(const_reference __x) const _GLIBCXX_NOEXCEPT
{ return std::__addressof(__x); }
#endif
// NB: __n is permitted to be 0. The C++ standard says nothing
// about what the return value is when __n == 0.
_GLIBCXX_NODISCARD pointer
_GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
if (__n > this->max_size())
if (__n > this->_M_max_size())
std::__throw_bad_alloc();
#if __cpp_aligned_new
@ -113,7 +117,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// __p is not permitted to be a null pointer.
void
deallocate(pointer __p, size_type __t)
deallocate(_Tp* __p, size_type __t)
{
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
@ -133,15 +137,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
);
}
#if __cplusplus <= 201703L
size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{
#if __PTRDIFF_MAX__ < __SIZE_MAX__
return std::size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
#else
return std::size_t(-1) / sizeof(_Tp);
#endif
}
{ return _M_max_size(); }
#if __cplusplus >= 201103L
template<typename _Up, typename... _Args>
@ -166,6 +165,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void
destroy(pointer __p) { __p->~_Tp(); }
#endif
#endif // ! C++20
template<typename _Up>
friend bool
@ -178,6 +178,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
operator!=(const new_allocator&, const new_allocator<_Up>&)
_GLIBCXX_NOTHROW
{ return false; }
private:
_GLIBCXX_CONSTEXPR size_type
_M_max_size() const _GLIBCXX_USE_NOEXCEPT
{
#if __PTRDIFF_MAX__ < __SIZE_MAX__
return std::size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
#else
return std::size_t(-1) / sizeof(_Tp);
#endif
}
};
_GLIBCXX_END_NAMESPACE_VERSION

4
libstdc++-v3/include/ext/rc_string_base.h
View File

@ -31,6 +31,7 @@
#define _RC_STRING_BASE_H 1
#include <ext/atomicity.h>
#include <ext/alloc_traits.h>
#include <bits/stl_iterator_base_funcs.h>
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
@ -120,7 +121,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_CharT _M_align;
};
typedef typename _Alloc::template rebind<_Rep>::other _Rep_alloc_type;
typedef typename __alloc_traits<_Alloc>::template rebind<_Rep>::other
_Rep_alloc_type;
_CharT*
_M_refdata() throw()

8
libstdc++-v3/include/ext/rope
View File

@ -53,6 +53,7 @@
#include <bits/stl_numeric.h>
#include <bits/allocator.h>
#include <bits/gthr.h>
#include <ext/alloc_traits.h>
#include <tr1/functional>
# ifdef __GC
@ -565,7 +566,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
# define __ROPE_DEFINE_ALLOC(_Tp, __name) \
typedef typename \
_Alloc::template rebind<_Tp>::other __name##Alloc; \
__alloc_traits<_Alloc>::template rebind<_Tp>::other __name##Alloc; \
static _Tp* __name##_allocate(size_type __n) \
{ return __name##Alloc().allocate(__n); } \
static void __name##_deallocate(_Tp *__p, size_type __n) \
@ -1499,7 +1500,7 @@ protected:
#define __ROPE_DEFINE_ALLOC(_Tp, __name) \
typedef typename \
_Alloc::template rebind<_Tp>::other __name##Alloc; \
__alloc_traits<_Alloc>::template rebind<_Tp>::other __name##Alloc; \
static _Tp* __name##_allocate(std::size_t __n) \
{ return __name##Alloc().allocate(__n); } \
static void __name##_deallocate(_Tp *__p, std::size_t __n) \
@ -1855,7 +1856,8 @@ protected:
{
_CharT* __buf = this->_Data_allocate(_S_rounded_up_size(1));
_M_get_allocator().construct(__buf, __c);
__alloc_traits<allocator_type>::construct(_M_get_allocator(),
__buf, __c);
__try
{
this->_M_tree_ptr = _S_new_RopeLeaf(__buf, 1,

6
libstdc++-v3/include/ext/slist
View File

@ -217,10 +217,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template <class _Tp, class _Alloc>
struct _Slist_base
: public _Alloc::template rebind<_Slist_node<_Tp> >::other
: public __alloc_traits<_Alloc>::template rebind<_Slist_node<_Tp> >::other
{
typedef typename _Alloc::template rebind<_Slist_node<_Tp> >::other
_Node_alloc;
typedef typename __alloc_traits<_Alloc>::template
rebind<_Slist_node<_Tp> >::other _Node_alloc;
typedef _Alloc allocator_type;
allocator_type

5
libstdc++-v3/include/ext/sso_string_base.h
View File

@ -140,7 +140,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
public:
size_type
_M_max_size() const
{ return (_M_get_allocator().max_size() - 1) / 2; }
{
typedef __alloc_traits<_CharT_alloc_type> _ATraits;
return (_ATraits::max_size(_M_get_allocator()) - 1) / 2;
}
_CharT*
_M_data() const

13
libstdc++-v3/include/ext/throw_allocator.h
View File

@ -62,6 +62,7 @@
# include <tr1/functional>
# include <tr1/random>
#endif
#include <ext/alloc_traits.h>
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
@ -814,12 +815,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
std::allocator<value_type> _M_allocator;
typedef __gnu_cxx::__alloc_traits<std::allocator<value_type> > traits;
using condition_type::throw_conditionally;
public:
size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_allocator.max_size(); }
{ return traits::max_size(_M_allocator); }
pointer
address(reference __x) const _GLIBCXX_NOEXCEPT
@ -830,13 +833,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return std::__addressof(__x); }
_GLIBCXX_NODISCARD pointer
allocate(size_type __n, std::allocator<void>::const_pointer hint = 0)
allocate(size_type __n, const void* hint = 0)
{
if (__n > this->max_size())
std::__throw_bad_alloc();
throw_conditionally();
pointer const a = _M_allocator.allocate(__n, hint);
pointer const a = traits::allocate(_M_allocator, __n, hint);
insert(a, sizeof(value_type) * __n);
return a;
}
@ -846,7 +849,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void
construct(_Up* __p, _Args&&... __args)
{
_M_allocator.construct(__p, std::forward<_Args>(__args)...);
traits::construct(_M_allocator, __p, std::forward<_Args>(__args)...);
insert_construct(__p);
}
@ -855,7 +858,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
destroy(_Up* __p)
{
erase_construct(__p);
_M_allocator.destroy(__p);
traits::destroy(_M_allocator, __p);
}
#else
void

5
libstdc++-v3/include/ext/vstring.h
View File

@ -58,6 +58,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
typedef _Base<_CharT, _Traits, _Alloc> __vstring_base;
typedef typename __vstring_base::_CharT_alloc_type _CharT_alloc_type;
typedef __alloc_traits<_CharT_alloc_type> _CharT_alloc_traits;
// Types:
public:
@ -68,8 +69,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::const_pointer const_pointer;
typedef typename _CharT_alloc_traits::pointer pointer;
typedef typename _CharT_alloc_traits::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, __versa_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, __versa_string>
const_iterator;

9
libstdc++-v3/include/ext/vstring_util.h
View File

@ -40,6 +40,7 @@
#include <bits/ostream_insert.h>
#include <bits/stl_iterator.h>
#include <ext/numeric_traits.h>
#include <ext/alloc_traits.h>
#include <bits/move.h>
#include <bits/range_access.h>
@ -50,14 +51,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc>
struct __vstring_utility
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
typedef typename __alloc_traits<_Alloc>::template rebind<_CharT>::other
_CharT_alloc_type;
typedef __alloc_traits<_CharT_alloc_type> _CharT_alloc_traits;
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef typename _CharT_alloc_type::size_type size_type;
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::const_pointer const_pointer;
typedef typename _CharT_alloc_traits::pointer pointer;
typedef typename _CharT_alloc_traits::const_pointer const_pointer;
// For __sso_string.
typedef __gnu_cxx::

1
libstdc++-v3/include/std/memory
View File

@ -76,6 +76,7 @@
# include <bits/functexcept.h>
# include <bits/stl_function.h> // std::less
# include <bits/uses_allocator.h>
# include <bits/alloc_traits.h>
# include <type_traits>
# include <debug/debug.h>
# include <bits/unique_ptr.h>

5
libstdc++-v3/testsuite/20_util/allocator/8230.cc
View File

@ -22,6 +22,7 @@
#include <memory>
#include <stdexcept>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/8230
void test02()
@ -30,11 +31,11 @@ void test02()
try
{
std::allocator<int> alloc;
const std::allocator<int>::size_type n = alloc.max_size();
const std::allocator<int>::size_type n = __gnu_test::max_size(alloc);
int* p = alloc.allocate(n + 1);
p[n] = 2002;
}
catch(const std::bad_alloc& e)
catch(const std::bad_alloc& e)
{
// Allowed.
test = true;

28
libstdc++-v3/testsuite/20_util/allocator/rebind_c++20.cc Normal file
View File

@ -0,0 +1,28 @@
// Copyright (C) 2019 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// { dg-options "-std=gnu++2a" }
// { dg-do compile { target c++2a } }
#include <memory>
template<typename T> struct Alloc : std::allocator<T> { };
using T = std::allocator_traits<Alloc<int>>;
// Prior to C++20 this finds std::allocator<int>::rebind and so fails:
static_assert( std::is_same_v<T::rebind_alloc<long>, Alloc<long>> );

4
libstdc++-v3/testsuite/20_util/allocator/requirements/typedefs.cc
View File

@ -30,6 +30,7 @@ static_assert( is_same<allocator<int>::size_type, std::size_t>::value,
"size_type" );
static_assert( is_same<allocator<int>::difference_type, std::ptrdiff_t>::value,
"difference_type" );
#if __cplusplus <= 201703L
static_assert( is_same<allocator<int>::pointer, int*>::value,
"pointer" );
static_assert( is_same<allocator<int>::const_pointer, const int*>::value,
@ -38,12 +39,15 @@ static_assert( is_same<allocator<int>::reference, int&>::value,
"reference" );
static_assert( is_same<allocator<int>::const_reference, const int&>::value,
"const_reference" );
#endif
static_assert( is_same<allocator<int>::value_type, int>::value,
"value_type" );
#if __cplusplus <= 201703L
static_assert( is_same<allocator<int>::rebind<char>::other,
allocator<char>>::value,
"rebind::other" );
#endif
static_assert( is_same<allocator<int>::propagate_on_container_move_assignment,
std::true_type>::value,

56
libstdc++-v3/testsuite/20_util/allocator/requirements/typedefs_c++20.cc Normal file
View File

@ -0,0 +1,56 @@
// Copyright (C) 2019 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// { dg-options "-std=gnu++2a" }
// { dg-do compile { target c++2a } }
#include <memory>
template<typename Alloc>
concept has_pointer = requires { typename Alloc::pointer; };
template<typename Alloc>
concept has_const_pointer = requires { typename Alloc::const_pointer; };
template<typename Alloc>
concept has_reference = requires { typename Alloc::reference; };
template<typename Alloc>
concept has_const_reference = requires { typename Alloc::const_reference; };
template<typename Alloc>
concept has_rebind = requires { typename Alloc::template rebind<long>; };
template<typename Alloc>
concept has_construct = requires(Alloc& a, int* p) { a.construct(p); };
template<typename Alloc>
concept has_destroy = requires(Alloc& a, int* p) { a.destroy(p); };
template<typename Alloc>
concept has_max_size = requires(Alloc& a) { a.max_size(); };
using A = std::allocator<int>;
static_assert( !has_pointer<A> );
static_assert( !has_const_pointer<A> );
static_assert( !has_reference<A> );
static_assert( !has_const_reference<A> );
static_assert( !has_rebind<A> );
static_assert( !has_construct<A> );
static_assert( !has_destroy<A> );
static_assert( !has_max_size<A> );

4
libstdc++-v3/testsuite/23_containers/deque/capacity/29134.cc
View File

@ -19,13 +19,15 @@
#include <deque>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
{
std::deque<int> d;
VERIFY( d.max_size() == d.get_allocator().max_size() );
std::allocator<int> a = d.get_allocator();
VERIFY( d.max_size() == __gnu_test::max_size(a) );
}
int main()

5
libstdc++-v3/testsuite/23_containers/forward_list/capacity/1.cc
View File

@ -21,6 +21,7 @@
#include <forward_list>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
void
test01()
@ -40,8 +41,8 @@ test01()
using std::_Fwd_list_node;
#endif
VERIFY( (fld.max_size()
== std::allocator<_Fwd_list_node<double> >().max_size()) );
std::allocator<_Fwd_list_node<double> > a;
VERIFY( fld.max_size() == __gnu_test::max_size(a) );
}
int

4
libstdc++-v3/testsuite/23_containers/list/capacity/29134.cc
View File

@ -19,6 +19,7 @@
#include <list>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
@ -32,7 +33,8 @@ void test01()
using std::_List_node;
#endif
VERIFY( l.max_size() == std::allocator<_List_node<int> >().max_size() );
std::allocator<_List_node<int> > a;
VERIFY( l.max_size() == __gnu_test::max_size(a) );
}
int main()

5
libstdc++-v3/testsuite/23_containers/map/capacity/29134.cc
View File

@ -19,14 +19,15 @@
#include <map>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
{
std::map<int, int> m;
VERIFY( (m.max_size() == std::allocator<std::_Rb_tree_node<
std::pair<const int, int> > >().max_size()) );
std::allocator<std::_Rb_tree_node<std::pair<const int, int> > > a;
VERIFY( m.max_size() == __gnu_test::max_size(a) );
}
int main()

5
libstdc++-v3/testsuite/23_containers/multimap/capacity/29134.cc
View File

@ -19,14 +19,15 @@
#include <map>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
{
std::multimap<int, int> mm;
VERIFY( (mm.max_size() == std::allocator<std::_Rb_tree_node<
std::pair<const int, int> > >().max_size()) );
std::allocator<std::_Rb_tree_node<std::pair<const int, int> > > a;
VERIFY( mm.max_size() == __gnu_test::max_size(a) );
}
int main()

5
libstdc++-v3/testsuite/23_containers/multiset/capacity/29134.cc
View File

@ -19,14 +19,15 @@
#include <set>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
{
std::multiset<int> ms;
VERIFY( ms.max_size()
== std::allocator<std::_Rb_tree_node<int> >().max_size() );
std::allocator<std::_Rb_tree_node<int> > a;
VERIFY( ms.max_size() == __gnu_test::max_size(a) );
}
int main()

5
libstdc++-v3/testsuite/23_containers/set/capacity/29134.cc
View File

@ -19,14 +19,15 @@
#include <set>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
{
std::set<int> s;
VERIFY( s.max_size() ==
std::allocator<std::_Rb_tree_node<int> >().max_size() );
std::allocator<std::_Rb_tree_node<int> > a;
VERIFY( s.max_size() == __gnu_test::max_size(a) );
}
int main()

11
libstdc++-v3/testsuite/23_containers/vector/capacity/29134.cc
View File

@ -19,13 +19,22 @@
#include <vector>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
{
std::vector<int> v;
VERIFY( v.max_size() == v.get_allocator().max_size() );
std::allocator<int> a = v.get_allocator();
#if __cplusplus > 201703L
// std::allocator_traits::max_size() is unrealistically large,
// so std::vector::max_size() returns a smaller value.
VERIFY( v.max_size() <= __gnu_test::max_size(a) );
#else
VERIFY( v.max_size() == __gnu_test::max_size(a) );
#endif
}
int main()

2
libstdc++-v3/testsuite/ext/malloc_allocator/variadic_construct.cc
View File

@ -1,4 +1,4 @@
// { dg-do run { target c++11 } }
// { dg-do run { target { { c++11_only || c++14_only } || c++17_only } } }
// 2007-10-26 Paolo Carlini <pcarlini@suse.de>

2
libstdc++-v3/testsuite/ext/new_allocator/variadic_construct.cc
View File

@ -1,4 +1,4 @@
// { dg-do run { target c++11 } }
// { dg-do run { target { { c++11_only || c++14_only } || c++17_only } } }
// 2007-10-26 Paolo Carlini <pcarlini@suse.de>

3
libstdc++-v3/testsuite/ext/vstring/capacity/29134.cc
View File

@ -19,13 +19,14 @@
#include <ext/vstring.h>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
// libstdc++/29134
void test01()
{
__gnu_cxx::__vstring vs;
VERIFY( vs.max_size() <= vs.get_allocator().max_size() );
VERIFY( vs.max_size() <= __gnu_test::max_size(vs.get_allocator()) );
}
int main()

4
libstdc++-v3/testsuite/util/replacement_memory_operators.h
View File

@ -76,7 +76,11 @@ namespace __gnu_test
check_delete(Alloc a = Alloc())
{
__gnu_test::counter::exceptions(false);
#if __cplusplus >= 201103L
auto p = a.allocate(10);
#else
typename Alloc::pointer p = a.allocate(10);
#endif
const std::size_t count1 = __gnu_test::counter::count();
a.deallocate(p, 10);
const std::size_t count2 = __gnu_test::counter::count();

14
libstdc++-v3/testsuite/util/testsuite_allocator.h
View File

@ -45,6 +45,18 @@ namespace unord = std::tr1;
namespace __gnu_test
{
// A common API for calling max_size() on an allocator in any -std mode.
template<typename A>
typename A::size_type
max_size(const A& a)
{
#if __cplusplus >= 201103L
return std::allocator_traits<A>::max_size(a);
#else
return a.max_size();
#endif
}
class tracker_allocator_counter
{
public:
@ -252,7 +264,7 @@ namespace __gnu_test
Alloc a;
try
{
(void) a.allocate(a.max_size() + 1);
(void) a.allocate(__gnu_test::max_size(a) + 1);
}
catch(std::bad_alloc&)
{