[counting-allocator] macOS buildtools/third_party/libc++/trunk/ changes.

include/string

 // -*- C++ -*-
 //===--------------------------- string -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 1305 matching lines @@
 
     enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
 
     struct __raw
     {
         size_type __words[__n_words];
     };
 
     struct __rep
     {
+        __rep(): __s() {}
         union
         {
             __long  __l;
             __short __s;
             __raw   __r;
         };
     };
 
     __compressed_pair<__rep, allocator_type> __r_;
 
@@ skipping 415 matching lines @@
 #   endif
 
 #endif  // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_long_size(size_type __s) _NOEXCEPT
         {__r_.first().__l.__size_ = __s;}
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_long_size() const _NOEXCEPT
         {return __r_.first().__l.__size_;}
+
     _LIBCPP_INLINE_VISIBILITY
     void __set_size(size_type __s) _NOEXCEPT
-        {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
+    {
+        if (__is_long())
+        {
+            __count_destroyed(__alloc(), __get_long_size());
+            __count_constructed(__alloc(), __s);
+            __set_long_size(__s);
+        }
+        else
+        {
+            __set_short_size(__s);
+        }
+    }
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_long_cap(size_type __s) _NOEXCEPT
         {__r_.first().__l.__cap_  = __long_mask | __s;}
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_long_cap() const _NOEXCEPT
         {return __r_.first().__l.__cap_ & size_type(~__long_mask);}
 
     _LIBCPP_INLINE_VISIBILITY
+    void __set_long_cap_size(size_type __c, size_type __s) _NOEXCEPT
+    {
+        if (__is_long())
+        {
+            __count_destroyed(__alloc(), __get_long_size());
+        }
+        __set_long_cap(__c);
+        __set_long_size(__s);
+        __count_constructed(__alloc(), __s);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
     void __set_long_pointer(pointer __p) _NOEXCEPT
         {__r_.first().__l.__data_ = __p;}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_long_pointer() _NOEXCEPT
         {return __r_.first().__l.__data_;}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_long_pointer() const _NOEXCEPT
         {return __r_.first().__l.__data_;}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_short_pointer() _NOEXCEPT
@@ skipping 198 matching lines @@
     if (__reserve < __min_cap)
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__reserve);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
         __set_long_pointer(__p);
-        __set_long_cap(__cap+1);
-        __set_long_size(__sz);
+        __set_long_cap_size(__cap+1, __sz);
     }
     traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);
     traits_type::assign(__p[__sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
 {
     if (__sz > max_size())
         this->__throw_length_error();
     pointer __p;
     if (__sz < __min_cap)
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__sz);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
         __set_long_pointer(__p);
-        __set_long_cap(__cap+1);
-        __set_long_size(__sz);
+        __set_long_cap_size(__cap+1, __sz);
     }
     traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);
     traits_type::assign(__p[__sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s)
 {
     _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
@@ skipping 115 matching lines @@
     if (__n < __min_cap)
     {
         __set_short_size(__n);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__n);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
         __set_long_pointer(__p);
-        __set_long_cap(__cap+1);
-        __set_long_size(__n);
+        __set_long_cap_size(__cap+1, __n);
     }
     traits_type::assign(_VSTD::__to_raw_pointer(__p), __n, __c);
     traits_type::assign(__p[__n], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_type __c)
 {
     __init(__n, __c);
@@ skipping 41 matching lines @@
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
     for (; __first != __last; ++__first)
         push_back(*__first);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
+        __set_size(0);
         if (__is_long())
             __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
@@ skipping 10 matching lines @@
     if (__sz < __min_cap)
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__sz);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
         __set_long_pointer(__p);
-        __set_long_cap(__cap+1);
-        __set_long_size(__sz);
+        __set_long_cap_size(__cap+1, __sz);
     }
     for (; __first != __last; ++__first, (void) ++__p)
         traits_type::assign(*__p, *__first);
     traits_type::assign(*__p, value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
@@ skipping 41 matching lines @@
 }
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::~basic_string()
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__erase_c(this);
 #endif
+    __set_size(0);
     if (__is_long())
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
     (size_type __old_cap, size_type __delta_cap, size_type __old_sz,
      size_type __n_copy,  size_type __n_del,     size_type __n_add, const value_type* __p_new_stuff)
 {
@@ skipping 11 matching lines @@
                           _VSTD::__to_raw_pointer(__old_p), __n_copy);
     if (__n_add != 0)
         traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy, __p_new_stuff, __n_add);
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
     if (__sec_cp_sz != 0)
         traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add,
                           _VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del, __sec_cp_sz);
     if (__old_cap+1 != __min_cap)
         __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
     __set_long_pointer(__p);
-    __set_long_cap(__cap+1);
     __old_sz = __n_copy + __n_add + __sec_cp_sz;
-    __set_long_size(__old_sz);
+    __set_long_cap_size(__cap+1, __old_sz);
     traits_type::assign(__p[__old_sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                                                      size_type __n_copy,  size_type __n_del,     size_type __n_add)
 {
     size_type __ms = max_size();
     if (__delta_cap > __ms - __old_cap)
         this->__throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
                           __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                           __ms - 1;
     pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
     __invalidate_all_iterators();
     if (__n_copy != 0)
         traits_type::copy(_VSTD::__to_raw_pointer(__p),
                           _VSTD::__to_raw_pointer(__old_p), __n_copy);
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
     if (__sec_cp_sz != 0)
         traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add,
                           _VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del,
                           __sec_cp_sz);
     if (__old_cap+1 != __min_cap)
         __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
     __set_long_pointer(__p);
-    __set_long_cap(__cap+1);
+    __set_long_cap_size(__cap+1, __old_sz);
 }
 
 // assign
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
     size_type __cap = capacity();
@@ skipping 33 matching lines @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
 {
     pointer __p;
     if (__is_long())
     {
         __p = __get_long_pointer();
-        __set_long_size(1);
     }
     else
     {
         __p = __get_short_pointer();
-        __set_short_size(1);
     }
+    __set_size(1);
     traits_type::assign(*__p, __c);
     traits_type::assign(*++__p, value_type());
     __invalidate_iterators_past(1);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 {
@@ skipping 180 matching lines @@
     }
     if (__sz == __cap)
     {
         __grow_by(__cap, 1, __sz, __sz, 0);
         __is_short = !__is_long();
     }
     pointer __p;
     if (__is_short)
     {
         __p = __get_short_pointer() + __sz;
-        __set_short_size(__sz+1);
     }
     else
     {
         __p = __get_long_pointer() + __sz;
-        __set_long_size(__sz+1);
     }
+    __set_size(__sz+1);
     traits_type::assign(*__p, __c);
     traits_type::assign(*++__p, value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
 typename enable_if
 <
      __is_input_iterator  <_InputIterator>::value &&
     !__is_forward_iterator<_InputIterator>::value,
@@ skipping 497 matching lines @@
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::pop_back()
 {
     _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
     size_type __sz;
     if (__is_long())
     {
         __sz = __get_long_size() - 1;
-        __set_long_size(__sz);
         traits_type::assign(*(__get_long_pointer() + __sz), value_type());
     }
     else
     {
         __sz = __get_short_size() - 1;
-        __set_short_size(__sz);
         traits_type::assign(*(__get_short_pointer() + __sz), value_type());
     }
+    __set_size(__sz);
     __invalidate_iterators_past(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
 {
     __invalidate_all_iterators();
     if (__is_long())
     {
         traits_type::assign(*__get_long_pointer(), value_type());
-        __set_long_size(0);
     }
     else
     {
         traits_type::assign(*__get_short_pointer(), value_type());
-        __set_short_size(0);
     }
+    __set_size(0);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
 {
     if (__is_long())
     {
         traits_type::assign(*(__get_long_pointer() + __pos), value_type());
-        __set_long_size(__pos);
     }
     else
     {
         traits_type::assign(*(__get_short_pointer() + __pos), value_type());
-        __set_short_size(__pos);
     }
+    __set_size(__pos);
     __invalidate_iterators_past(__pos);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
 {
     size_type __sz = size();
     if (__n > __sz)
         append(__n - __sz, __c);
@@ skipping 54 matching lines @@
                 }
             #else  // _LIBCPP_NO_EXCEPTIONS
                 if (__new_data == nullptr)
                     return;
             #endif  // _LIBCPP_NO_EXCEPTIONS
             }
             __now_long = true;
             __was_long = __is_long();
             __p = __get_pointer();
         }
+        __set_size(0);
         traits_type::copy(_VSTD::__to_raw_pointer(__new_data),
-                          _VSTD::__to_raw_pointer(__p), size()+1);
+                          _VSTD::__to_raw_pointer(__p), __sz+1);
         if (__was_long)
             __alloc_traits::deallocate(__alloc(), __p, __cap+1);
         if (__now_long)
         {
-            __set_long_cap(__res_arg+1);
-            __set_long_size(__sz);
+            __set_long_cap_size(__res_arg+1, __sz);
             __set_long_pointer(__new_data);
         }
         else
             __set_short_size(__sz);
         __invalidate_all_iterators();
     }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ skipping 989 matching lines @@
     basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
     {
         return basic_string<char32_t> (__str, __len);
     }
   }
 }
 #endif
 
 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_string<char>)
 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_string<wchar_t>)
-_LIBCPP_EXTERN_TEMPLATE(string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
+_LIBCPP_EXTERN_TEMPLATE(string operator+<char, char_traits<char>, counting_allocator<char, allocation_group::string> >(char const*, string const&))
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_STRING