+2019-05-17 François Dumont <fdumont@gcc.gnu.org>
+
+ * include/bits/stl_deque.h
+ (_Deque_iterator<>::__ptr_to): Remove, use std::__ptr_rebind.
+ (_Deque_base(_Deque_base&&, const allocator_type&)): New.
+ (_Deque_base::_Deque_impl_data): New.
+ (_Deque_base::_Deque_impl): Inherit latter.
+ (_Deque_base::_Deque_impl::_M_swap_data): Move...
+ (_Deque_base::_Deque_impl_data::_M_swap_data): ... here.
+ (_Deque_base::_Deque_impl()): Add noexcept qualification.
+ (_Deque_base::_Deque_impl(_Deque_impl&&, _Tp_alloc_type&&)): New.
+ (_Deque_base::_Deque_impl::_M_get_Tp_allocator()): Remove static_cast.
+ (deque<>::deque()): Default.
+ (deque<>::deque(deque&&)): Default.
+ (deque<>::deque(deque&&, const allocator_type&, false_type)): New.
+ (deque<>::deque(deque&&, const allocator_type&, true_type)): New.
+ (deque<>::deque(deque&&, const allocator_type&)): Delegate to latters.
+ (deque<>::deque<_It>(_It, _It, const allocator_type&)): Use
+ _M_range_initialize.
+ (deque<>::assign<_It>(_It, _It)): Use _M_assign_aux.
+ (deque<>::resize(size_type, const value_type&)): Share a single
+ implementation.
+ (deque<>::insert<_It>(const_iterator, _It, _It)): Use
+ _M_range_insert_aux.
+ [__cplusplus >= 201103L](_M_initialize_dispatch): Remove.
+ [__cplusplus >= 201103L](_M_assign_dispatch): Remove.
+ [__cplusplus >= 201103L](_M_insert_dispatch): Remove.
+ * testsuite/23_containers/deque/allocator/default_init.cc: New.
+
2019-05-17 Jonathan Wakely <jwakely@redhat.com>
PR libstdc++/90246
{
_Map_pointer __cur;
__try
- {
- for (__cur = this->_M_impl._M_start._M_node;
+ {
+ for (__cur = this->_M_impl._M_start._M_node;
__cur < this->_M_impl._M_finish._M_node;
++__cur)
- std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
+ std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
_M_get_Tp_allocator());
- std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
+ std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
this->_M_impl._M_finish._M_cur,
_M_get_Tp_allocator());
- }
+ }
__catch(...)
- {
- std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+ {
+ std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
_M_get_Tp_allocator());
- __throw_exception_again;
- }
+ __throw_exception_again;
+ }
}
#endif
if (_Alloc_traits::_S_propagate_on_copy_assign())
{
if (!_Alloc_traits::_S_always_equal()
- && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
- {
+ && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
+ {
// Replacement allocator cannot free existing storage,
// so deallocate everything and take copy of __x's data.
_M_replace_map(__x, __x.get_allocator());
if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
{
_Alloc_traits::construct(this->_M_impl,
- this->_M_impl._M_start._M_cur - 1,
- std::forward<_Args>(__args)...);
+ this->_M_impl._M_start._M_cur - 1,
+ std::forward<_Args>(__args)...);
--this->_M_impl._M_start._M_cur;
}
else
!= this->_M_impl._M_finish._M_last - 1)
{
_Alloc_traits::construct(this->_M_impl,
- this->_M_impl._M_finish._M_cur,
- std::forward<_Args>(__args)...);
+ this->_M_impl._M_finish._M_cur,
+ std::forward<_Args>(__args)...);
++this->_M_impl._M_finish._M_cur;
}
else
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
{
- iterator __cur = begin();
- for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
- *__cur = *__first;
- if (__first == __last)
- _M_erase_at_end(__cur);
- else
- _M_range_insert_aux(end(), __first, __last,
+ iterator __cur = begin();
+ for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
+ *__cur = *__first;
+ if (__first == __last)
+ _M_erase_at_end(__cur);
+ else
+ _M_range_insert_aux(end(), __first, __last,
std::__iterator_category(__first));
}
}
}
else
- _M_insert_aux(__pos, __n, __x);
+ _M_insert_aux(__pos, __n, __x);
}
#if __cplusplus >= 201103L
{
_Map_pointer __cur;
__try
- {
- for (__cur = this->_M_impl._M_start._M_node;
+ {
+ for (__cur = this->_M_impl._M_start._M_node;
__cur < this->_M_impl._M_finish._M_node;
++__cur)
- std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
+ std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
__value, _M_get_Tp_allocator());
- std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
+ std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
this->_M_impl._M_finish._M_cur,
__value, _M_get_Tp_allocator());
- }
+ }
__catch(...)
- {
- std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+ {
+ std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
_M_get_Tp_allocator());
- __throw_exception_again;
- }
+ __throw_exception_again;
+ }
}
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_range_initialize(_InputIterator __first, _InputIterator __last,
- std::input_iterator_tag)
+ std::input_iterator_tag)
{
- this->_M_initialize_map(0);
- __try
- {
- for (; __first != __last; ++__first)
+ this->_M_initialize_map(0);
+ __try
+ {
+ for (; __first != __last; ++__first)
#if __cplusplus >= 201103L
emplace_back(*__first);
#else
- push_back(*__first);
+ push_back(*__first);
#endif
- }
- __catch(...)
- {
- clear();
- __throw_exception_again;
- }
+ }
+ __catch(...)
+ {
+ clear();
+ __throw_exception_again;
+ }
}
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
- std::forward_iterator_tag)
+ std::forward_iterator_tag)
{
- const size_type __n = std::distance(__first, __last);
- this->_M_initialize_map(_S_check_init_len(__n, _M_get_Tp_allocator()));
-
- _Map_pointer __cur_node;
- __try
- {
- for (__cur_node = this->_M_impl._M_start._M_node;
- __cur_node < this->_M_impl._M_finish._M_node;
- ++__cur_node)
+ const size_type __n = std::distance(__first, __last);
+ this->_M_initialize_map(_S_check_init_len(__n, _M_get_Tp_allocator()));
+
+ _Map_pointer __cur_node;
+ __try
+ {
+ for (__cur_node = this->_M_impl._M_start._M_node;
+ __cur_node < this->_M_impl._M_finish._M_node;
+ ++__cur_node)
{
_ForwardIterator __mid = __first;
std::advance(__mid, _S_buffer_size());
_M_get_Tp_allocator());
__first = __mid;
}
- std::__uninitialized_copy_a(__first, __last,
+ std::__uninitialized_copy_a(__first, __last,
this->_M_impl._M_finish._M_first,
_M_get_Tp_allocator());
- }
- __catch(...)
- {
- std::_Destroy(this->_M_impl._M_start,
+ }
+ __catch(...)
+ {
+ std::_Destroy(this->_M_impl._M_start,
iterator(*__cur_node, __cur_node),
_M_get_Tp_allocator());
- __throw_exception_again;
- }
+ __throw_exception_again;
+ }
}
// Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_last - 1.
{
#if __cplusplus >= 201103L
_Alloc_traits::construct(this->_M_impl,
- this->_M_impl._M_finish._M_cur,
- std::forward<_Args>(__args)...);
+ this->_M_impl._M_finish._M_cur,
+ std::forward<_Args>(__args)...);
#else
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
#endif
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
#if __cplusplus >= 201103L
_Alloc_traits::construct(this->_M_impl,
- this->_M_impl._M_start._M_cur,
- std::forward<_Args>(__args)...);
+ this->_M_impl._M_start._M_cur,
+ std::forward<_Args>(__args)...);
#else
this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t);
#endif
void
deque<_Tp, _Alloc>::
_M_range_insert_aux(iterator __pos,
- _InputIterator __first, _InputIterator __last,
- std::input_iterator_tag)
+ _InputIterator __first, _InputIterator __last,
+ std::input_iterator_tag)
{ std::copy(__first, __last, std::inserter(*this, __pos)); }
template <typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_range_insert_aux(iterator __pos,
- _ForwardIterator __first, _ForwardIterator __last,
- std::forward_iterator_tag)
+ _ForwardIterator __first, _ForwardIterator __last,
+ std::forward_iterator_tag)
{
- const size_type __n = std::distance(__first, __last);
- if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+ const size_type __n = std::distance(__first, __last);
+ if (__pos._M_cur == this->_M_impl._M_start._M_cur)
{
iterator __new_start = _M_reserve_elements_at_front(__n);
__try
__throw_exception_again;
}
}
- else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+ else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
{
iterator __new_finish = _M_reserve_elements_at_back(__n);
__try
__throw_exception_again;
}
}
- else
- _M_insert_aux(__pos, __first, __last, __n);
+ else
+ _M_insert_aux(__pos, __first, __last, __n);
}
template<typename _Tp, typename _Alloc>
void
deque<_Tp, _Alloc>::
_M_insert_aux(iterator __pos,
- _ForwardIterator __first, _ForwardIterator __last,
- size_type __n)
+ _ForwardIterator __first, _ForwardIterator __last,
+ size_type __n)
{
- const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
- const size_type __length = size();
- if (static_cast<size_type>(__elemsbefore) < __length / 2)
+ const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
+ const size_type __length = size();
+ if (static_cast<size_type>(__elemsbefore) < __length / 2)
{
iterator __new_start = _M_reserve_elements_at_front(__n);
iterator __old_start = this->_M_impl._M_start;
__throw_exception_again;
}
}
- else
- {
- iterator __new_finish = _M_reserve_elements_at_back(__n);
- iterator __old_finish = this->_M_impl._M_finish;
- const difference_type __elemsafter =
- difference_type(__length) - __elemsbefore;
- __pos = this->_M_impl._M_finish - __elemsafter;
- __try
- {
- if (__elemsafter > difference_type(__n))
+ else
+ {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ iterator __old_finish = this->_M_impl._M_finish;
+ const difference_type __elemsafter =
+ difference_type(__length) - __elemsbefore;
+ __pos = this->_M_impl._M_finish - __elemsafter;
+ __try
+ {
+ if (__elemsafter > difference_type(__n))
{
iterator __finish_n = (this->_M_impl._M_finish
- difference_type(__n));
_GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish);
std::copy(__first, __last, __pos);
}
- else
+ else
{
_ForwardIterator __mid = __first;
std::advance(__mid, __elemsafter);
this->_M_impl._M_finish = __new_finish;
std::copy(__first, __mid, __pos);
}
- }
- __catch(...)
- {
- _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+ }
+ __catch(...)
+ {
+ _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
__new_finish._M_node + 1);
- __throw_exception_again;
- }
- }
+ __throw_exception_again;
+ }
+ }
}
template<typename _Tp, typename _Alloc>
_M_reserve_map_at_front(__new_nodes);
size_type __i;
__try
- {
- for (__i = 1; __i <= __new_nodes; ++__i)
- *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
- }
+ {
+ for (__i = 1; __i <= __new_nodes; ++__i)
+ *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
+ }
__catch(...)
- {
- for (size_type __j = 1; __j < __i; ++__j)
- _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
- __throw_exception_again;
- }
+ {
+ for (size_type __j = 1; __j < __i; ++__j)
+ _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
+ __throw_exception_again;
+ }
}
template <typename _Tp, typename _Alloc>
_M_reserve_map_at_back(__new_nodes);
size_type __i;
__try
- {
- for (__i = 1; __i <= __new_nodes; ++__i)
- *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
- }
+ {
+ for (__i = 1; __i <= __new_nodes; ++__i)
+ *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
+ }
__catch(...)
- {
- for (size_type __j = 1; __j < __i; ++__j)
- _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
- __throw_exception_again;
- }
+ {
+ for (size_type __j = 1; __j < __i; ++__j)
+ _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
+ __throw_exception_again;
+ }
}
template <typename _Tp, typename _Alloc>
{
__new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
- __new_num_nodes) / 2
- + (__add_at_front ? __nodes_to_add : 0);
+ + (__add_at_front ? __nodes_to_add : 0);
if (__new_nstart < this->_M_impl._M_start._M_node)
std::copy(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1,
else
{
size_type __new_map_size = this->_M_impl._M_map_size
- + std::max(this->_M_impl._M_map_size,
+ + std::max(this->_M_impl._M_map_size,
__nodes_to_add) + 2;
_Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
- + (__add_at_front ? __nodes_to_add : 0);
+ + (__add_at_front ? __nodes_to_add : 0);
std::copy(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1,
__new_nstart);
struct _Deque_iterator
{
#if __cplusplus < 201103L
- typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
+ typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
- typedef _Tp* _Elt_pointer;
- typedef _Tp** _Map_pointer;
+ typedef _Tp* _Elt_pointer;
+ typedef _Tp** _Map_pointer;
#else
private:
- template<typename _Up>
- using __ptr_to = typename pointer_traits<_Ptr>::template rebind<_Up>;
template<typename _CvTp>
- using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_to<_CvTp>>;
+ using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_rebind<_Ptr, _CvTp>>;
public:
- typedef __iter<_Tp> iterator;
- typedef __iter<const _Tp> const_iterator;
- typedef __ptr_to<_Tp> _Elt_pointer;
- typedef __ptr_to<_Elt_pointer> _Map_pointer;
+ typedef __iter<_Tp> iterator;
+ typedef __iter<const _Tp> const_iterator;
+ typedef __ptr_rebind<_Ptr, _Tp> _Elt_pointer;
+ typedef __ptr_rebind<_Ptr, _Elt_pointer> _Map_pointer;
#endif
static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
#else
// Conversion from iterator to const_iterator.
template<typename _Iter,
- typename = _Require<is_same<_Self, const_iterator>,
- is_same<_Iter, iterator>>>
+ typename = _Require<is_same<_Self, const_iterator>,
+ is_same<_Iter, iterator>>>
_Deque_iterator(const _Iter& __x) noexcept
: _M_cur(__x._M_cur), _M_first(__x._M_first),
- _M_last(__x._M_last), _M_node(__x._M_node) { }
+ _M_last(__x._M_last), _M_node(__x._M_node) { }
_Deque_iterator(const _Deque_iterator&) = default;
_Deque_iterator& operator=(const _Deque_iterator&) = default;
_Map_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Map_alloc_type> _Map_alloc_traits;
- public:
typedef _Alloc allocator_type;
allocator_type
this->_M_impl._M_swap_data(__x._M_impl);
}
+ _Deque_base(_Deque_base&& __x, const allocator_type& __a)
+ : _M_impl(std::move(__x._M_impl), _Tp_alloc_type(__a))
+ { __x._M_initialize_map(0); }
+
_Deque_base(_Deque_base&& __x, const allocator_type& __a, size_t __n)
: _M_impl(__a)
{
~_Deque_base() _GLIBCXX_NOEXCEPT;
- protected:
typedef typename iterator::_Map_pointer _Map_pointer;
- //This struct encapsulates the implementation of the std::deque
- //standard container and at the same time makes use of the EBO
- //for empty allocators.
- struct _Deque_impl
- : public _Tp_alloc_type
+ struct _Deque_impl_data
{
_Map_pointer _M_map;
size_t _M_map_size;
iterator _M_start;
iterator _M_finish;
- _Deque_impl()
- : _Tp_alloc_type(), _M_map(), _M_map_size(0),
- _M_start(), _M_finish()
+ _Deque_impl_data() _GLIBCXX_NOEXCEPT
+ : _M_map(), _M_map_size(), _M_start(), _M_finish()
+ { }
+
+#if __cplusplus >= 201103L
+ _Deque_impl_data(const _Deque_impl_data&) = default;
+ _Deque_impl_data&
+ operator=(const _Deque_impl_data&) = default;
+
+ _Deque_impl_data(_Deque_impl_data&& __x) noexcept
+ : _Deque_impl_data(__x)
+ { __x = _Deque_impl_data(); }
+#endif
+
+ void
+ _M_swap_data(_Deque_impl_data& __x) _GLIBCXX_NOEXCEPT
+ {
+ // Do not use std::swap(_M_start, __x._M_start), etc as it loses
+ // information used by TBAA.
+ std::swap(*this, __x);
+ }
+ };
+
+ // This struct encapsulates the implementation of the std::deque
+ // standard container and at the same time makes use of the EBO
+ // for empty allocators.
+ struct _Deque_impl
+ : public _Tp_alloc_type, public _Deque_impl_data
+ {
+ _Deque_impl() _GLIBCXX_NOEXCEPT_IF(
+ is_nothrow_default_constructible<_Tp_alloc_type>::value)
+ : _Tp_alloc_type()
{ }
_Deque_impl(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
- : _Tp_alloc_type(__a), _M_map(), _M_map_size(0),
- _M_start(), _M_finish()
+ : _Tp_alloc_type(__a)
{ }
#if __cplusplus >= 201103L
_Deque_impl(_Deque_impl&&) = default;
_Deque_impl(_Tp_alloc_type&& __a) noexcept
- : _Tp_alloc_type(std::move(__a)), _M_map(), _M_map_size(0),
- _M_start(), _M_finish()
+ : _Tp_alloc_type(std::move(__a))
{ }
-#endif
- void _M_swap_data(_Deque_impl& __x) _GLIBCXX_NOEXCEPT
- {
- using std::swap;
- swap(this->_M_start, __x._M_start);
- swap(this->_M_finish, __x._M_finish);
- swap(this->_M_map, __x._M_map);
- swap(this->_M_map_size, __x._M_map_size);
- }
+ _Deque_impl(_Deque_impl&& __d, _Tp_alloc_type&& __a)
+ : _Tp_alloc_type(std::move(__a)), _Deque_impl_data(std::move(__d))
+ { }
+#endif
};
_Tp_alloc_type&
_M_get_Tp_allocator() _GLIBCXX_NOEXCEPT
- { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+ { return this->_M_impl; }
const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
- { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+ { return this->_M_impl; }
_Map_alloc_type
_M_get_map_allocator() const _GLIBCXX_NOEXCEPT
_Map_alloc_traits::deallocate(__map_alloc, __p, __n);
}
- protected:
void _M_initialize_map(size_t);
void _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish);
void _M_destroy_nodes(_Map_pointer __nstart,
_Deque_base<_Tp, _Alloc>::
_M_initialize_map(size_t __num_elements)
{
- const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
+ const size_t __num_nodes = (__num_elements / __deque_buf_size(sizeof(_Tp))
+ 1);
this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
typedef ptrdiff_t difference_type;
typedef _Alloc allocator_type;
- protected:
+ private:
static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); }
/**
* @brief Creates a %deque with no elements.
*/
- deque() : _Base() { }
+#if __cplusplus >= 201103L
+ deque() = default;
+#else
+ deque() { }
+#endif
/**
* @brief Creates a %deque with no elements.
#if __cplusplus >= 201103L
/**
* @brief %Deque move constructor.
- * @param __x A %deque of identical element and allocator types.
*
- * The newly-created %deque contains the exact contents of @a __x.
- * The contents of @a __x are a valid, but unspecified %deque.
+ * The newly-created %deque contains the exact contents of the
+ * moved instance.
+ * The contents of the moved instance are a valid, but unspecified
+ * %deque.
*/
- deque(deque&& __x)
- : _Base(std::move(__x)) { }
+ deque(deque&&) = default;
/// Copy constructor with alternative allocator
deque(const deque& __x, const allocator_type& __a)
/// Move constructor with alternative allocator
deque(deque&& __x, const allocator_type& __a)
+ : deque(std::move(__x), __a, typename _Alloc_traits::is_always_equal{})
+ { }
+
+ private:
+ deque(deque&& __x, const allocator_type& __a, true_type)
+ : _Base(std::move(__x), __a)
+ { }
+
+ deque(deque&& __x, const allocator_type& __a, false_type)
: _Base(std::move(__x), __a, __x.size())
{
- if (__x.get_allocator() != __a)
+ if (__x.get_allocator() != __a && !__x.empty())
{
std::__uninitialized_move_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
}
}
+ public:
/**
* @brief Builds a %deque from an initializer list.
* @param __l An initializer_list.
deque(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
- { _M_initialize_dispatch(__first, __last, __false_type()); }
+ {
+ _M_range_initialize(__first, __last,
+ std::__iterator_category(__first));
+ }
#else
template<typename _InputIterator>
deque(_InputIterator __first, _InputIterator __last,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
- { _M_assign_dispatch(__first, __last, __false_type()); }
+ { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
#else
template<typename _InputIterator>
void
*/
void
resize(size_type __new_size, const value_type& __x)
- {
- const size_type __len = size();
- if (__new_size > __len)
- _M_fill_insert(this->_M_impl._M_finish, __new_size - __len, __x);
- else if (__new_size < __len)
- _M_erase_at_end(this->_M_impl._M_start
- + difference_type(__new_size));
- }
#else
/**
* @brief Resizes the %deque to the specified number of elements.
*/
void
resize(size_type __new_size, value_type __x = value_type())
+#endif
{
const size_type __len = size();
if (__new_size > __len)
_M_erase_at_end(this->_M_impl._M_start
+ difference_type(__new_size));
}
-#endif
#if __cplusplus >= 201103L
/** A non-binding request to reduce memory use. */
if (this->_M_impl._M_start._M_cur
!= this->_M_impl._M_start._M_last - 1)
{
- _Alloc_traits::destroy(this->_M_impl,
+ _Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_start._M_cur);
++this->_M_impl._M_start._M_cur;
}
!= this->_M_impl._M_finish._M_first)
{
--this->_M_impl._M_finish._M_cur;
- _Alloc_traits::destroy(this->_M_impl,
+ _Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_finish._M_cur);
}
else
* @brief Inserts an initializer list into the %deque.
* @param __p An iterator into the %deque.
* @param __l An initializer_list.
+ * @return An iterator that points to the inserted data.
*
* This function will insert copies of the data in the
* initializer_list @a __l into the %deque before the location
std::random_access_iterator_tag());
return begin() + __offset;
}
-#endif
-#if __cplusplus >= 201103L
/**
* @brief Inserts a number of copies of given data into the %deque.
* @param __position A const_iterator into the %deque.
_InputIterator __last)
{
difference_type __offset = __position - cbegin();
- _M_insert_dispatch(__position._M_const_cast(),
- __first, __last, __false_type());
+ _M_range_insert_aux(__position._M_const_cast(), __first, __last,
+ std::__iterator_category(__first));
return begin() + __offset;
}
#else
protected:
// Internal constructor functions follow.
+#if __cplusplus < 201103L
// called by the range constructor to implement [23.1.1]/9
// _GLIBCXX_RESOLVE_LIB_DEFECTS
_M_fill_initialize(__x);
}
+ // called by the range constructor to implement [23.1.1]/9
+ template<typename _InputIterator>
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+ __false_type)
+ {
+ _M_range_initialize(__first, __last,
+ std::__iterator_category(__first));
+ }
+#endif
+
static size_t
_S_check_init_len(size_t __n, const allocator_type& __a)
{
return (std::min)(__diffmax, __allocmax);
}
- // called by the range constructor to implement [23.1.1]/9
- template<typename _InputIterator>
- void
- _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
- __false_type)
- {
- _M_range_initialize(__first, __last,
- std::__iterator_category(__first));
- }
-
// called by the second initialize_dispatch above
//@{
/**
// Internal assign functions follow. The *_aux functions do the actual
// assignment work for the range versions.
+#if __cplusplus < 201103L
// called by the range assign to implement [23.1.1]/9
// _GLIBCXX_RESOLVE_LIB_DEFECTS
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{ _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+#endif
// called by the second assign_dispatch above
template<typename _InputIterator>
// Internal insert functions follow. The *_aux functions do the actual
// insertion work when all shortcuts fail.
+#if __cplusplus < 201103L
// called by the range insert to implement [23.1.1]/9
// _GLIBCXX_RESOLVE_LIB_DEFECTS
_M_range_insert_aux(__pos, __first, __last,
std::__iterator_category(__first));
}
+#endif
// called by the second insert_dispatch above
template<typename _InputIterator>
--- /dev/null
+// 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-do run { target c++11 } }
+// { dg-options "-O0" }
+// { dg-xfail-run-if "PR c++/65816" { *-*-* } }
+
+#include <deque>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+#include <ext/aligned_buffer.h>
+
+using T = int;
+
+using __gnu_test::default_init_allocator;
+
+void test01()
+{
+ typedef default_init_allocator<T> alloc_type;
+ typedef std::deque<T, alloc_type> test_type;
+
+ __gnu_cxx::__aligned_buffer<test_type> buf;
+ __builtin_memset(buf._M_addr(), ~0, sizeof(test_type));
+
+ test_type *tmp = ::new(buf._M_addr()) test_type;
+
+ VERIFY( tmp->get_allocator().state == 0 );
+
+ tmp->~test_type();
+}
+
+void test02()
+{
+ typedef default_init_allocator<T> alloc_type;
+ typedef std::deque<T, alloc_type> test_type;
+
+ __gnu_cxx::__aligned_buffer<test_type> buf;
+ __builtin_memset(buf._M_addr(), ~0, sizeof(test_type));
+
+ test_type *tmp = ::new(buf._M_addr()) test_type();
+
+ VERIFY( tmp->get_allocator().state == 0 );
+
+ tmp->~test_type();
+}
+
+int main()
+{
+ test01();
+ test02();
+ return 0;
+}
projects / platform / upstream / gcc.git / commitdiff