From: François Dumont Date: Sat, 24 May 2014 20:59:00 +0000 (+0000) Subject: array: Clean useless white chars. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=f3de79d43a924e3984ab3299ac7a38f5a4aabdf5;p=gcc.git array: Clean useless white chars. 2014-05-24 François Dumont * include/profile/array: Clean useless white chars. * include/profile/base.h: Likewise. * include/profile/iterator_tracker.h: Likewise. * include/profile/bitset: Code cleanup and remove not instrumented code. * include/profile/deque: Likewise. * include/profile/forward_list: Likewise. * include/profile/list (std::__profile::_List_profile<>): New. (std::__profile::list<>): Inherit from latter and adapt. * include/profile/impl/profiler_map_to_unordered_map.h: Generalize advise to match any ordered to unordered container conversion. * include/profile/ordered_base.h (std::__profile::_Ordered_profile<>): New. * include/Makefile.am: Add latter. * include/Makefile.in: Regenerate. * include/profile/map.h (std::__profile::map<>): Inherit from latter, remove not instrumented code. * include/profile/multimap.h (std::__profile::multimap<>): Likewise. * include/profile/set.h (std::__profile::set<>): Likewise. * include/profile/multiset.h (std::__profile::multiset<>): Likewise. * include/profile/unordered_base.h: Add some line feed. * include/profile/unordered_map: Clean useless white chars and replace spaces with tabs. * include/profile/unordered_set: Likewise. * include/profile/vector (std::__profile::_Vector_profile_pre<>): New. (std::__profile::_Vector_profile_post<>): New. (std::__profile::vector<>): Inherit from latter and adapt. From-SVN: r210900 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 6d6417dda2c..c2e7127b56a 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,32 @@ +2014-05-24 François Dumont + + * include/profile/array: Clean useless white chars. + * include/profile/base.h: Likewise. + * include/profile/iterator_tracker.h: Likewise. + * include/profile/bitset: Code cleanup and remove not instrumented code. + * include/profile/deque: Likewise. + * include/profile/forward_list: Likewise. + * include/profile/list (std::__profile::_List_profile<>): New. + (std::__profile::list<>): Inherit from latter and adapt. + * include/profile/impl/profiler_map_to_unordered_map.h: Generalize + advise to match any ordered to unordered container conversion. + * include/profile/ordered_base.h (std::__profile::_Ordered_profile<>): + New. + * include/Makefile.am: Add latter. + * include/Makefile.in: Regenerate. + * include/profile/map.h (std::__profile::map<>): Inherit from latter, + remove not instrumented code. + * include/profile/multimap.h (std::__profile::multimap<>): Likewise. + * include/profile/set.h (std::__profile::set<>): Likewise. + * include/profile/multiset.h (std::__profile::multiset<>): Likewise. + * include/profile/unordered_base.h: Add some line feed. + * include/profile/unordered_map: Clean useless white chars and replace + spaces with tabs. + * include/profile/unordered_set: Likewise. + * include/profile/vector (std::__profile::_Vector_profile_pre<>): New. + (std::__profile::_Vector_profile_post<>): New. + (std::__profile::vector<>): Inherit from latter and adapt. + 2014-05-23 Jonathan Wakely PR libstdc++/60793 diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 0d676dbdf39..a079ff6af0b 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -816,6 +816,7 @@ profile_headers = \ ${profile_srcdir}/map.h \ ${profile_srcdir}/multimap.h \ ${profile_srcdir}/multiset.h \ + ${profile_srcdir}/ordered_base.h \ ${profile_srcdir}/set \ ${profile_srcdir}/set.h \ ${profile_srcdir}/iterator_tracker.h diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index be525f77b3e..502f04e0490 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -1079,6 +1079,7 @@ profile_headers = \ ${profile_srcdir}/map.h \ ${profile_srcdir}/multimap.h \ ${profile_srcdir}/multiset.h \ + ${profile_srcdir}/ordered_base.h \ ${profile_srcdir}/set \ ${profile_srcdir}/set.h \ ${profile_srcdir}/iterator_tracker.h diff --git a/libstdc++-v3/include/profile/array b/libstdc++-v3/include/profile/array index 1a43a4888d7..3561c761525 100644 --- a/libstdc++-v3/include/profile/array +++ b/libstdc++-v3/include/profile/array @@ -83,19 +83,19 @@ namespace __profile end() const noexcept { return const_iterator(data() + _Nm); } - reverse_iterator + reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } - const_reverse_iterator + const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } - reverse_iterator + reverse_iterator rend() noexcept { return reverse_iterator(begin()); } - const_reverse_iterator + const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } @@ -107,22 +107,22 @@ namespace __profile cend() const noexcept { return const_iterator(data() + _Nm); } - const_reverse_iterator + const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } - const_reverse_iterator + const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } // Capacity. - constexpr size_type + constexpr size_type size() const noexcept { return _Nm; } - constexpr size_type + constexpr size_type max_size() const noexcept { return _Nm; } - constexpr bool + constexpr bool empty() const noexcept { return size() == 0; } // Element access. @@ -157,23 +157,23 @@ namespace __profile _AT_Type::_S_ref(_M_elems, 0)); } - reference + reference front() noexcept { return *begin(); } - constexpr const_reference + constexpr const_reference front() const noexcept { return _AT_Type::_S_ref(_M_elems, 0); } - reference + reference back() noexcept { return _Nm ? *(end() - 1) : *end(); } - constexpr const_reference + constexpr const_reference back() const noexcept { return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) - : _AT_Type::_S_ref(_M_elems, 0); + : _AT_Type::_S_ref(_M_elems, 0); } pointer @@ -187,7 +187,7 @@ namespace __profile // Array comparisons. template - inline bool + inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::equal(__one.begin(), __one.end(), __two.begin()); } @@ -199,9 +199,9 @@ namespace __profile template inline bool operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) - { + { return std::lexicographical_compare(__a.begin(), __a.end(), - __b.begin(), __b.end()); + __b.begin(), __b.end()); } template diff --git a/libstdc++-v3/include/profile/base.h b/libstdc++-v3/include/profile/base.h index 342bb704288..9ca0c3f4aba 100644 --- a/libstdc++-v3/include/profile/base.h +++ b/libstdc++-v3/include/profile/base.h @@ -40,9 +40,9 @@ * @namespace std::__profile * @brief GNU profile code, replaces standard behavior with profile behavior. */ -namespace std _GLIBCXX_VISIBILITY(default) -{ - namespace __profile { } +namespace std _GLIBCXX_VISIBILITY(default) +{ + namespace __profile { } } /** diff --git a/libstdc++-v3/include/profile/bitset b/libstdc++-v3/include/profile/bitset index a9f37aaf1b5..651f25cd885 100644 --- a/libstdc++-v3/include/profile/bitset +++ b/libstdc++-v3/include/profile/bitset @@ -35,7 +35,8 @@ namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { - /// Class std::bitset wrapper with performance instrumentation. + /// Class std::bitset wrapper with performance instrumentation, none at the + /// moment. template class bitset : public _GLIBCXX_STD_C::bitset<_Nb> @@ -43,60 +44,13 @@ namespace __profile typedef _GLIBCXX_STD_C::bitset<_Nb> _Base; public: - // bit reference: - class reference - : private _Base::reference - { - typedef typename _Base::reference _Base_ref; - - friend class bitset; - reference(); - - reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT - : _Base_ref(__base) - { } - - public: - reference(const reference& __x) _GLIBCXX_NOEXCEPT - : _Base_ref(__x) - { } - - reference& - operator=(bool __x) _GLIBCXX_NOEXCEPT - { - *static_cast<_Base_ref*>(this) = __x; - return *this; - } - - reference& - operator=(const reference& __x) _GLIBCXX_NOEXCEPT - { - *static_cast<_Base_ref*>(this) = __x; - return *this; - } - - bool - operator~() const _GLIBCXX_NOEXCEPT - { - return ~(*static_cast(this)); - } - - operator bool() const _GLIBCXX_NOEXCEPT - { - return *static_cast(this); - } - - reference& - flip() _GLIBCXX_NOEXCEPT - { - _Base_ref::flip(); - return *this; - } - }; - // 23.3.5.1 constructors: - _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT +#if __cplusplus < 201103L + bitset() : _Base() { } +#else + constexpr bitset() = default; +#endif #if __cplusplus >= 201103L constexpr bitset(unsigned long long __val) noexcept @@ -106,8 +60,8 @@ namespace __profile : _Base(__val) { } template - explicit - bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, + explicit + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, typename std::basic_string<_CharT, _Traits, _Alloc>::size_type __pos = 0, typename std::basic_string<_CharT, _Traits, _Alloc>::size_type @@ -129,8 +83,8 @@ namespace __profile #if __cplusplus >= 201103L template - explicit - bitset(const _CharT* __str, + explicit + bitset(const _CharT* __str, typename std::basic_string<_CharT>::size_type __n = std::basic_string<_CharT>::npos, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) @@ -221,92 +175,6 @@ namespace __profile return *this; } - // element access: - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 11. Bitset minor problems - reference - operator[](size_t __pos) - { - return reference(_M_base()[__pos], this); - } - - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 11. Bitset minor problems - _GLIBCXX_CONSTEXPR bool - operator[](size_t __pos) const - { - return _Base::operator[](__pos); - } - - using _Base::to_ulong; -#if __cplusplus >= 201103L - using _Base::to_ullong; -#endif - - template - std::basic_string<_CharT, _Traits, _Alloc> - to_string() const - { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); } - - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 396. what are characters zero and one. - template - std::basic_string<_CharT, _Traits, _Alloc> - to_string(_CharT __zero, _CharT __one = _CharT('1')) const - { - return _M_base().template - to_string<_CharT, _Traits, _Alloc>(__zero, __one); - } - - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 434. bitset::to_string() hard to use. - template - std::basic_string<_CharT, _Traits, std::allocator<_CharT> > - to_string() const - { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } - - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 853. to_string needs updating with zero and one. - template - std::basic_string<_CharT, _Traits, std::allocator<_CharT> > - to_string(_CharT __zero, _CharT __one = _CharT('1')) const - { return to_string<_CharT, _Traits, - std::allocator<_CharT> >(__zero, __one); } - - template - std::basic_string<_CharT, std::char_traits<_CharT>, - std::allocator<_CharT> > - to_string() const - { - return to_string<_CharT, std::char_traits<_CharT>, - std::allocator<_CharT> >(); - } - - template - std::basic_string<_CharT, std::char_traits<_CharT>, - std::allocator<_CharT> > - to_string(_CharT __zero, _CharT __one = _CharT('1')) const - { - return to_string<_CharT, std::char_traits<_CharT>, - std::allocator<_CharT> >(__zero, __one); - } - - std::basic_string, std::allocator > - to_string() const - { - return to_string,std::allocator >(); - } - - std::basic_string, std::allocator > - to_string(char __zero, char __one = '1') const - { - return to_string, - std::allocator >(__zero, __one); - } - - using _Base::count; - using _Base::size; - bool operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT { return _M_base() == __rhs; } @@ -315,11 +183,6 @@ namespace __profile operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT { return _M_base() != __rhs; } - using _Base::test; - using _Base::all; - using _Base::any; - using _Base::none; - bitset<_Nb> operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT { return bitset<_Nb>(_M_base() << __pos); } diff --git a/libstdc++-v3/include/profile/deque b/libstdc++-v3/include/profile/deque index 2c4f9cbd019..13513f4bdc7 100644 --- a/libstdc++-v3/include/profile/deque +++ b/libstdc++-v3/include/profile/deque @@ -43,26 +43,29 @@ namespace __profile typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base; public: - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; - typedef typename _Base::reverse_iterator reverse_iterator; - typedef typename _Base::const_reverse_iterator const_reverse_iterator; - - typedef typename _Base::size_type size_type; - typedef typename _Base::difference_type difference_type; - - typedef _Tp value_type; - typedef _Allocator allocator_type; - typedef typename _Base::pointer pointer; - typedef typename _Base::const_pointer const_pointer; + typedef typename _Base::size_type size_type; + typedef typename _Base::value_type value_type; // 23.2.1.1 construct/copy/destroy: +#if __cplusplus < 201103L deque() : _Base() { } + deque(const deque& __x) + : _Base(__x) { } + + ~deque() { } +#else + deque() = default; + deque(const deque&) = default; + deque(deque&&) = default; + + ~deque() = default; + + deque(initializer_list __l, + const _Allocator& __a = _Allocator()) + : _Base(__l, __a) { } +#endif explicit deque(const _Allocator& __a) @@ -89,346 +92,48 @@ namespace __profile #else template #endif - deque(_InputIterator __first, _InputIterator __last, + deque(_InputIterator __first, _InputIterator __last, const _Allocator& __a = _Allocator()) : _Base(__first, __last, __a) - { } - - deque(const deque& __x) - : _Base(__x) { } + { } deque(const _Base& __x) : _Base(__x) { } -#if __cplusplus >= 201103L - deque(deque&& __x) - : _Base(std::move(__x)) - { } - - deque(initializer_list __l, - const allocator_type& __a = allocator_type()) - : _Base(__l, __a) { } -#endif - - ~deque() _GLIBCXX_NOEXCEPT { } - +#if __cplusplus < 201103L deque& operator=(const deque& __x) { - *static_cast<_Base*>(this) = __x; + _M_base() = __x; return *this; } +#else + deque& + operator=(const deque&) = default; -#if __cplusplus >= 201103L deque& - operator=(deque&& __x) noexcept - { - // NB: DR 1204. - // NB: DR 675. - this->clear(); - this->swap(__x); - return *this; - } + operator=(deque&&) = default; deque& operator=(initializer_list __l) { - *static_cast<_Base*>(this) = __l; + _M_base() = __l; return *this; } #endif -#if __cplusplus >= 201103L - template> -#else - template -#endif - void - assign(_InputIterator __first, _InputIterator __last) - { - _Base::assign(__first, __last); - } - - void - assign(size_type __n, const _Tp& __t) - { - _Base::assign(__n, __t); - } - -#if __cplusplus >= 201103L - void - assign(initializer_list __l) - { - _Base::assign(__l); - } -#endif - - using _Base::get_allocator; - - // iterators: - iterator - begin() _GLIBCXX_NOEXCEPT - { return iterator(_Base::begin()); } - - const_iterator - begin() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::begin()); } - - iterator - end() _GLIBCXX_NOEXCEPT - { return iterator(_Base::end()); } - - const_iterator - end() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::end()); } - - reverse_iterator - rbegin() _GLIBCXX_NOEXCEPT - { return reverse_iterator(end()); } - - const_reverse_iterator - rbegin() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(end()); } - - reverse_iterator - rend() _GLIBCXX_NOEXCEPT - { return reverse_iterator(begin()); } - - const_reverse_iterator - rend() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(begin()); } - -#if __cplusplus >= 201103L - const_iterator - cbegin() const noexcept - { return const_iterator(_Base::begin()); } - - const_iterator - cend() const noexcept - { return const_iterator(_Base::end()); } - - const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } -#endif - - // 23.2.1.2 capacity: - using _Base::size; - using _Base::max_size; - -#if __cplusplus >= 201103L - void - resize(size_type __sz) - { - _Base::resize(__sz); - } - - void - resize(size_type __sz, const _Tp& __c) - { - _Base::resize(__sz, __c); - } -#else void - resize(size_type __sz, _Tp __c = _Tp()) - { - _Base::resize(__sz, __c); - } -#endif - + swap(deque& __x) #if __cplusplus >= 201103L - using _Base::shrink_to_fit; + noexcept( noexcept(declval<_Base>().swap(__x)) ) #endif - - using _Base::empty; - - // element access: - reference - operator[](size_type __n) _GLIBCXX_NOEXCEPT - { - return _M_base()[__n]; - } - - const_reference - operator[](size_type __n) const _GLIBCXX_NOEXCEPT - { - return _M_base()[__n]; - } - - using _Base::at; - - reference - front() _GLIBCXX_NOEXCEPT - { - return _Base::front(); - } - - const_reference - front() const _GLIBCXX_NOEXCEPT - { - return _Base::front(); - } - - reference - back() _GLIBCXX_NOEXCEPT - { - return _Base::back(); - } - - const_reference - back() const _GLIBCXX_NOEXCEPT - { - return _Base::back(); - } - - // 23.2.1.3 modifiers: - void - push_front(const _Tp& __x) - { - _Base::push_front(__x); - } - - void - push_back(const _Tp& __x) - { - _Base::push_back(__x); - } - -#if __cplusplus >= 201103L - void - push_front(_Tp&& __x) - { emplace_front(std::move(__x)); } - - void - push_back(_Tp&& __x) - { emplace_back(std::move(__x)); } - - template - void - emplace_front(_Args&&... __args) - { - _Base::emplace_front(std::forward<_Args>(__args)...); - } - - template - void - emplace_back(_Args&&... __args) - { - _Base::emplace_back(std::forward<_Args>(__args)...); - } - - template - iterator - emplace(const_iterator __position, _Args&&... __args) - { - typename _Base::iterator __res = _Base::emplace(__position, - std::forward<_Args>(__args)...); - return iterator(__res); - } -#endif - - iterator -#if __cplusplus >= 201103L - insert(const_iterator __position, const _Tp& __x) -#else - insert(iterator __position, const _Tp& __x) -#endif - { - typename _Base::iterator __res = _Base::insert(__position, __x); - return iterator(__res); - } - -#if __cplusplus >= 201103L - iterator - insert(const_iterator __position, _Tp&& __x) - { return emplace(__position, std::move(__x)); } - - iterator - insert(const_iterator __p, initializer_list __l) - { return _Base::insert(__p, __l); } -#endif - -#if __cplusplus >= 201103L - iterator - insert(const_iterator __position, size_type __n, const _Tp& __x) - { return _Base::insert(__position, __n, __x); } -#else - void - insert(iterator __position, size_type __n, const _Tp& __x) - { _Base::insert(__position, __n, __x); } -#endif - -#if __cplusplus >= 201103L - template> - iterator - insert(const_iterator __position, - _InputIterator __first, _InputIterator __last) - { return _Base::insert(__position, __first, __last); } -#else - template - void - insert(iterator __position, - _InputIterator __first, _InputIterator __last) - { _Base::insert(__position, __first, __last); } -#endif - - void - pop_front() _GLIBCXX_NOEXCEPT - { - _Base::pop_front(); - } - - void - pop_back() _GLIBCXX_NOEXCEPT - { - _Base::pop_back(); - } - - iterator -#if __cplusplus >= 201103L - erase(const_iterator __position) -#else - erase(iterator __position) -#endif - { - return _Base::erase(__position); - } - - iterator -#if __cplusplus >= 201103L - erase(const_iterator __first, const_iterator __last) -#else - erase(iterator __first, iterator __last) -#endif - { - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 151. can't currently clear() empty container - return _Base::erase(__first, __last); - } - - void - swap(deque& __x) _GLIBCXX_NOEXCEPT - { - _Base::swap(__x); - } - - void - clear() _GLIBCXX_NOEXCEPT - { - _Base::clear(); - } + { _Base::swap(__x); } _Base& - _M_base() _GLIBCXX_NOEXCEPT { return *this; } + _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& - _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } }; template diff --git a/libstdc++-v3/include/profile/forward_list b/libstdc++-v3/include/profile/forward_list index 260f1d65b4b..290e4f9d703 100644 --- a/libstdc++-v3/include/profile/forward_list +++ b/libstdc++-v3/include/profile/forward_list @@ -46,13 +46,9 @@ namespace __profile { typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base; - typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template - rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type; - - typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits; - public: - typedef typename _Base::size_type size_type; + typedef typename _Base::size_type size_type; + typedef typename _Base::const_iterator const_iterator; // 23.2.3.1 construct/copy/destroy: explicit @@ -73,98 +69,135 @@ namespace __profile { } forward_list(size_type __n, const _Tp& __value, - const _Alloc& __al = _Alloc()) + const _Alloc& __al = _Alloc()) : _Base(__n, __value, __al) { } template> - forward_list(_InputIterator __first, _InputIterator __last, - const _Alloc& __al = _Alloc()) - : _Base(__first, __last, __al) - { } - - forward_list(const forward_list& __list) - : _Base(__list) - { } + forward_list(_InputIterator __first, _InputIterator __last, + const _Alloc& __al = _Alloc()) + : _Base(__first, __last, __al) + { } - forward_list(forward_list&& __list) noexcept - : _Base(std::move(__list)) { } + forward_list(const forward_list&) = default; + forward_list(forward_list&&) = default; forward_list(std::initializer_list<_Tp> __il, - const _Alloc& __al = _Alloc()) + const _Alloc& __al = _Alloc()) : _Base(__il, __al) { } - ~forward_list() noexcept - { } + ~forward_list() = default; forward_list& - operator=(const forward_list& __list) - { - static_cast<_Base&>(*this) = __list; - return *this; - } + operator=(const forward_list&) = default; forward_list& - operator=(forward_list&& __list) - noexcept(_Node_alloc_traits::_S_nothrow_move()) - { - static_cast<_Base&>(*this) = std::move(__list); - return *this; - } + operator=(forward_list&&) = default; forward_list& operator=(std::initializer_list<_Tp> __il) { - static_cast<_Base&>(*this) = __il; - return *this; + _M_base() = __il; + return *this; } + void + swap(forward_list& __fl) + noexcept( noexcept(declval<_Base>().swap(__fl)) ) + { _Base::swap(__fl); } + + void + splice_after(const_iterator __pos, forward_list&& __fl) + { _Base::splice_after(__pos, std::move(__fl)); } + + void + splice_after(const_iterator __pos, forward_list& __list) + { _Base::splice_after(__pos, __list); } + + void + splice_after(const_iterator __pos, forward_list&& __list, + const_iterator __i) + { _Base::splice_after(__pos, std::move(__list), __i); } + + void + splice_after(const_iterator __pos, forward_list& __list, + const_iterator __i) + { _Base::splice_after(__pos, __list, __i); } + + void + splice_after(const_iterator __pos, forward_list&& __list, + const_iterator __before, const_iterator __last) + { _Base::splice_after(__pos, std::move(__list), __before, __last); } + + void + splice_after(const_iterator __pos, forward_list& __list, + const_iterator __before, const_iterator __last) + { _Base::splice_after(__pos, __list, __before, __last); } + + void + merge(forward_list&& __list) + { _Base::merge(std::move(__list)); } + + void + merge(forward_list& __list) + { _Base::merge(__list); } + + template + void + merge(forward_list&& __list, _Comp __comp) + { _Base::merge(std::move(__list), __comp); } + + template + void + merge(forward_list& __list, _Comp __comp) + { _Base::merge(__list, __comp); } + _Base& - _M_base() noexcept { return *this; } + _M_base() noexcept { return *this; } const _Base& - _M_base() const noexcept { return *this; } + _M_base() const noexcept { return *this; } }; template inline bool operator==(const forward_list<_Tp, _Alloc>& __lx, - const forward_list<_Tp, _Alloc>& __ly) + const forward_list<_Tp, _Alloc>& __ly) { return __lx._M_base() == __ly._M_base(); } template inline bool operator<(const forward_list<_Tp, _Alloc>& __lx, - const forward_list<_Tp, _Alloc>& __ly) + const forward_list<_Tp, _Alloc>& __ly) { return __lx._M_base() < __ly._M_base(); } template inline bool operator!=(const forward_list<_Tp, _Alloc>& __lx, - const forward_list<_Tp, _Alloc>& __ly) + const forward_list<_Tp, _Alloc>& __ly) { return !(__lx == __ly); } /// Based on operator< template inline bool operator>(const forward_list<_Tp, _Alloc>& __lx, - const forward_list<_Tp, _Alloc>& __ly) + const forward_list<_Tp, _Alloc>& __ly) { return (__ly < __lx); } /// Based on operator< template inline bool operator>=(const forward_list<_Tp, _Alloc>& __lx, - const forward_list<_Tp, _Alloc>& __ly) + const forward_list<_Tp, _Alloc>& __ly) { return !(__lx < __ly); } /// Based on operator< template inline bool operator<=(const forward_list<_Tp, _Alloc>& __lx, - const forward_list<_Tp, _Alloc>& __ly) + const forward_list<_Tp, _Alloc>& __ly) { return !(__ly < __lx); } /// See std::forward_list::swap(). diff --git a/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h b/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h index 4ef9da1edc7..c1b2da10765 100644 --- a/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h +++ b/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h @@ -40,7 +40,7 @@ namespace __gnu_profile __log2(std::size_t __size) { for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0; - -- __bit_count) + -- __bit_count) if ((2 << __bit_count) & __size) return __bit_count; return 0; @@ -48,7 +48,7 @@ namespace __gnu_profile inline float __map_insert_cost(std::size_t __size) - { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value + { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value * static_cast(__log2(__size))); } inline float @@ -61,7 +61,7 @@ namespace __gnu_profile { return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value * static_cast(__log2(__size))); } - /** @brief A map-to-unordered_map instrumentation line in the + /** @brief A map-to-unordered_map instrumentation line in the object table. */ class __map2umap_info : public __object_info_base @@ -70,9 +70,9 @@ namespace __gnu_profile __map2umap_info() : _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { } - + __map2umap_info(__stack_t __stack) - : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), + : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { } virtual ~__map2umap_info() { } @@ -108,32 +108,38 @@ namespace __gnu_profile std::string __advice() const - { return "change std::map to std::unordered_map"; } + { return "prefer an unordered container"; } void __record_insert(std::size_t __size, std::size_t __count) { - _M_insert += __count; - _M_map_cost += __count * __map_insert_cost(__size); - _M_umap_cost - += (__count - * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value); + ++_M_insert; + if (__count) + { + _M_map_cost += __count * __map_insert_cost(__size); + _M_umap_cost + += (__count + * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value); + } } void __record_erase(std::size_t __size, std::size_t __count) { - _M_erase += __count; - _M_map_cost += __count * __map_erase_cost(__size); - _M_umap_cost - += (__count - * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value); + ++_M_erase; + if (__count) + { + _M_map_cost += __count * __map_erase_cost(__size); + _M_umap_cost + += (__count + * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value); + } } void __record_find(std::size_t __size) { - _M_find += 1; + ++_M_find; _M_map_cost += __map_find_cost(__size); _M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value; } @@ -165,9 +171,9 @@ namespace __gnu_profile }; - /** @brief A map-to-unordered_map instrumentation line in the + /** @brief A map-to-unordered_map instrumentation line in the stack table. */ - class __map2umap_stack_info + class __map2umap_stack_info : public __map2umap_info { public: @@ -177,12 +183,12 @@ namespace __gnu_profile /** @brief Map-to-unordered_map instrumentation producer. */ class __trace_map2umap - : public __trace_base<__map2umap_info, __map2umap_stack_info> + : public __trace_base<__map2umap_info, __map2umap_stack_info> { public: __trace_map2umap() : __trace_base<__map2umap_info, __map2umap_stack_info>() - { __id = "map-to-unordered-map"; } + { __id = "ordered-to-unordered"; } }; inline void @@ -193,7 +199,7 @@ namespace __gnu_profile __trace_map_to_unordered_map_report(FILE* __f, __warning_vector_t& __warnings) { - if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) + if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) { _GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings); _GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f); @@ -220,7 +226,7 @@ namespace __gnu_profile } inline void - __trace_map_to_unordered_map_insert(const void* __obj, + __trace_map_to_unordered_map_insert(const void* __obj, std::size_t __size, std::size_t __count) { if (!__profcxx_init()) @@ -234,13 +240,13 @@ namespace __gnu_profile } inline void - __trace_map_to_unordered_map_erase(const void* __obj, + __trace_map_to_unordered_map_erase(const void* __obj, std::size_t __size, std::size_t __count) { - if (!__profcxx_init()) + if (!__profcxx_init()) return; - __map2umap_info* __info + __map2umap_info* __info = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); if (__info) @@ -268,7 +274,7 @@ namespace __gnu_profile __map2umap_info* __info = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); - + if (__info) __info->__record_iterate(__count); } diff --git a/libstdc++-v3/include/profile/iterator_tracker.h b/libstdc++-v3/include/profile/iterator_tracker.h index df92c84295a..9b2aeab5e83 100644 --- a/libstdc++-v3/include/profile/iterator_tracker.h +++ b/libstdc++-v3/include/profile/iterator_tracker.h @@ -35,9 +35,8 @@ namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { - template - class __iterator_tracker + class __iterator_tracker { typedef __iterator_tracker _Self; @@ -49,12 +48,12 @@ namespace __profile typedef std::iterator_traits<_Iterator> _Traits; public: - typedef _Iterator _Base_iterator; - typedef typename _Traits::iterator_category iterator_category; - typedef typename _Traits::value_type value_type; - typedef typename _Traits::difference_type difference_type; - typedef typename _Traits::reference reference; - typedef typename _Traits::pointer pointer; + typedef _Iterator _Base_iterator; + typedef typename _Traits::iterator_category iterator_category; + typedef typename _Traits::value_type value_type; + typedef typename _Traits::difference_type difference_type; + typedef typename _Traits::reference reference; + typedef typename _Traits::pointer pointer; __iterator_tracker() _GLIBCXX_NOEXCEPT : _M_current(), _M_ds(0) { } @@ -67,7 +66,7 @@ namespace __profile : _M_current(__x._M_current), _M_ds(__x._M_ds) { } template - __iterator_tracker(const __iterator_tracker<_MutableIterator, + __iterator_tracker(const __iterator_tracker<_MutableIterator, typename __gnu_cxx::__enable_if <(std::__are_same<_MutableIterator, typename _Sequence::iterator::_Base_iterator>::__value), @@ -76,7 +75,7 @@ namespace __profile _Iterator base() const _GLIBCXX_NOEXCEPT { return _M_current; } - + /** * @brief Conversion to underlying non-debug iterator to allow * better interaction with non-profile containers. @@ -199,7 +198,7 @@ namespace __profile template inline bool operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) + const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() != __rhs.base(); } diff --git a/libstdc++-v3/include/profile/list b/libstdc++-v3/include/profile/list index 87d99a0b93d..438b440108c 100644 --- a/libstdc++-v3/include/profile/list +++ b/libstdc++-v3/include/profile/list @@ -30,81 +30,109 @@ #define _GLIBCXX_PROFILE_LIST 1 #include -#include -#include +#include +#include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { + template + class _List_profile + { + _List& + _M_conjure() + { return *static_cast<_List*>(this); } + + public: + _List_profile() _GLIBCXX_NOEXCEPT + { + __profcxx_list_construct(&_M_conjure()); // list2slist + __profcxx_list_construct2(&_M_conjure()); // list2vector + } + +#if __cplusplus >= 201103L + _List_profile(const _List_profile&) noexcept + : _List_profile() { } + _List_profile(_List_profile&&) noexcept + : _List_profile() { } + + _List_profile& + operator=(const _List_profile&) = default; + _List_profile& + operator=(_List_profile&&) = default; +#endif + + ~_List_profile() + { + __profcxx_list_destruct(&_M_conjure()); + __profcxx_list_destruct2(&_M_conjure()); + } + }; + /** @brief List wrapper with performance instrumentation. */ -template > + template > class list - : public _GLIBCXX_STD_C::list<_Tp, _Allocator> + : public _GLIBCXX_STD_C::list<_Tp, _Allocator>, + public _List_profile > { - typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base; + typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base; public: - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; - typedef __iterator_tracker - iterator; - typedef __iterator_tracker - const_iterator; + typedef __iterator_tracker + iterator; + typedef __iterator_tracker + const_iterator; - typedef typename _Base::size_type size_type; - typedef typename _Base::difference_type difference_type; + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; - typedef _Tp value_type; - typedef _Allocator allocator_type; - typedef typename _Base::pointer pointer; - typedef typename _Base::const_pointer const_pointer; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; // 23.2.2.1 construct/copy/destroy: - list() _GLIBCXX_NOEXCEPT - : _Base() - { - __profcxx_list_construct(this); // list2slist - __profcxx_list_construct2(this); // list2vector - } +#if __cplusplus < 201103L + list() { } + list(const list& __x) + : _Base(__x) { } + + ~list() { } +#else + list() = default; + list(const list&) = default; + list(list&&) = default; + ~list() = default; + + list(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__l, __a) { } +#endif explicit list(const _Allocator& __a) _GLIBCXX_NOEXCEPT - : _Base(__a) - { - __profcxx_list_construct(this); // list2slist - __profcxx_list_construct2(this); // list2vector - } + : _Base(__a) { } #if __cplusplus >= 201103L explicit list(size_type __n) - : _Base(__n) - { - __profcxx_list_construct(this); - __profcxx_list_construct2(this); - } + : _Base(__n) { } list(size_type __n, const _Tp& __value, const _Allocator& __a = _Allocator()) - : _Base(__n, __value, __a) - { - __profcxx_list_construct(this); - __profcxx_list_construct2(this); - } + : _Base(__n, __value, __a) { } #else explicit list(size_type __n, const _Tp& __value = _Tp(), const _Allocator& __a = _Allocator()) - : _Base(__n, __value, __a) - { - __profcxx_list_construct(this); - __profcxx_list_construct2(this); - } + : _Base(__n, __value, __a) { } #endif #if __cplusplus >= 201103L @@ -115,91 +143,33 @@ template > #endif list(_InputIterator __first, _InputIterator __last, const _Allocator& __a = _Allocator()) - : _Base(__first, __last, __a) - { - __profcxx_list_construct(this); - __profcxx_list_construct2(this); - } - - list(const list& __x) - : _Base(__x) - { - __profcxx_list_construct(this); - __profcxx_list_construct2(this); - } + : _Base(__first, __last, __a) { } list(const _Base& __x) - : _Base(__x) - { - __profcxx_list_construct(this); - __profcxx_list_construct2(this); - } - -#if __cplusplus >= 201103L - list(list&& __x) noexcept - : _Base(std::move(__x)) - { - __profcxx_list_construct(this); - __profcxx_list_construct2(this); - } - - list(initializer_list __l, - const allocator_type& __a = allocator_type()) - : _Base(__l, __a) { } -#endif - - ~list() _GLIBCXX_NOEXCEPT - { - __profcxx_list_destruct(this); - __profcxx_list_destruct2(this); - } + : _Base(__x) { } +#if __cplusplus < 201103L list& operator=(const list& __x) { - static_cast<_Base&>(*this) = __x; + _M_base() = __x; return *this; } +#else + list& + operator=(const list&) = default; -#if __cplusplus >= 201103L list& - operator=(list&& __x) - { - // NB: DR 1204. - // NB: DR 675. - this->clear(); - this->swap(__x); - return *this; - } + operator=(list&&) = default; list& operator=(initializer_list __l) { - static_cast<_Base&>(*this) = __l; + _M_base() = __l; return *this; } - - void - assign(initializer_list __l) - { _Base::assign(__l); } #endif -#if __cplusplus >= 201103L - template> -#else - template -#endif - void - assign(_InputIterator __first, _InputIterator __last) - { _Base::assign(__first, __last); } - - void - assign(size_type __n, const _Tp& __t) - { _Base::assign(__n, __t); } - - using _Base::get_allocator; - // iterators: iterator begin() _GLIBCXX_NOEXCEPT @@ -212,29 +182,29 @@ template > iterator end() _GLIBCXX_NOEXCEPT { - __profcxx_list_rewind(this); - return iterator(_Base::end(), this); + __profcxx_list_rewind(this); + return iterator(_Base::end(), this); } const_iterator end() const _GLIBCXX_NOEXCEPT { - __profcxx_list_rewind(this); - return const_iterator(_Base::end(), this); + __profcxx_list_rewind(this); + return const_iterator(_Base::end(), this); } reverse_iterator rbegin() _GLIBCXX_NOEXCEPT { - __profcxx_list_rewind(this); - return reverse_iterator(end()); + __profcxx_list_rewind(this); + return reverse_iterator(end()); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT - { - __profcxx_list_rewind(this); - return const_reverse_iterator(end()); + { + __profcxx_list_rewind(this); + return const_reverse_iterator(end()); } reverse_iterator @@ -248,11 +218,11 @@ template > #if __cplusplus >= 201103L const_iterator cbegin() const noexcept - { return const_iterator(_Base::begin(), this); } + { return const_iterator(_Base::cbegin(), this); } const_iterator cend() const noexcept - { return const_iterator(_Base::end(), this); } + { return const_iterator(_Base::cend(), this); } const_reverse_iterator crbegin() const noexcept @@ -264,44 +234,17 @@ template > #endif // 23.2.2.2 capacity: - using _Base::empty; - using _Base::size; - using _Base::max_size; - -#if __cplusplus >= 201103L - void - resize(size_type __sz) - { _Base::resize(__sz); } - - void - resize(size_type __sz, const _Tp& __c) - { _Base::resize(__sz, __c); } -#else - void - resize(size_type __sz, _Tp __c = _Tp()) - { _Base::resize(__sz, __c); } -#endif - - // element access: - reference - front() _GLIBCXX_NOEXCEPT - { return _Base::front(); } - - const_reference - front() const _GLIBCXX_NOEXCEPT - { return _Base::front(); } - reference back() _GLIBCXX_NOEXCEPT { - __profcxx_list_rewind(this); + __profcxx_list_rewind(this); return _Base::back(); } const_reference back() const _GLIBCXX_NOEXCEPT { - __profcxx_list_rewind(this); + __profcxx_list_rewind(this); return _Base::back(); } @@ -309,44 +252,32 @@ template > void push_front(const value_type& __x) { - __profcxx_list_invalid_operator(this); - __profcxx_list_operation(this); - _Base::push_front(__x); + __profcxx_list_invalid_operator(this); + __profcxx_list_operation(this); + _Base::push_front(__x); } -#if __cplusplus >= 201103L - using _Base::emplace_front; -#endif - void pop_front() _GLIBCXX_NOEXCEPT { - __profcxx_list_operation(this); + __profcxx_list_operation(this); _Base::pop_front(); } - using _Base::push_back; - -#if __cplusplus >= 201103L - using _Base::emplace_back; -#endif - void pop_back() _GLIBCXX_NOEXCEPT { - iterator __victim = end(); - --__victim; _Base::pop_back(); - __profcxx_list_rewind(this); + __profcxx_list_rewind(this); } #if __cplusplus >= 201103L template - iterator - emplace(const_iterator __position, _Args&&... __args) + iterator + emplace(const_iterator __position, _Args&&... __args) { return iterator(_Base::emplace(__position.base(), - std::forward<_Args>(__args)...), + std::forward<_Args>(__args)...), this); } #endif @@ -358,24 +289,24 @@ template > insert(iterator __position, const _Tp& __x) #endif { - _M_profile_insert(this, __position, size()); - return iterator(_Base::insert(__position.base(), __x), this); + _M_profile_insert(this, __position, this->size()); + return iterator(_Base::insert(__position.base(), __x), this); } #if __cplusplus >= 201103L iterator insert(const_iterator __position, _Tp&& __x) { - _M_profile_insert(this, __position, size()); - return iterator(_Base::emplace(__position.base(), std::move(__x)), - this); + _M_profile_insert(this, __position, this->size()); + return iterator(_Base::emplace(__position.base(), std::move(__x)), + this); } iterator insert(const_iterator __position, initializer_list __l) { - _M_profile_insert(this, __position, size()); - return iterator(_Base::insert(__position.base(), __l), this); + _M_profile_insert(this, __position, this->size()); + return iterator(_Base::insert(__position.base(), __l), this); } #endif @@ -383,14 +314,14 @@ template > iterator insert(const_iterator __position, size_type __n, const _Tp& __x) { - _M_profile_insert(this, __position, size()); + _M_profile_insert(this, __position, this->size()); return iterator(_Base::insert(__position.base(), __n, __x), this); } #else void insert(iterator __position, size_type __n, const _Tp& __x) { - _M_profile_insert(this, __position, size()); + _M_profile_insert(this, __position, this->size()); _Base::insert(__position.base(), __n, __x); } #endif @@ -399,20 +330,20 @@ template > template> iterator - insert(const_iterator __position, _InputIterator __first, + insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { - _M_profile_insert(this, __position, size()); + _M_profile_insert(this, __position, this->size()); return iterator(_Base::insert(__position.base(), __first, __last), this); } #else template - void - insert(iterator __position, _InputIterator __first, + void + insert(iterator __position, _InputIterator __first, _InputIterator __last) { - _M_profile_insert(this, __position, size()); + _M_profile_insert(this, __position, this->size()); _Base::insert(__position.base(), __first, __last); } #endif @@ -439,12 +370,11 @@ template > void swap(list& __x) +#if __cplusplus >= 201103L + noexcept( noexcept(declval<_Base>().swap(__x)) ) +#endif { _Base::swap(__x); } - void - clear() _GLIBCXX_NOEXCEPT - { _Base::clear(); } - // 23.2.2.4 list operations: void #if __cplusplus >= 201103L @@ -488,9 +418,6 @@ template > iterator __last) #endif { - // We used to perform the splice_alloc check: not anymore, redundant - // after implementing the relevant bits of N1599. - _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()), __first.base(), __last.base()); } @@ -515,12 +442,12 @@ template > } template - void - remove_if(_Predicate __pred) - { + void + remove_if(_Predicate __pred) + { for (iterator __x = begin(); __x != end(); ) { - __profcxx_list_operation(this); + __profcxx_list_operation(this); if (__pred(*__x)) __x = erase(__x); else @@ -538,7 +465,7 @@ template > iterator __next = __first; while (++__next != __last) { - __profcxx_list_operation(this); + __profcxx_list_operation(this); if (*__first == *__next) erase(__next); else @@ -548,9 +475,9 @@ template > } template - void - unique(_BinaryPredicate __binary_pred) - { + void + unique(_BinaryPredicate __binary_pred) + { iterator __first = begin(); iterator __last = end(); if (__first == __last) @@ -558,7 +485,7 @@ template > iterator __next = __first; while (++__next != __last) { - __profcxx_list_operation(this); + __profcxx_list_operation(this); if (__binary_pred(*__first, *__next)) erase(__next); else @@ -573,12 +500,7 @@ template > #else merge(list& __x) #endif - { - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 300. list::merge() specification incomplete - if (this != &__x) - { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); } - } + { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); } #if __cplusplus >= 201103L void @@ -587,63 +509,49 @@ template > #endif template - void + void #if __cplusplus >= 201103L - merge(list&& __x, _Compare __comp) + merge(list&& __x, _Compare __comp) #else - merge(list& __x, _Compare __comp) + merge(list& __x, _Compare __comp) #endif - { - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 300. list::merge() specification incomplete - if (this != &__x) - { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); } - } + { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); } #if __cplusplus >= 201103L template - void - merge(list& __x, _Compare __comp) - { this->merge(std::move(__x), __comp); } + void + merge(list& __x, _Compare __comp) + { this->merge(std::move(__x), __comp); } #endif - void - sort() { _Base::sort(); } - - template - void - sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); } - - using _Base::reverse; - _Base& - _M_base() _GLIBCXX_NOEXCEPT { return *this; } + _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& - _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } void _M_profile_find() const { } - void _M_profile_iterate(int __rewind = 0) const + void _M_profile_iterate(int __rewind = 0) const { - __profcxx_list_operation(this); - __profcxx_list_iterate(this); - if (__rewind) - __profcxx_list_rewind(this); + __profcxx_list_operation(this); + __profcxx_list_iterate(this); + if (__rewind) + __profcxx_list_rewind(this); } private: size_type _M_profile_insert(void* obj, const_iterator __pos, size_type __size) { - size_type __shift = 0; - typename _Base::const_iterator __it = __pos.base(); - for (; __it != _Base::end(); ++__it) - __shift++; - __profcxx_list_rewind(this); - __profcxx_list_operation(this); - __profcxx_list_insert(this, __shift, __size); + size_type __shift = 0; + typename _Base::const_iterator __it = __pos.base(); + for (; __it != _Base::end(); ++__it) + __shift++; + __profcxx_list_rewind(this); + __profcxx_list_operation(this); + __profcxx_list_insert(this, __shift, __size); } }; diff --git a/libstdc++-v3/include/profile/map.h b/libstdc++-v3/include/profile/map.h index 6a3160b8e6b..88a560775ba 100644 --- a/libstdc++-v3/include/profile/map.h +++ b/libstdc++-v3/include/profile/map.h @@ -28,8 +28,8 @@ #ifndef _GLIBCXX_PROFILE_MAP_H #define _GLIBCXX_PROFILE_MAP_H 1 -#include #include +#include namespace std _GLIBCXX_VISIBILITY(default) { @@ -39,44 +39,47 @@ namespace __profile template, typename _Allocator = std::allocator > > class map - : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> + : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>, + public _Ordered_profile > { typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base; -#if __cplusplus >= 201103L - typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits; -#endif - public: // types: - typedef _Key key_type; - typedef _Tp mapped_type; - typedef std::pair value_type; - typedef _Compare key_compare; - typedef _Allocator allocator_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; - typedef typename _Base::size_type size_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::pointer pointer; - typedef typename _Base::const_pointer const_pointer; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; + typedef _Key key_type; + typedef _Tp mapped_type; + typedef typename _Base::value_type value_type; + typedef _Compare key_compare; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; // 23.3.1.1 construct/copy/destroy: +#if __cplusplus < 201103L map() - : _Base() - { __profcxx_map_to_unordered_map_construct(this); } + : _Base() { } + map(const map& __x) + : _Base(__x) { } + ~map() + { } +#else + map() = default; + map(const map&) = default; + map(map&&) = default; + ~map() = default; +#endif explicit map(const _Compare& __comp, const _Allocator& __a = _Allocator()) - : _Base(__comp, __a) - { __profcxx_map_to_unordered_map_construct(this); } + : _Base(__comp, __a) { } #if __cplusplus >= 201103L template #endif - map(_InputIterator __first, _InputIterator __last, + map(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) - : _Base(__first, __last, __comp, __a) - { __profcxx_map_to_unordered_map_construct(this); } - - map(const map& __x) - : _Base(__x) - { __profcxx_map_to_unordered_map_construct(this); } + : _Base(__first, __last, __comp, __a) { } map(const _Base& __x) - : _Base(__x) - { __profcxx_map_to_unordered_map_construct(this); } + : _Base(__x) { } #if __cplusplus >= 201103L - map(map&& __x) - noexcept(is_nothrow_copy_constructible<_Compare>::value) - : _Base(std::move(__x)) - { __profcxx_map_to_unordered_map_construct(this); } - map(initializer_list __l, const _Compare& __c = _Compare(), - const allocator_type& __a = allocator_type()) - : _Base(__l, __c, __a) - { __profcxx_map_to_unordered_map_construct(this); } + const _Allocator& __a = _Allocator()) + : _Base(__l, __c, __a) { } explicit - map(const allocator_type& __a) - : _Base(__a) - { __profcxx_map_to_unordered_map_construct(this); } + map(const _Allocator& __a) + : _Base(__a) { } - map(const map& __x, const allocator_type& __a) - : _Base(__x, __a) - { __profcxx_map_to_unordered_map_construct(this); } + map(const map& __x, const _Allocator& __a) + : _Base(__x, __a) { } - map(map&& __x, const allocator_type& __a) - noexcept(is_nothrow_copy_constructible<_Compare>::value - && _Alloc_traits::_S_always_equal()) - : _Base(std::move(__x), __a) - { __profcxx_map_to_unordered_map_construct(this); } + map(map&& __x, const _Allocator& __a) + noexcept( noexcept(_Base(std::move(__x), __a)) ) + : _Base(std::move(__x), __a) { } - map(initializer_list __l, const allocator_type& __a) - : _Base(__l, __a) - { __profcxx_map_to_unordered_map_construct(this); } + map(initializer_list __l, const _Allocator& __a) + : _Base(__l, __a) { } template - map(_InputIterator __first, _InputIterator __last, - const allocator_type& __a) - : _Base(__first, __last, __a) - { __profcxx_map_to_unordered_map_construct(this); } + map(_InputIterator __first, _InputIterator __last, + const _Allocator& __a) + : _Base(__first, __last, __a) { } #endif - ~map() _GLIBCXX_NOEXCEPT - { __profcxx_map_to_unordered_map_destruct(this); } - #if __cplusplus < 201103L map& operator=(const map& __x) @@ -161,113 +143,79 @@ namespace __profile } #endif - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 133. map missing get_allocator() - using _Base::get_allocator; - - // iterators: - iterator - begin() _GLIBCXX_NOEXCEPT - { return _Base::begin(); } - - const_iterator - begin() const _GLIBCXX_NOEXCEPT - { return _Base::begin(); } - - iterator - end() _GLIBCXX_NOEXCEPT - { return _Base::end(); } - - const_iterator - end() const _GLIBCXX_NOEXCEPT - { return _Base::end(); } - reverse_iterator rbegin() _GLIBCXX_NOEXCEPT - { - __profcxx_map_to_unordered_map_invalidate(this); - return reverse_iterator(end()); + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT { - __profcxx_map_to_unordered_map_invalidate(this); - return const_reverse_iterator(end()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); } reverse_iterator rend() _GLIBCXX_NOEXCEPT { - __profcxx_map_to_unordered_map_invalidate(this); - return reverse_iterator(begin()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT { - __profcxx_map_to_unordered_map_invalidate(this); - return const_reverse_iterator(begin()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); } #if __cplusplus >= 201103L - const_iterator - cbegin() const noexcept - { return const_iterator(_Base::begin()); } - - const_iterator - cend() const noexcept - { return const_iterator(_Base::end()); } - const_reverse_iterator crbegin() const noexcept { - __profcxx_map_to_unordered_map_invalidate(this); - return const_reverse_iterator(end()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crbegin(); } const_reverse_iterator crend() const noexcept { - __profcxx_map_to_unordered_map_invalidate(this); - return const_reverse_iterator(begin()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crend(); } #endif - // capacity: - using _Base::empty; - using _Base::size; - using _Base::max_size; - // 23.3.1.2 element access: mapped_type& operator[](const key_type& __k) { - __profcxx_map_to_unordered_map_find(this, size()); - return _Base::operator[](__k); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::operator[](__k); } #if __cplusplus >= 201103L mapped_type& operator[](key_type&& __k) { - __profcxx_map_to_unordered_map_find(this, size()); - return _Base::operator[](std::move(__k)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::operator[](std::move(__k)); } #endif mapped_type& at(const key_type& __k) { - __profcxx_map_to_unordered_map_find(this, size()); - return _Base::at(__k); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::at(__k); } const mapped_type& at(const key_type& __k) const { - __profcxx_map_to_unordered_map_find(this, size()); - return _Base::at(__k); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::at(__k); } // modifiers: @@ -276,21 +224,20 @@ namespace __profile std::pair emplace(_Args&&... __args) { - __profcxx_map_to_unordered_map_insert(this, size(), 1); - auto __res = _Base::emplace(std::forward<_Args>(__args)...); - return std::pair(iterator(__res.first), - __res.second); + // The cost is the same whether or not the element is inserted so we + // always report insertion of 1 element. + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::emplace(std::forward<_Args>(__args)...); } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { - size_type size_before = size(); - auto __res = _Base::emplace_hint(__pos, - std::forward<_Args>(__args)...); + auto size_before = this->size(); + auto __res = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...); __profcxx_map_to_unordered_map_insert(this, size_before, - size() - size_before); + _M_hint_used(__pos, __res) ? 0 : 1); return __res; } #endif @@ -298,67 +245,56 @@ namespace __profile std::pair insert(const value_type& __x) { - __profcxx_map_to_unordered_map_insert(this, size(), 1); - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, bool> __res = _Base::insert(__x); - return std::pair(iterator(__res.first), - __res.second); + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(__x); } #if __cplusplus >= 201103L template::value>::type> - std::pair - insert(_Pair&& __x) - { - __profcxx_map_to_unordered_map_insert(this, size(), 1); - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, bool> __res - = _Base::insert(std::forward<_Pair>(__x)); - return std::pair(iterator(__res.first), - __res.second); + std::pair + insert(_Pair&& __x) + { + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(std::forward<_Pair>(__x)); } #endif #if __cplusplus >= 201103L void insert(std::initializer_list __list) - { - size_type size_before = size(); - _Base::insert(__list); - __profcxx_map_to_unordered_map_insert(this, size_before, - size() - size_before); - } + { insert(__list.begin(), __list.end()); } #endif iterator #if __cplusplus >= 201103L - insert(const_iterator __position, const value_type& __x) + insert(const_iterator __pos, const value_type& __x) #else - insert(iterator __position, const value_type& __x) + insert(iterator __pos, const value_type& __x) #endif { - size_type size_before = size(); - iterator __i = iterator(_Base::insert(__position, __x)); - __profcxx_map_to_unordered_map_insert(this, size_before, - size() - size_before); - return __i; + size_type size_before = this->size(); + iterator __res = _Base::insert(__pos, __x); + + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; } #if __cplusplus >= 201103L template::value>::type> - iterator - insert(const_iterator __position, _Pair&& __x) - { - size_type size_before = size(); - iterator __i - = iterator(_Base::insert(__position, std::forward<_Pair>(__x))); - __profcxx_map_to_unordered_map_insert(this, size_before, - size() - size_before); - return __i; + iterator + insert(const_iterator __pos, _Pair&& __x) + { + size_type size_before = this->size(); + auto __res = _Base::insert(__pos, std::forward<_Pair>(__x)); + + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; } #endif @@ -368,151 +304,163 @@ namespace __profile #else template #endif - void - insert(_InputIterator __first, _InputIterator __last) - { - size_type size_before = size(); - _Base::insert(__first, __last); - __profcxx_map_to_unordered_map_insert(this, size_before, - size() - size_before); + void + insert(_InputIterator __first, _InputIterator __last) + { + for (; __first != __last; ++__first) + insert(*__first); } #if __cplusplus >= 201103L iterator erase(const_iterator __position) { - iterator __i = _Base::erase(__position); - __profcxx_map_to_unordered_map_erase(this, size(), 1); - return __i; + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__position); } iterator erase(iterator __position) - { return erase(const_iterator(__position)); } + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__position); + } #else void erase(iterator __position) { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); _Base::erase(__position); - __profcxx_map_to_unordered_map_erase(this, size(), 1); } #endif size_type erase(const key_type& __x) { - iterator __victim = find(__x); - if (__victim == end()) - return 0; - else - { - _Base::erase(__victim); - return 1; - } + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) - { return iterator(_Base::erase(__first, __last)); } + { + if (__first != __last) + { + iterator __ret; + for (; __first != __last;) + __ret = erase(__first++); + return __ret; + } + else + return _Base::erase(__first, __last); + } #else void erase(iterator __first, iterator __last) - { _Base::erase(__first, __last); } + { + for (; __first != __last;) + erase(__first++); + } #endif void swap(map& __x) #if __cplusplus >= 201103L - noexcept(_Alloc_traits::_S_nothrow_swap()) + noexcept( noexcept(declval<_Base>().swap(__x)) ) #endif { _Base::swap(__x); } - void - clear() _GLIBCXX_NOEXCEPT - { this->erase(begin(), end()); } - - // observers: - using _Base::key_comp; - using _Base::value_comp; - // 23.3.1.3 map operations: iterator find(const key_type& __x) { - __profcxx_map_to_unordered_map_find(this, size()); - return iterator(_Base::find(__x)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); } const_iterator find(const key_type& __x) const { - __profcxx_map_to_unordered_map_find(this, size()); - return const_iterator(_Base::find(__x)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); } size_type count(const key_type& __x) const { - __profcxx_map_to_unordered_map_find(this, size()); - return _Base::count(__x); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::count(__x); } iterator lower_bound(const key_type& __x) - { - __profcxx_map_to_unordered_map_invalidate(this); - return iterator(_Base::lower_bound(__x)); + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::lower_bound(__x); } const_iterator lower_bound(const key_type& __x) const - { - __profcxx_map_to_unordered_map_invalidate(this); - return const_iterator(_Base::lower_bound(__x)); + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::lower_bound(__x); } iterator upper_bound(const key_type& __x) - { - __profcxx_map_to_unordered_map_invalidate(this); - return iterator(_Base::upper_bound(__x)); + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); } const_iterator upper_bound(const key_type& __x) const - { - __profcxx_map_to_unordered_map_invalidate(this); - return const_iterator(_Base::upper_bound(__x)); + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); } std::pair equal_range(const key_type& __x) { - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, _Base_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(iterator(__res.first), - iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } std::pair equal_range(const key_type& __x) const { - __profcxx_map_to_unordered_map_find(this, size()); - typedef typename _Base::const_iterator _Base_const_iterator; - std::pair<_Base_const_iterator, _Base_const_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(const_iterator(__res.first), - const_iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } - _Base& - _M_base() _GLIBCXX_NOEXCEPT { return *this; } + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& - _M_base() const _GLIBCXX_NOEXCEPT { return *this; } - + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + /** If hint is used we consider that the map and unordered_map + * operations have equivalent insertion cost so we do not update metrics + * about it. + * Note that to find out if hint has been used is libstdc++ + * implementation dependant. + */ + bool + _M_hint_used(const_iterator __hint, iterator __res) + { + return (__hint == __res || + (__hint == this->end() && ++__res == this->end()) || + (__hint != this->end() && (++__hint == __res || + ++__res == --__hint))); + } }; template& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) - { + { __profcxx_map_to_unordered_map_invalidate(&__lhs); __profcxx_map_to_unordered_map_invalidate(&__rhs); - return __lhs._M_base() == __rhs._M_base(); + return __lhs._M_base() == __rhs._M_base(); } template& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) - { + { __profcxx_map_to_unordered_map_invalidate(&__lhs); __profcxx_map_to_unordered_map_invalidate(&__rhs); - return __lhs._M_base() != __rhs._M_base(); + return __lhs._M_base() != __rhs._M_base(); } template +#include +#include namespace std _GLIBCXX_VISIBILITY(default) { @@ -39,38 +40,44 @@ namespace __profile template, typename _Allocator = std::allocator > > class multimap - : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> + : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>, + public _Ordered_profile > { typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base; -#if __cplusplus >= 201103L - typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits; -#endif - public: // types: - typedef _Key key_type; - typedef _Tp mapped_type; - typedef std::pair value_type; - typedef _Compare key_compare; - typedef _Allocator allocator_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; - typedef typename _Base::reverse_iterator reverse_iterator; - typedef typename _Base::const_reverse_iterator const_reverse_iterator; - - typedef typename _Base::size_type size_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::pointer pointer; - typedef typename _Base::const_pointer const_pointer; + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; // 23.3.1.1 construct/copy/destroy: +#if __cplusplus < 201103L multimap() : _Base() { } + multimap(const multimap& __x) + : _Base(__x) { } + ~multimap() { } +#else + multimap() = default; + multimap(const multimap&) = default; + multimap(multimap&&) = default; + ~multimap() = default; +#endif explicit multimap(const _Compare& __comp, const _Allocator& __a = _Allocator()) @@ -82,49 +89,40 @@ namespace __profile #else template #endif - multimap(_InputIterator __first, _InputIterator __last, - const _Compare& __comp = _Compare(), - const _Allocator& __a = _Allocator()) - : _Base(__first, __last, __comp, __a) { } - -#if __cplusplus < 201103L - multimap(const multimap& __x) - : _Base(__x) { } -#else - multimap(const multimap&) = default; - multimap(multimap&&) = default; + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__first, __last, __comp, __a) { } +#if __cplusplus >= 201103L multimap(initializer_list __l, const _Compare& __c = _Compare(), - const allocator_type& __a = allocator_type()) + const _Allocator& __a = _Allocator()) : _Base(__l, __c, __a) { } explicit - multimap(const allocator_type& __a) - : _Base(__a) { } + multimap(const _Allocator& __a) + : _Base(__a) { } - multimap(const multimap& __x, const allocator_type& __a) + multimap(const multimap& __x, const _Allocator& __a) : _Base(__x, __a) { } - multimap(multimap&& __x, const allocator_type& __a) - noexcept(is_nothrow_copy_constructible<_Compare>::value - && _Alloc_traits::_S_always_equal()) + multimap(multimap&& __x, const _Allocator& __a) + noexcept( noexcept(_Base(std::move(__x), __a)) ) : _Base(std::move(__x), __a) { } - multimap(initializer_list __l, const allocator_type& __a) + multimap(initializer_list __l, const _Allocator& __a) : _Base(__l, __a) { } template - multimap(_InputIterator __first, _InputIterator __last, - const allocator_type& __a) - : _Base(__first, __last, __a) { } + multimap(_InputIterator __first, _InputIterator __last, + const _Allocator& __a) + : _Base(__first, __last, __a) { } #endif multimap(const _Base& __x) : _Base(__x) { } - ~multimap() _GLIBCXX_NOEXCEPT { } - #if __cplusplus < 201103L multimap& operator=(const multimap& __x) @@ -147,117 +145,125 @@ namespace __profile } #endif - using _Base::get_allocator; - - // iterators: - iterator - begin() _GLIBCXX_NOEXCEPT - { return iterator(_Base::begin()); } - - const_iterator - begin() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::begin()); } - - iterator - end() _GLIBCXX_NOEXCEPT - { return iterator(_Base::end()); } - - const_iterator - end() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::end()); } - reverse_iterator rbegin() _GLIBCXX_NOEXCEPT - { return reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); + } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); + } reverse_iterator rend() _GLIBCXX_NOEXCEPT - { return reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); + } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); + } #if __cplusplus >= 201103L - const_iterator - cbegin() const noexcept - { return const_iterator(_Base::begin()); } - - const_iterator - cend() const noexcept - { return const_iterator(_Base::end()); } - const_reverse_iterator crbegin() const noexcept - { return const_reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crbegin(); + } const_reverse_iterator crend() const noexcept - { return const_reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crend(); + } #endif - // capacity: - using _Base::empty; - using _Base::size; - using _Base::max_size; - // modifiers: #if __cplusplus >= 201103L template iterator emplace(_Args&&... __args) { - return iterator(_Base::emplace(std::forward<_Args>(__args)...)); + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::emplace(std::forward<_Args>(__args)...); } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { - return iterator(_Base::emplace_hint(__pos, - std::forward<_Args>(__args)...)); + auto size_before = this->size(); + auto __res + = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...); + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; } #endif - + iterator insert(const value_type& __x) - { return iterator(_Base::insert(__x)); } + { + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(__x); + } #if __cplusplus >= 201103L template::value>::type> - iterator - insert(_Pair&& __x) - { return iterator(_Base::insert(std::forward<_Pair>(__x))); } + iterator + insert(_Pair&& __x) + { + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(std::forward<_Pair>(__x)); + } #endif #if __cplusplus >= 201103L void insert(std::initializer_list __list) - { _Base::insert(__list); } + { insert(__list.begin(), __list.end()); } #endif iterator #if __cplusplus >= 201103L - insert(const_iterator __position, const value_type& __x) + insert(const_iterator __pos, const value_type& __x) #else - insert(iterator __position, const value_type& __x) + insert(iterator __pos, const value_type& __x) #endif - { return iterator(_Base::insert(__position, __x)); } + { + size_type size_before = this->size(); + iterator __res = _Base::insert(__pos, __x); + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; + } #if __cplusplus >= 201103L template::value>::type> - iterator - insert(const_iterator __position, _Pair&& __x) - { return iterator(_Base::insert(__position, - std::forward<_Pair>(__x))); } + iterator + insert(const_iterator __pos, _Pair&& __x) + { + size_type size_before = this->size(); + auto __res = _Base::insert(__pos, std::forward<_Pair>(__x)); + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; + } #endif #if __cplusplus >= 201103L @@ -266,115 +272,163 @@ namespace __profile #else template #endif - void - insert(_InputIterator __first, _InputIterator __last) - { _Base::insert(__first, __last); } + void + insert(_InputIterator __first, _InputIterator __last) + { + for (; __first != __last; ++__first) + insert(*__first); + } #if __cplusplus >= 201103L iterator - erase(const_iterator __position) - { return iterator(_Base::erase(__position)); } + erase(const_iterator __pos) + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__pos); + } iterator - erase(iterator __position) - { return iterator(_Base::erase(__position)); } + erase(iterator __pos) + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__pos); + } #else void - erase(iterator __position) - { _Base::erase(__position); } + erase(iterator __pos) + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + _Base::erase(__pos); + } #endif size_type erase(const key_type& __x) { - std::pair __victims = this->equal_range(__x); - size_type __count = 0; - while (__victims.first != __victims.second) - { - iterator __victim = __victims.first++; - _Base::erase(__victim); - ++__count; - } - return __count; + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) - { return iterator(_Base::erase(__first, __last)); } + { + if (__first != __last) + { + iterator __ret; + for (; __first != __last;) + __ret = erase(__first++); + return __ret; + } + else + return _Base::erase(__first, __last); + } #else void erase(iterator __first, iterator __last) - { _Base::erase(__first, __last); } + { + for (; __first != __last;) + erase(__first++); + } #endif void swap(multimap& __x) #if __cplusplus >= 201103L - noexcept(_Alloc_traits::_S_nothrow_swap()) + noexcept( noexcept(declval<_Base>().swap(__x)) ) #endif { _Base::swap(__x); } - void - clear() _GLIBCXX_NOEXCEPT - { this->erase(begin(), end()); } - - // observers: - using _Base::key_comp; - using _Base::value_comp; - // 23.3.1.3 multimap operations: iterator find(const key_type& __x) - { return iterator(_Base::find(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); + } const_iterator find(const key_type& __x) const - { return const_iterator(_Base::find(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); + } - using _Base::count; + size_type + count(const key_type& __x) const + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::count(__x); + } iterator lower_bound(const key_type& __x) - { return iterator(_Base::lower_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::lower_bound(__x); + } const_iterator lower_bound(const key_type& __x) const - { return const_iterator(_Base::lower_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::lower_bound(__x); + } iterator upper_bound(const key_type& __x) - { return iterator(_Base::upper_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); + } const_iterator upper_bound(const key_type& __x) const - { return const_iterator(_Base::upper_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); + } std::pair equal_range(const key_type& __x) { - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, _Base_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(iterator(__res.first), - iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } std::pair equal_range(const key_type& __x) const { - typedef typename _Base::const_iterator _Base_const_iterator; - std::pair<_Base_const_iterator, _Base_const_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(const_iterator(__res.first), - const_iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } _Base& - _M_base() _GLIBCXX_NOEXCEPT { return *this; } + _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& - _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + /** If hint is used we consider that the map and unordered_map + * operations have equivalent insertion cost so we do not update metrics + * about it. + * Note that to find out if hint has been used is libstdc++ + * implementation dependant. + */ + bool + _M_hint_used(const_iterator __hint, iterator __res) + { + return (__hint == __res || + (__hint == this->end() && ++__res == this->end()) || + (__hint != this->end() && (++__hint == __res || + ++__res == --__hint))); + } }; template +#include +#include namespace std _GLIBCXX_VISIBILITY(default) { @@ -39,38 +40,45 @@ namespace __profile template, typename _Allocator = std::allocator<_Key> > class multiset - : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> + : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>, + public _Ordered_profile > { typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base; -#if __cplusplus >= 201103L - typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits; -#endif - public: // types: - typedef _Key key_type; - typedef _Key value_type; - typedef _Compare key_compare; - typedef _Compare value_compare; - typedef _Allocator allocator_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; - typedef typename _Base::reverse_iterator reverse_iterator; - typedef typename _Base::const_reverse_iterator const_reverse_iterator; - - typedef typename _Base::size_type size_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::pointer pointer; - typedef typename _Base::const_pointer const_pointer; + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; // 23.3.3.1 construct/copy/destroy: +#if __cplusplus < 201103L multiset() : _Base() { } + multiset(const multiset& __x) + : _Base(__x) { } + ~multiset() { } +#else + multiset() = default; + multiset(const multiset&) = default; + multiset(multiset&&) = default; + ~multiset() = default; +#endif explicit multiset(const _Compare& __comp, const _Allocator& __a = _Allocator()) @@ -82,18 +90,12 @@ namespace __profile #else template #endif - multiset(_InputIterator __first, _InputIterator __last, + multiset(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__first, __last, __comp, __a) { } -#if __cplusplus < 201103L - multiset(const multiset& __x) - : _Base(__x) { } -#else - multiset(const multiset&) = default; - multiset(multiset&&) = default; - +#if __cplusplus >= 201103L multiset(initializer_list __l, const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) @@ -101,30 +103,27 @@ namespace __profile explicit multiset(const allocator_type& __a) - : _Base(__a) { } + : _Base(__a) { } multiset(const multiset& __x, const allocator_type& __a) : _Base(__x, __a) { } multiset(multiset&& __x, const allocator_type& __a) - noexcept(is_nothrow_copy_constructible<_Compare>::value - && _Alloc_traits::_S_always_equal()) + noexcept( noexcept(_Base(std::move(__x), __a)) ) : _Base(std::move(__x), __a) { } multiset(initializer_list __l, const allocator_type& __a) : _Base(__l, __a) { } template - multiset(_InputIterator __first, _InputIterator __last, - const allocator_type& __a) - : _Base(__first, __last, __a) { } + multiset(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _Base(__first, __last, __a) { } #endif multiset(const _Base& __x) : _Base(__x) { } - ~multiset() _GLIBCXX_NOEXCEPT { } - #if __cplusplus < 201103L multiset& operator=(const multiset& __x) @@ -147,98 +146,112 @@ namespace __profile } #endif - using _Base::get_allocator; - // iterators: - iterator - begin() _GLIBCXX_NOEXCEPT - { return iterator(_Base::begin()); } - - const_iterator - begin() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::begin()); } - - iterator - end() _GLIBCXX_NOEXCEPT - { return iterator(_Base::end()); } - - const_iterator - end() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::end()); } - reverse_iterator rbegin() _GLIBCXX_NOEXCEPT - { return reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); + } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); + } reverse_iterator rend() _GLIBCXX_NOEXCEPT - { return reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); + } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); + } #if __cplusplus >= 201103L - const_iterator - cbegin() const noexcept - { return const_iterator(_Base::begin()); } - - const_iterator - cend() const noexcept - { return const_iterator(_Base::end()); } - const_reverse_iterator crbegin() const noexcept - { return const_reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crbegin(); + } const_reverse_iterator crend() const noexcept - { return const_reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crend(); + } #endif - // capacity: - using _Base::empty; - using _Base::size; - using _Base::max_size; - // modifiers: #if __cplusplus >= 201103L template iterator emplace(_Args&&... __args) - { return iterator(_Base::emplace(std::forward<_Args>(__args)...)); } + { + // The cost is the same whether or not the element is inserted so we + // always report insertion of 1 element. + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::emplace(std::forward<_Args>(__args)...); + } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { - return iterator(_Base::emplace_hint(__pos, - std::forward<_Args>(__args)...)); + auto size_before = this->size(); + auto __res = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...); + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; } #endif iterator insert(const value_type& __x) - { return iterator(_Base::insert(__x)); } + { + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(__x); + } #if __cplusplus >= 201103L iterator insert(value_type&& __x) - { return iterator(_Base::insert(std::move(__x))); } + { + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(std::move(__x)); + } #endif iterator - insert(const_iterator __position, const value_type& __x) - { return iterator(_Base::insert(__position, __x)); } + insert(const_iterator __pos, const value_type& __x) + { + size_type size_before = this->size(); + iterator __res = _Base::insert(__pos, __x); + + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; + } #if __cplusplus >= 201103L iterator - insert(const_iterator __position, value_type&& __x) - { return iterator(_Base::insert(__position, std::move(__x))); } + insert(const_iterator __pos, value_type&& __x) + { + auto size_before = this->size(); + auto __res = _Base::insert(__pos, std::move(__x)); + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; + } #endif #if __cplusplus >= 201103L @@ -247,106 +260,137 @@ namespace __profile #else template #endif - void - insert(_InputIterator __first, _InputIterator __last) - { _Base::insert(__first, __last); } + void + insert(_InputIterator __first, _InputIterator __last) + { + for (; __first != __last; ++__first) + insert(*__first); + } #if __cplusplus >= 201103L void insert(initializer_list __l) - { _Base::insert(__l); } + { insert(__l.begin(), __l.end()); } #endif #if __cplusplus >= 201103L iterator - erase(const_iterator __position) - { return iterator(_Base::erase(__position)); } + erase(const_iterator __pos) + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__pos); + } #else void - erase(iterator __position) - { _Base::erase(__position); } + erase(iterator __pos) + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + _Base::erase(__pos); + } #endif size_type erase(const key_type& __x) { - std::pair __victims = this->equal_range(__x); - size_type __count = 0; - while (__victims.first != __victims.second) - { - iterator __victim = __victims.first++; - _Base::erase(__victim); - ++__count; - } - return __count; + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) - { return iterator(_Base::erase(__first, __last)); } + { + if (__first != __last) + { + iterator __ret; + for (; __first != __last;) + __ret = erase(__first++); + return __ret; + } + else + return _Base::erase(__first, __last); + } #else void erase(iterator __first, iterator __last) - { _Base::erase(__first, __last); } + { + for (; __first != __last;) + erase(__first++); + } #endif void swap(multiset& __x) #if __cplusplus >= 201103L - noexcept(_Alloc_traits::_S_nothrow_swap()) + noexcept( noexcept(declval<_Base>().swap(__x)) ) #endif { _Base::swap(__x); } - void - clear() _GLIBCXX_NOEXCEPT - { this->erase(begin(), end()); } - - // observers: - using _Base::key_comp; - using _Base::value_comp; - // multiset operations: iterator find(const key_type& __x) - { return iterator(_Base::find(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); + } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 214. set::find() missing const overload const_iterator find(const key_type& __x) const - { return const_iterator(_Base::find(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); + } - using _Base::count; + size_type + count(const key_type& __x) const + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::count(__x); + } iterator lower_bound(const key_type& __x) - { return iterator(_Base::lower_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::lower_bound(__x); + } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 214. set::find() missing const overload const_iterator lower_bound(const key_type& __x) const - { return const_iterator(_Base::lower_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::lower_bound(__x); + } iterator upper_bound(const key_type& __x) - { return iterator(_Base::upper_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); + } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 214. set::find() missing const overload const_iterator upper_bound(const key_type& __x) const - { return const_iterator(_Base::upper_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); + } std::pair equal_range(const key_type& __x) { - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, _Base_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(iterator(__res.first), - iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -354,19 +398,31 @@ namespace __profile std::pair equal_range(const key_type& __x) const { - typedef typename _Base::const_iterator _Base_iterator; - std::pair<_Base_iterator, _Base_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(const_iterator(__res.first), - const_iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } _Base& - _M_base() _GLIBCXX_NOEXCEPT { return *this; } + _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& - _M_base() const _GLIBCXX_NOEXCEPT { return *this; } - + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + /** If hint is used we consider that the map and unordered_map + * operations have equivalent insertion cost so we do not update metrics + * about it. + * Note that to find out if hint has been used is libstdc++ + * implementation dependant. + */ + bool + _M_hint_used(const_iterator __hint, iterator __res) + { + return (__hint == __res || + (__hint == this->end() && ++__res == this->end()) || + (__hint != this->end() && (++__hint == __res || + ++__res == --__hint))); + } }; template diff --git a/libstdc++-v3/include/profile/ordered_base.h b/libstdc++-v3/include/profile/ordered_base.h new file mode 100644 index 00000000000..c76adfc48f0 --- /dev/null +++ b/libstdc++-v3/include/profile/ordered_base.h @@ -0,0 +1,65 @@ +// Profiling unordered containers implementation details -*- C++ -*- + +// Copyright (C) 2014 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +/** @file profile/ordered_base.h + * This file is a GNU profile extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_ORDERED +#define _GLIBCXX_PROFILE_ORDERED 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __profile +{ + template + class _Ordered_profile + { + _Cont& + _M_conjure() + { return *static_cast<_Cont*>(this); } + + public: + _Ordered_profile() _GLIBCXX_NOEXCEPT + { __profcxx_map_to_unordered_map_construct(&_M_conjure()); } + +#if __cplusplus >= 201103L + _Ordered_profile(const _Ordered_profile&) noexcept + : _Ordered_profile() { } + _Ordered_profile(_Ordered_profile&&) noexcept + : _Ordered_profile() { } + + _Ordered_profile& + operator=(const _Ordered_profile&) = default; + _Ordered_profile& + operator=(_Ordered_profile&&) = default; +#endif + + ~_Ordered_profile() + { __profcxx_map_to_unordered_map_destruct(&_M_conjure()); } + }; + +} // namespace __profile +} // namespace std + +#endif diff --git a/libstdc++-v3/include/profile/set.h b/libstdc++-v3/include/profile/set.h index 05fbeb9f6b1..ced035041a8 100644 --- a/libstdc++-v3/include/profile/set.h +++ b/libstdc++-v3/include/profile/set.h @@ -29,9 +29,10 @@ #ifndef _GLIBCXX_PROFILE_SET_H #define _GLIBCXX_PROFILE_SET_H 1 -#include +#include +#include -namespace std _GLIBCXX_VISIBILITY(default) +namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { @@ -39,7 +40,8 @@ namespace __profile template, typename _Allocator = std::allocator<_Key> > class set - : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator> + : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>, + public _Ordered_profile > { typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base; @@ -49,28 +51,36 @@ namespace __profile public: // types: - typedef _Key key_type; - typedef _Key value_type; - typedef _Compare key_compare; - typedef _Compare value_compare; - typedef _Allocator allocator_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; - typedef typename _Base::reverse_iterator reverse_iterator; - typedef typename _Base::const_reverse_iterator const_reverse_iterator; - - typedef typename _Base::size_type size_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::pointer pointer; - typedef typename _Base::const_pointer const_pointer; + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::reverse_iterator reverse_iterator; + typedef typename _Base::const_reverse_iterator const_reverse_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; // 23.3.3.1 construct/copy/destroy: - +#if __cplusplus < 201103L set() : _Base() { } + set(const set& __x) + : _Base(__x) { } + ~set() { } +#else + set() = default; + set(const set&) = default; + set(set&&) = default; + ~set() = default; +#endif explicit set(const _Compare& __comp, const _Allocator& __a = _Allocator()) @@ -82,49 +92,40 @@ namespace __profile #else template #endif - set(_InputIterator __first, _InputIterator __last, + set(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__first, __last, __comp, __a) { } -#if __cplusplus < 201103L - set(const set& __x) - : _Base(__x) { } -#else - set(const set&) = default; - set(set&&) = default; - +#if __cplusplus >= 201103L set(initializer_list __l, const _Compare& __comp = _Compare(), - const allocator_type& __a = allocator_type()) + const _Allocator& __a = _Allocator()) : _Base(__l, __comp, __a) { } explicit - set(const allocator_type& __a) - : _Base(__a) { } + set(const _Allocator& __a) + : _Base(__a) { } - set(const set& __x, const allocator_type& __a) + set(const set& __x, const _Allocator& __a) : _Base(__x, __a) { } - set(set&& __x, const allocator_type& __a) - noexcept(is_nothrow_copy_constructible<_Compare>::value - && _Alloc_traits::_S_always_equal()) + set(set&& __x, const _Allocator& __a) + noexcept( noexcept(_Base(std::move(__x), __a)) ) : _Base(std::move(__x), __a) { } - set(initializer_list __l, const allocator_type& __a) + set(initializer_list __l, const _Allocator& __a) : _Base(__l, __a) { } template - set(_InputIterator __first, _InputIterator __last, - const allocator_type& __a) - : _Base(__first, __last, __a) { } + set(_InputIterator __first, _InputIterator __last, + const _Allocator& __a) + : _Base(__first, __last, __a) { } #endif set(const _Base& __x) : _Base(__x) { } - ~set() _GLIBCXX_NOEXCEPT { } - #if __cplusplus < 201103L set& operator=(const set& __x) @@ -147,108 +148,98 @@ namespace __profile } #endif - using _Base::get_allocator; - - // iterators: - iterator - begin() _GLIBCXX_NOEXCEPT - { return iterator(_Base::begin()); } - - const_iterator - begin() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::begin()); } - - iterator - end() _GLIBCXX_NOEXCEPT - { return iterator(_Base::end()); } - - const_iterator - end() const _GLIBCXX_NOEXCEPT - { return const_iterator(_Base::end()); } - reverse_iterator rbegin() _GLIBCXX_NOEXCEPT - { return reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); + } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rbegin(); + } reverse_iterator rend() _GLIBCXX_NOEXCEPT - { return reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); + } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT - { return const_reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::rend(); + } #if __cplusplus >= 201103L - const_iterator - cbegin() const noexcept - { return const_iterator(_Base::begin()); } - - const_iterator - cend() const noexcept - { return const_iterator(_Base::end()); } - const_reverse_iterator crbegin() const noexcept - { return const_reverse_iterator(end()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crbegin(); + } const_reverse_iterator crend() const noexcept - { return const_reverse_iterator(begin()); } + { + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::crend(); + } #endif - // capacity: - using _Base::empty; - using _Base::size; - using _Base::max_size; - // modifiers: #if __cplusplus >= 201103L template std::pair emplace(_Args&&... __args) { - auto __res = _Base::emplace(std::forward<_Args>(__args)...); - return std::pair(iterator(__res.first), - __res.second); + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::emplace(std::forward<_Args>(__args)...); } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { - return iterator(_Base::emplace_hint(__pos, - std::forward<_Args>(__args)...)); + auto size_before = this->size(); + auto __res + = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...); + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; } #endif std::pair insert(const value_type& __x) { - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, bool> __res = _Base::insert(__x); - return std::pair(iterator(__res.first), - __res.second); + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(__x); } #if __cplusplus >= 201103L std::pair insert(value_type&& __x) { - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, bool> __res - = _Base::insert(std::move(__x)); - return std::pair(iterator(__res.first), - __res.second); + __profcxx_map_to_unordered_map_insert(this, this->size(), 1); + return _Base::insert(std::move(__x)); } #endif iterator - insert(const_iterator __position, const value_type& __x) - { return iterator(_Base::insert(__position, __x)); } + insert(const_iterator __pos, const value_type& __x) + { + size_type size_before = this->size(); + iterator __res = _Base::insert(__pos, __x); + __profcxx_map_to_unordered_map_insert(this, size_before, + _M_hint_used(__pos, __res) ? 0 : 1); + return __res; + } #if __cplusplus >= 201103L iterator @@ -262,125 +253,162 @@ namespace __profile #else template #endif - void - insert(_InputIterator __first, _InputIterator __last) - { _Base::insert(__first, __last); } + void + insert(_InputIterator __first, _InputIterator __last) + { + for (; __first != __last; ++__first) + insert(*__first); + } #if __cplusplus >= 201103L void insert(initializer_list __l) - { _Base::insert(__l); } + { insert(__l.begin(), __l.end()); } #endif #if __cplusplus >= 201103L iterator - erase(const_iterator __position) - { return iterator(_Base::erase(__position)); } + erase(const_iterator __pos) + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__pos); + } #else void - erase(iterator __position) - { _Base::erase(__position); } + erase(iterator __pos) + { + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + _Base::erase(__pos); + } #endif size_type erase(const key_type& __x) { - iterator __victim = find(__x); - if (__victim == end()) - return 0; - else - { - _Base::erase(__victim); - return 1; - } + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_erase(this, this->size(), 1); + return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) - { return iterator(_Base::erase(__first, __last)); } + { + if (__first != __last) + { + iterator __ret; + for (; __first != __last;) + __ret = erase(__first++); + return __ret; + } + + return _Base::erase(__first, __last); + } #else void erase(iterator __first, iterator __last) - { _Base::erase(__first, __last); } + { + for (; __first != __last;) + erase(__first++); + } #endif void swap(set& __x) #if __cplusplus >= 201103L - noexcept(_Alloc_traits::_S_nothrow_swap()) + noexcept( noexcept(declval<_Base>().swap(__x)) ) #endif { _Base::swap(__x); } - void - clear() _GLIBCXX_NOEXCEPT - { this->erase(begin(), end()); } - - // observers: - using _Base::key_comp; - using _Base::value_comp; - // set operations: iterator find(const key_type& __x) - { return iterator(_Base::find(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); + } - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 214. set::find() missing const overload const_iterator find(const key_type& __x) const - { return const_iterator(_Base::find(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::find(__x); + } - using _Base::count; + size_type + count(const key_type& __x) const + { + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::count(__x); + } iterator lower_bound(const key_type& __x) - { return iterator(_Base::lower_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::lower_bound(__x); + } - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 214. set::find() missing const overload const_iterator lower_bound(const key_type& __x) const - { return const_iterator(_Base::lower_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::lower_bound(__x); + } iterator upper_bound(const key_type& __x) - { return iterator(_Base::upper_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); + } - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 214. set::find() missing const overload const_iterator upper_bound(const key_type& __x) const - { return const_iterator(_Base::upper_bound(__x)); } + { + __profcxx_map_to_unordered_map_find(this, this->size()); + __profcxx_map_to_unordered_map_invalidate(this); + return _Base::upper_bound(__x); + } - std::pair + std::pair equal_range(const key_type& __x) { - typedef typename _Base::iterator _Base_iterator; - std::pair<_Base_iterator, _Base_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(iterator(__res.first), - iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 214. set::find() missing const overload - std::pair + std::pair equal_range(const key_type& __x) const { - typedef typename _Base::const_iterator _Base_iterator; - std::pair<_Base_iterator, _Base_iterator> __res = - _Base::equal_range(__x); - return std::make_pair(const_iterator(__res.first), - const_iterator(__res.second)); + __profcxx_map_to_unordered_map_find(this, this->size()); + return _Base::equal_range(__x); } _Base& - _M_base() _GLIBCXX_NOEXCEPT { return *this; } + _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& - _M_base() const _GLIBCXX_NOEXCEPT { return *this; } - + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + /** If hint is used we consider that the map and unordered_map + * operations have equivalent insertion cost so we do not update metrics + * about it. + * Note that to find out if hint has been used is libstdc++ + * implementation dependant. + */ + bool + _M_hint_used(const_iterator __hint, iterator __res) + { + return (__hint == __res || + (__hint == this->end() && ++__res == this->end()) || + (__hint != this->end() && (++__hint == __res || + ++__res == --__hint))); + } }; template diff --git a/libstdc++-v3/include/profile/unordered_base.h b/libstdc++-v3/include/profile/unordered_base.h index 6c52f0a65fd..283f87ce715 100644 --- a/libstdc++-v3/include/profile/unordered_base.h +++ b/libstdc++-v3/include/profile/unordered_base.h @@ -157,7 +157,7 @@ namespace __profile _Unordered_profile() { auto& __uc = _M_conjure(); - __profcxx_hashtable_construct(&__uc, __uc.bucket_count()); + __profcxx_hashtable_construct(&__uc, __uc.bucket_count()); __profcxx_hashtable_construct2(&__uc); } _Unordered_profile(const _Unordered_profile&) @@ -168,8 +168,8 @@ namespace __profile ~_Unordered_profile() noexcept { auto& __uc = _M_conjure(); - __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size()); - _M_profile_destruct(); + __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size()); + _M_profile_destruct(); } _Unordered_profile& @@ -210,6 +210,7 @@ namespace __profile auto __lend = __uc.end(__bkt); for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit) ++__chain; + if (__chain) { ++__chain; @@ -245,6 +246,7 @@ namespace __profile __pit = __it; } } + if (__chain) { ++__chain; diff --git a/libstdc++-v3/include/profile/unordered_map b/libstdc++-v3/include/profile/unordered_map index 994438274f0..e13c069e58e 100644 --- a/libstdc++-v3/include/profile/unordered_map +++ b/libstdc++-v3/include/profile/unordered_map @@ -56,73 +56,66 @@ namespace __profile typedef typename _GLIBCXX_STD_BASE _Base; _Base& - _M_base() noexcept { return *this; } + _M_base() noexcept { return *this; } const _Base& - _M_base() const noexcept { return *this; } + _M_base() const noexcept { return *this; } public: - typedef typename _Base::size_type size_type; - typedef typename _Base::hasher hasher; - typedef typename _Base::key_equal key_equal; - typedef typename _Base::allocator_type allocator_type; - typedef typename _Base::key_type key_type; - typedef typename _Base::value_type value_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - typedef typename _Base::mapped_type mapped_type; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + typedef typename _Base::mapped_type mapped_type; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; explicit unordered_map(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Base(__n, __hf, __eql, __a) - { } + : _Base(__n, __hf, __eql, __a) { } template - unordered_map(_InputIterator __f, _InputIterator __l, + unordered_map(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Base(__f, __l, __n, __hf, __eql, __a) - { } + : _Base(__f, __l, __n, __hf, __eql, __a) { } unordered_map(const unordered_map&) = default; unordered_map(const _Base& __x) - : _Base(__x) - { } + : _Base(__x) { } unordered_map(unordered_map&&) = default; explicit unordered_map(const allocator_type& __a) - : _Base(__a) - { } + : _Base(__a) { } unordered_map(const unordered_map& __umap, const allocator_type& __a) - : _Base(__umap, __a) - { } + : _Base(__umap, __a) { } unordered_map(unordered_map&& __umap, const allocator_type& __a) - : _Base(std::move(__umap._M_base()), __a) - { } + : _Base(std::move(__umap._M_base()), __a) { } unordered_map(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Base(__l, __n, __hf, __eql, __a) - { } + : _Base(__l, __n, __hf, __eql, __a) { } unordered_map& operator=(const unordered_map&) = default; @@ -140,9 +133,9 @@ namespace __profile void clear() noexcept { - __profcxx_hashtable_destruct(this, _Base::bucket_count(), + __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size()); - this->_M_profile_destruct(); + this->_M_profile_destruct(); _Base::clear(); } @@ -170,81 +163,81 @@ namespace __profile void insert(std::initializer_list __l) - { - size_type __old_size = _Base::bucket_count(); - _Base::insert(__l); - _M_profile_resize(__old_size); + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size); } std::pair insert(const value_type& __obj) { - size_type __old_size = _Base::bucket_count(); - std::pair __res = _Base::insert(__obj); - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + std::pair __res = _Base::insert(__obj); + _M_profile_resize(__old_size); + return __res; } iterator insert(const_iterator __iter, const value_type& __v) - { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__iter, __v); - _M_profile_resize(__old_size); - return __res; + { + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size); + return __res; } template::value>::type> - std::pair - insert(_Pair&& __obj) - { + std::pair + insert(_Pair&& __obj) + { size_type __old_size = _Base::bucket_count(); std::pair __res = _Base::insert(std::forward<_Pair>(__obj)); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); return __res; } template::value>::type> - iterator - insert(const_iterator __iter, _Pair&& __v) - { - size_type __old_size = _Base::bucket_count(); + iterator + insert(const_iterator __iter, _Pair&& __v) + { + size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v)); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); return __res; } template - void - insert(_InputIter __first, _InputIter __last) - { - size_type __old_size = _Base::bucket_count(); + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); } // operator[] mapped_type& operator[](const _Key& __k) { - size_type __old_size = _Base::bucket_count(); - mapped_type& __res = _M_base()[__k]; - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + mapped_type& __res = _M_base()[__k]; + _M_profile_resize(__old_size); + return __res; } mapped_type& operator[](_Key&& __k) { - size_type __old_size = _Base::bucket_count(); - mapped_type& __res = _M_base()[std::move(__k)]; - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + mapped_type& __res = _M_base()[std::move(__k)]; + _M_profile_resize(__old_size); + return __res; } void @@ -256,7 +249,7 @@ namespace __profile { size_type __old_size = _Base::bucket_count(); _Base::rehash(__n); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); } private: @@ -305,76 +298,69 @@ namespace __profile public _Unordered_profile, false> - { + { typedef typename _GLIBCXX_STD_BASE _Base; _Base& - _M_base() noexcept { return *this; } + _M_base() noexcept { return *this; } const _Base& - _M_base() const noexcept { return *this; } + _M_base() const noexcept { return *this; } public: - typedef typename _Base::size_type size_type; - typedef typename _Base::hasher hasher; - typedef typename _Base::key_equal key_equal; - typedef typename _Base::allocator_type allocator_type; - typedef typename _Base::key_type key_type; - typedef typename _Base::value_type value_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; explicit unordered_multimap(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Base(__n, __hf, __eql, __a) - { } + : _Base(__n, __hf, __eql, __a) { } template - unordered_multimap(_InputIterator __f, _InputIterator __l, + unordered_multimap(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Base(__f, __l, __n, __hf, __eql, __a) - { } + : _Base(__f, __l, __n, __hf, __eql, __a) { } unordered_multimap(const unordered_multimap&) = default; unordered_multimap(const _Base& __x) - : _Base(__x) - { } + : _Base(__x) { } unordered_multimap(unordered_multimap&&) = default; explicit unordered_multimap(const allocator_type& __a) - : _Base(__a) - { } + : _Base(__a) { } unordered_multimap(const unordered_multimap& __ummap, const allocator_type& __a) - : _Base(__ummap._M_base(), __a) - { } + : _Base(__ummap._M_base(), __a) { } unordered_multimap(unordered_multimap&& __ummap, const allocator_type& __a) - : _Base(std::move(__ummap._M_base()), __a) - { } + : _Base(std::move(__ummap._M_base()), __a) { } unordered_multimap(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Base(__l, __n, __hf, __eql, __a) - { } + : _Base(__l, __n, __hf, __eql, __a) { } unordered_multimap& operator=(const unordered_multimap&) = default; @@ -392,7 +378,7 @@ namespace __profile void clear() noexcept { - __profcxx_hashtable_destruct(this, _Base::bucket_count(), + __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size()); this->_M_profile_destruct(); _Base::clear(); @@ -422,61 +408,61 @@ namespace __profile void insert(std::initializer_list __l) - { - size_type __old_size = _Base::bucket_count(); - _Base::insert(__l); - _M_profile_resize(__old_size); + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size); } iterator insert(const value_type& __obj) { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__obj); - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__obj); + _M_profile_resize(__old_size); + return __res; } iterator insert(const_iterator __iter, const value_type& __v) - { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__iter, __v); - _M_profile_resize(__old_size); - return __res; + { + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size); + return __res; } template::value>::type> - iterator - insert(_Pair&& __obj) - { + iterator + insert(_Pair&& __obj) + { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(std::forward<_Pair>(__obj)); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); return __res; } template::value>::type> - iterator - insert(const_iterator __iter, _Pair&& __v) - { - size_type __old_size = _Base::bucket_count(); + iterator + insert(const_iterator __iter, _Pair&& __v) + { + size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v)); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); return __res; } template - void - insert(_InputIter __first, _InputIter __last) - { - size_type __old_size = _Base::bucket_count(); + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); } void @@ -487,9 +473,9 @@ namespace __profile void rehash(size_type __n) { - size_type __old_size = _Base::bucket_count(); - _Base::rehash(__n); - _M_profile_resize(__old_size); + size_type __old_size = _Base::bucket_count(); + _Base::rehash(__n); + _M_profile_resize(__old_size); } private: @@ -497,8 +483,8 @@ namespace __profile _M_profile_resize(size_type __old_size) { size_type __new_size = _Base::bucket_count(); - if (__old_size != __new_size) - __profcxx_hashtable_resize(this, __old_size, __new_size); + if (__old_size != __new_size) + __profcxx_hashtable_resize(this, __old_size, __new_size); } }; diff --git a/libstdc++-v3/include/profile/unordered_set b/libstdc++-v3/include/profile/unordered_set index a7f8ea8aa3b..c42ddfeda62 100644 --- a/libstdc++-v3/include/profile/unordered_set +++ b/libstdc++-v3/include/profile/unordered_set @@ -44,7 +44,7 @@ namespace std _GLIBCXX_VISIBILITY(default) namespace __profile { /** @brief Unordered_set wrapper with performance instrumentation. */ - template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator<_Key> > @@ -62,18 +62,18 @@ namespace __profile _M_base() const noexcept { return *this; } public: - typedef typename _Base::size_type size_type; - typedef typename _Base::hasher hasher; - typedef typename _Base::key_equal key_equal; - typedef typename _Base::allocator_type allocator_type; - typedef typename _Base::key_type key_type; - typedef typename _Base::value_type value_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef typename _Base::iterator iterator; - typedef typename _Base::const_iterator const_iterator; + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; explicit unordered_set(size_type __n = 10, @@ -84,7 +84,7 @@ namespace __profile { } template - unordered_set(_InputIterator __f, _InputIterator __l, + unordered_set(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), @@ -144,10 +144,10 @@ namespace __profile void clear() noexcept { - __profcxx_hashtable_destruct(this, _Base::bucket_count(), - _Base::size()); - this->_M_profile_destruct(); - _Base::clear(); + __profcxx_hashtable_destruct(this, _Base::bucket_count(), + _Base::size()); + this->_M_profile_destruct(); + _Base::clear(); } template @@ -174,63 +174,63 @@ namespace __profile void insert(std::initializer_list __l) - { - size_type __old_size = _Base::bucket_count(); - _Base::insert(__l); - _M_profile_resize(__old_size); + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size); } std::pair insert(const value_type& __obj) { - size_type __old_size = _Base::bucket_count(); - std::pair __res = _Base::insert(__obj); - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + std::pair __res = _Base::insert(__obj); + _M_profile_resize(__old_size); + return __res; } iterator insert(const_iterator __iter, const value_type& __v) - { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__iter, __v); - _M_profile_resize(__old_size); - return __res; + { + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size); + return __res; } std::pair insert(value_type&& __obj) { - size_type __old_size = _Base::bucket_count(); - std::pair __res = _Base::insert(std::move(__obj)); - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + std::pair __res = _Base::insert(std::move(__obj)); + _M_profile_resize(__old_size); + return __res; } iterator insert(const_iterator __iter, value_type&& __v) - { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__iter, std::move(__v)); - _M_profile_resize(__old_size); - return __res; + { + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__iter, std::move(__v)); + _M_profile_resize(__old_size); + return __res; } template - void - insert(_InputIter __first, _InputIter __last) - { - size_type __old_size = _Base::bucket_count(); + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); } void rehash(size_type __n) { - size_type __old_size = _Base::bucket_count(); - _Base::rehash(__n); - _M_profile_resize(__old_size); + size_type __old_size = _Base::bucket_count(); + _Base::rehash(__n); + _M_profile_resize(__old_size); } private: @@ -287,10 +287,10 @@ namespace __profile public: typedef typename _Base::size_type size_type; - typedef typename _Base::hasher hasher; + typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; - typedef typename _Base::key_type key_type; + typedef typename _Base::key_type key_type; typedef typename _Base::value_type value_type; typedef typename _Base::difference_type difference_type; typedef typename _Base::reference reference; @@ -308,7 +308,7 @@ namespace __profile { } template - unordered_multiset(_InputIterator __f, _InputIterator __l, + unordered_multiset(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), @@ -368,10 +368,10 @@ namespace __profile void clear() noexcept { - __profcxx_hashtable_destruct(this, _Base::bucket_count(), - _Base::size()); - this->_M_profile_destruct(); - _Base::clear(); + __profcxx_hashtable_destruct(this, _Base::bucket_count(), + _Base::size()); + this->_M_profile_destruct(); + _Base::clear(); } template @@ -397,63 +397,63 @@ namespace __profile void insert(std::initializer_list __l) - { - size_type __old_size = _Base::bucket_count(); - _Base::insert(__l); - _M_profile_resize(__old_size); + { + size_type __old_size = _Base::bucket_count(); + _Base::insert(__l); + _M_profile_resize(__old_size); } iterator insert(const value_type& __obj) { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__obj); - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__obj); + _M_profile_resize(__old_size); + return __res; } iterator insert(const_iterator __iter, const value_type& __v) { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__iter, __v); - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__iter, __v); + _M_profile_resize(__old_size); + return __res; } iterator insert(value_type&& __obj) { size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(std::move(__obj)); - _M_profile_resize(__old_size); - return __res; + iterator __res = _Base::insert(std::move(__obj)); + _M_profile_resize(__old_size); + return __res; } iterator insert(const_iterator __iter, value_type&& __v) { - size_type __old_size = _Base::bucket_count(); - iterator __res = _Base::insert(__iter, std::move(__v)); - _M_profile_resize(__old_size); - return __res; + size_type __old_size = _Base::bucket_count(); + iterator __res = _Base::insert(__iter, std::move(__v)); + _M_profile_resize(__old_size); + return __res; } template - void - insert(_InputIter __first, _InputIter __last) - { - size_type __old_size = _Base::bucket_count(); + void + insert(_InputIter __first, _InputIter __last) + { + size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); - _M_profile_resize(__old_size); + _M_profile_resize(__old_size); } void rehash(size_type __n) { - size_type __old_size = _Base::bucket_count(); - _Base::rehash(__n); - _M_profile_resize(__old_size); + size_type __old_size = _Base::bucket_count(); + _Base::rehash(__n); + _M_profile_resize(__old_size); } private: @@ -461,8 +461,8 @@ namespace __profile _M_profile_resize(size_type __old_size) { size_type __new_size = _Base::bucket_count(); - if (__old_size != __new_size) - __profcxx_hashtable_resize(this, __old_size, __new_size); + if (__old_size != __new_size) + __profcxx_hashtable_resize(this, __old_size, __new_size); } }; diff --git a/libstdc++-v3/include/profile/vector b/libstdc++-v3/include/profile/vector index 5c2c6219029..0933ca34cc2 100644 --- a/libstdc++-v3/include/profile/vector +++ b/libstdc++-v3/include/profile/vector @@ -37,87 +37,134 @@ namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { - template > - class vector - : public _GLIBCXX_STD_C::vector<_Tp, _Allocator> + template + class _Vector_profile_pre { - typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base; + _Vector& + _M_conjure() + { return *static_cast<_Vector*>(this); } + + public: +#if __cplusplus >= 201103L + _Vector_profile_pre() = default; + _Vector_profile_pre(const _Vector_profile_pre&) = default; + _Vector_profile_pre(_Vector_profile_pre&&) = default; + + _Vector_profile_pre& + operator=(const _Vector_profile_pre&) = default; - typedef typename _Base::iterator _Base_iterator; - typedef typename _Base::const_iterator _Base_const_iterator; + _Vector_profile_pre& + operator=(_Vector_profile_pre&&) noexcept + { _M_profile_destruct(); } +#endif + + void + _M_profile_destruct() + { + __profcxx_vector_destruct2(&_M_conjure()); + __profcxx_vector_destruct(&_M_conjure(), + _M_conjure().capacity(), _M_conjure().size()); + } + }; + + template + class _Vector_profile_post + { + _Vector& + _M_conjure() + { return *static_cast<_Vector*>(this); } + + protected: + _Vector_profile_post() _GLIBCXX_NOEXCEPT + { + __profcxx_vector_construct(&_M_conjure(), _M_conjure().capacity()); + __profcxx_vector_construct2(&_M_conjure()); + } #if __cplusplus >= 201103L - typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits; + _Vector_profile_post(const _Vector_profile_post&) noexcept + : _Vector_profile_post() { } + _Vector_profile_post(_Vector_profile_post&&) noexcept + : _Vector_profile_post() { } + + _Vector_profile_post& + operator=(const _Vector_profile_post&) = default; + _Vector_profile_post& + operator=(_Vector_profile_post&&) = default; #endif + ~_Vector_profile_post() + { _M_conjure()._M_profile_destruct(); } + }; + + template > + class vector + : public _Vector_profile_pre >, + public _GLIBCXX_STD_C::vector<_Tp, _Allocator>, + public _Vector_profile_post > + { + typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base; + + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_iterator _Base_const_iterator; + public: - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; typedef __iterator_tracker<_Base_iterator, vector> - iterator; + iterator; typedef __iterator_tracker<_Base_const_iterator, vector> - const_iterator; - - typedef typename _Base::size_type size_type; - typedef typename _Base::difference_type difference_type; - - typedef _Tp value_type; - typedef _Allocator allocator_type; - typedef typename _Base::pointer pointer; - typedef typename _Base::const_pointer const_pointer; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; - + const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + _Base& - _M_base() _GLIBCXX_NOEXCEPT { return *this; } + _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& - _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } // 23.2.4.1 construct/copy/destroy: - vector() _GLIBCXX_NOEXCEPT - : _Base() - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } +#if __cplusplus < 201103L + vector() + { } + + vector(const vector& __x) + : _Base(__x) { } +#else + vector() = default; + vector(const vector&) = default; + vector(vector&&) = default; +#endif explicit vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT - : _Base(__a) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(__a) { } #if __cplusplus >= 201103L explicit vector(size_type __n, const _Allocator& __a = _Allocator()) - : _Base(__n, __a) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(__n, __a) { } vector(size_type __n, const _Tp& __value, const _Allocator& __a = _Allocator()) - : _Base(__n, __value, __a) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(__n, __value, __a) { } #else explicit vector(size_type __n, const _Tp& __value = _Tp(), const _Allocator& __a = _Allocator()) - : _Base(__n, __value, __a) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(__n, __value, __a) { } #endif #if __cplusplus >= 201103L @@ -126,91 +173,48 @@ namespace __profile #else template #endif - vector(_InputIterator __first, _InputIterator __last, + vector(_InputIterator __first, _InputIterator __last, const _Allocator& __a = _Allocator()) - : _Base(__first, __last, __a) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(__first, __last, __a) { } - vector(const vector& __x) - : _Base(__x) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } - - /// Construction from a release-mode vector + /// Construction from a normal-mode vector vector(const _Base& __x) - : _Base(__x) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(__x) { } #if __cplusplus >= 201103L - vector(vector&& __x) noexcept - : _Base(std::move(__x)) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } - vector(const _Base& __x, const _Allocator& __a) - : _Base(__x, __a) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(__x, __a) { } vector(vector&& __x, const _Allocator& __a) - : _Base(std::move(__x), __a) - { - __profcxx_vector_construct(this, this->capacity()); - __profcxx_vector_construct2(this); - } + : _Base(std::move(__x), __a) { } vector(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__l, __a) { } #endif - ~vector() _GLIBCXX_NOEXCEPT - { - __profcxx_vector_destruct(this, this->capacity(), this->size()); - __profcxx_vector_destruct2(this); - } - +#if __cplusplus < 201103L vector& operator=(const vector& __x) { - static_cast<_Base&>(*this) = __x; - return *this; + _M_base() = __x; + return *this; } +#else + vector& + operator=(const vector&) = default; -#if __cplusplus >= 201103L vector& - operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) - { - __profcxx_vector_destruct(this, this->capacity(), this->size()); - __profcxx_vector_destruct2(this); - static_cast<_Base&>(*this) = std::move(__x); - return *this; - } + operator=(vector&&) = default; vector& operator=(initializer_list __l) { - static_cast<_Base&>(*this) = __l; + _M_base() = __l; return *this; } #endif - using _Base::assign; - using _Base::get_allocator; - - // iterators: iterator begin() _GLIBCXX_NOEXCEPT @@ -263,183 +267,135 @@ namespace __profile #endif // 23.2.4.2 capacity: - using _Base::size; - using _Base::max_size; #if __cplusplus >= 201103L void resize(size_type __sz) { - __profcxx_vector_invalid_operator(this); - _M_profile_resize(this, this->capacity(), __sz); - _Base::resize(__sz); + __profcxx_vector_invalid_operator(this); + _M_profile_resize(this->capacity(), __sz); + _Base::resize(__sz); } void resize(size_type __sz, const _Tp& __c) { - __profcxx_vector_invalid_operator(this); - _M_profile_resize(this, this->capacity(), __sz); - _Base::resize(__sz, __c); + __profcxx_vector_invalid_operator(this); + _M_profile_resize(this->capacity(), __sz); + _Base::resize(__sz, __c); } #else void resize(size_type __sz, _Tp __c = _Tp()) { - __profcxx_vector_invalid_operator(this); - _M_profile_resize(this, this->capacity(), __sz); - _Base::resize(__sz, __c); + __profcxx_vector_invalid_operator(this); + _M_profile_resize(this->capacity(), __sz); + _Base::resize(__sz, __c); } #endif -#if __cplusplus >= 201103L - using _Base::shrink_to_fit; -#endif - - using _Base::empty; - // element access: reference operator[](size_type __n) _GLIBCXX_NOEXCEPT { - __profcxx_vector_invalid_operator(this); - return _M_base()[__n]; + __profcxx_vector_invalid_operator(this); + return _M_base()[__n]; } const_reference operator[](size_type __n) const _GLIBCXX_NOEXCEPT { - __profcxx_vector_invalid_operator(this); - return _M_base()[__n]; - } - - using _Base::at; - - reference - front() _GLIBCXX_NOEXCEPT - { - return _Base::front(); - } - - const_reference - front() const _GLIBCXX_NOEXCEPT - { - return _Base::front(); + __profcxx_vector_invalid_operator(this); + return _M_base()[__n]; } - reference - back() _GLIBCXX_NOEXCEPT - { - return _Base::back(); - } - - const_reference - back() const _GLIBCXX_NOEXCEPT - { - return _Base::back(); - } - - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // DR 464. Suggestion for new member functions in standard containers. - using _Base::data; - // 23.2.4.3 modifiers: void push_back(const _Tp& __x) { - size_type __old_size = this->capacity(); + size_type __old_size = this->capacity(); _Base::push_back(__x); - _M_profile_resize(this, __old_size, this->capacity()); + _M_profile_resize(__old_size, this->capacity()); } #if __cplusplus >= 201103L void push_back(_Tp&& __x) { - size_type __old_size = this->capacity(); - _Base::push_back(std::move(__x)); - _M_profile_resize(this, __old_size, this->capacity()); + size_type __old_size = this->capacity(); + _Base::push_back(std::move(__x)); + _M_profile_resize(__old_size, this->capacity()); } #endif iterator #if __cplusplus >= 201103L - insert(const_iterator __position, const _Tp& __x) + insert(const_iterator __pos, const _Tp& __x) #else - insert(iterator __position, const _Tp& __x) + insert(iterator __pos, const _Tp& __x) #endif { - __profcxx_vector_insert(this, __position.base() - _Base::begin(), - this->size()); - size_type __old_size = this->capacity(); - _Base_iterator __res = _Base::insert(__position.base(), __x); - _M_profile_resize(this, __old_size, this->capacity()); + __profcxx_vector_insert(this, __pos.base() - _Base::begin(), + this->size()); + size_type __old_size = this->capacity(); + _Base_iterator __res = _Base::insert(__pos.base(), __x); + _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } #if __cplusplus >= 201103L iterator - insert(const_iterator __position, _Tp&& __x) + insert(const_iterator __pos, _Tp&& __x) { - __profcxx_vector_insert(this, __position.base() - _Base::cbegin(), - this->size()); - size_type __old_size = this->capacity(); - _Base_iterator __res = _Base::insert(__position.base(), __x); - _M_profile_resize(this, __old_size, this->capacity()); + __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(), + this->size()); + size_type __old_size = this->capacity(); + _Base_iterator __res = _Base::insert(__pos.base(), __x); + _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } template - iterator - emplace(const_iterator __position, _Args&&... __args) - { - _Base_iterator __res = _Base::emplace(__position.base(), + iterator + emplace(const_iterator __pos, _Args&&... __args) + { + _Base_iterator __res = _Base::emplace(__pos.base(), std::forward<_Args>(__args)...); return iterator(__res, this); } iterator - insert(const_iterator __position, initializer_list __l) - { return this->insert(__position, __l.begin(), __l.end()); } -#endif - -#if __cplusplus >= 201103L - void - swap(vector&& __x) - { - _Base::swap(__x); - } + insert(const_iterator __pos, initializer_list __l) + { return this->insert(__pos, __l.begin(), __l.end()); } #endif void swap(vector& __x) #if __cplusplus >= 201103L - noexcept(_Alloc_traits::_S_nothrow_swap()) + noexcept( noexcept(declval<_Base>().swap(__x)) ) #endif - { - _Base::swap(__x); - } + { _Base::swap(__x); } #if __cplusplus >= 201103L iterator - insert(const_iterator __position, size_type __n, const _Tp& __x) + insert(const_iterator __pos, size_type __n, const _Tp& __x) { - __profcxx_vector_insert(this, __position.base() - _Base::cbegin(), - this->size()); - size_type __old_size = this->capacity(); - _Base_iterator __res = _Base::insert(__position, __n, __x); - _M_profile_resize(this, __old_size, this->capacity()); + __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(), + this->size()); + size_type __old_size = this->capacity(); + _Base_iterator __res = _Base::insert(__pos, __n, __x); + _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } #else void - insert(iterator __position, size_type __n, const _Tp& __x) + insert(iterator __pos, size_type __n, const _Tp& __x) { - __profcxx_vector_insert(this, __position.base() - _Base::begin(), - this->size()); - size_type __old_size = this->capacity(); - _Base::insert(__position, __n, __x); - _M_profile_resize(this, __old_size, this->capacity()); + __profcxx_vector_insert(this, __pos.base() - _Base::begin(), + this->size()); + size_type __old_size = this->capacity(); + _Base::insert(__pos, __n, __x); + _M_profile_resize(__old_size, this->capacity()); } #endif @@ -447,40 +403,37 @@ namespace __profile template> iterator - insert(const_iterator __position, + insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) - { - __profcxx_vector_insert(this, __position.base() - _Base::cbegin(), + { + __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(), this->size()); size_type __old_size = this->capacity(); - _Base_iterator __res = _Base::insert(__position, __first, __last); - _M_profile_resize(this, __old_size, this->capacity()); + _Base_iterator __res = _Base::insert(__pos, __first, __last); + _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } #else template void - insert(iterator __position, + insert(iterator __pos, _InputIterator __first, _InputIterator __last) - { - __profcxx_vector_insert(this, __position.base() - _Base::begin(), + { + __profcxx_vector_insert(this, __pos.base() - _Base::begin(), this->size()); size_type __old_size = this->capacity(); - _Base::insert(__position, __first, __last); - _M_profile_resize(this, __old_size, this->capacity()); + _Base::insert(__pos, __first, __last); + _M_profile_resize(__old_size, this->capacity()); } #endif iterator #if __cplusplus >= 201103L - erase(const_iterator __position) + erase(const_iterator __pos) #else - erase(iterator __position) + erase(iterator __pos) #endif - { - _Base_iterator __res = _Base::erase(__position.base()); - return iterator(__res, this); - } + { return iterator(_Base::erase(__pos.base()), this); } iterator #if __cplusplus >= 201103L @@ -488,76 +441,66 @@ namespace __profile #else erase(iterator __first, iterator __last) #endif - { - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 151. can't currently clear() empty container - _Base_iterator __res = _Base::erase(__first.base(), __last.base()); - return iterator(__res, this); - } + { return iterator(_Base::erase(__first.base(), __last.base()), this); } void clear() _GLIBCXX_NOEXCEPT { - __profcxx_vector_destruct(this, this->capacity(), this->size()); - __profcxx_vector_destruct2(this); - _Base::clear(); + this->_M_profile_destruct(); + _Base::clear(); } - inline void _M_profile_find() const - { - __profcxx_vector_find(this, size()); - } + inline void _M_profile_find() const + { __profcxx_vector_find(this, this->size()); } - inline void _M_profile_iterate(int __rewind = 0) const - { - __profcxx_vector_iterate(this); - } + inline void _M_profile_iterate(int __rewind = 0) const + { __profcxx_vector_iterate(this); } private: - void _M_profile_resize(void* obj, size_type __old_size, - size_type __new_size) + void _M_profile_resize(size_type __old_size, size_type __new_size) { - if (__old_size < __new_size) { - __profcxx_vector_resize(this, this->size(), __new_size); - __profcxx_vector_resize2(this, this->size(), __new_size); - } + if (__old_size < __new_size) + { + __profcxx_vector_resize(this, this->size(), __new_size); + __profcxx_vector_resize2(this, this->size(), __new_size); + } } }; template inline bool operator==(const vector<_Tp, _Alloc>& __lhs, - const vector<_Tp, _Alloc>& __rhs) + const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() == __rhs._M_base(); } template inline bool operator!=(const vector<_Tp, _Alloc>& __lhs, - const vector<_Tp, _Alloc>& __rhs) + const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() != __rhs._M_base(); } template inline bool operator<(const vector<_Tp, _Alloc>& __lhs, - const vector<_Tp, _Alloc>& __rhs) + const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() < __rhs._M_base(); } template inline bool operator<=(const vector<_Tp, _Alloc>& __lhs, - const vector<_Tp, _Alloc>& __rhs) + const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() <= __rhs._M_base(); } template inline bool operator>=(const vector<_Tp, _Alloc>& __lhs, - const vector<_Tp, _Alloc>& __rhs) + const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() >= __rhs._M_base(); } template inline bool operator>(const vector<_Tp, _Alloc>& __lhs, - const vector<_Tp, _Alloc>& __rhs) + const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() > __rhs._M_base(); } template