std::string asan annotations

[aizatsky]

Summary

This change adds ASAN container annotations to std::string. String-specific annotations can be disabled with _LIBCPP_NO_ASAN_STD_STRING define.

When the string is small, in-object memory is appropriately poisoned to catch the code accessing invalid memory regions.

For new string layout, it is impossible to poison memory precisely due to last byte containing string size. In this new layout last 8 bytes of string object are never poisoned.

[aizatsky]

This comment was removed by aizatsky.

[aizatsky]

This comment was removed by aizatsky.

[aizatsky]

wip

[aizatsky]

cleanup

[aizatsky]

cleanup

[kcc]

looks reasonable. Please avoid space-only and {}-only changes.

Hopefully Marshall can have a look too.

include/string

1782

this division deserves a comment

2358

looks like you are only adding {}
do you need to?

2472

{}-only change?

2702

{}-only change?

2959

extra line?

2968

extra line?

3062

seems to be a common pattern. Hide it inside __annotate_*?

[aizatsky]

nits

[aizatsky]

ptal

include/string

3062

It is not. Sometimes it is >, sometimes it is <, sometimes it is unconditionable.

[aizatsky]

friendly ping.

[aizatsky]

Marshall,

Is there still an interest in this? If there is, let's figure out a way to move this forward.

[mclow.lists]

I will rebase this as soon as D21459 lands.

[aizatsky]

Marshall,

I'm happy to rebase it myself if you have some time for reviewing this afterwards. I'd like to verify that everything works since it has been quite a while since I last touched this.

[mclow.lists]

Mike - I'll be happy to review it after 5-Aug. (I'll be doing committee stuff all next week).

include/string

 
 template <class _CharT>
 struct __padding<_CharT, 1>
 {
 };
 
 #endif  // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
+template <class _CharT, class _Allocator>
+struct _LIBCPP_TYPE_VIS_ONLY basic_string_asan_traits {
+  typedef allocator_traits<_Allocator> __alloc_traits;
+  typedef typename __alloc_traits::const_pointer __const_pointer;
+
+  static void __annotate_delete(__const_pointer __beg, __const_pointer __mid,
+                                __const_pointer __end) {}
+
+  static void __annotate_new(__const_pointer __beg, __const_pointer __mid,
+                             __const_pointer __end) {}
+
+  static void __annotate_grow(__const_pointer __beg, __const_pointer __old_mid,
+                              __const_pointer __new_mid,
+                              __const_pointer __end) {}
+};
+
+// asan is enabled only for default allocator.
+template <class _CharT>
+struct _LIBCPP_TYPE_VIS_ONLY
+    basic_string_asan_traits<_CharT, allocator<_CharT>> {
+  typedef allocator<_CharT> __allocator;
+  typedef allocator_traits<__allocator> __alloc_traits;
+  typedef typename __alloc_traits::const_pointer __const_pointer;
+
+  static void __annotate_delete(__const_pointer __beg, __const_pointer __mid,
+                                __const_pointer __end) {
+   __annotate_contiguous_container(__beg, __end, __mid, __end);
+  }
+
+  static void __annotate_new(__const_pointer __beg, __const_pointer __mid,
+                             __const_pointer __end) {
+    __annotate_contiguous_container(__beg, __end, __end, __mid);
+  }
+
+  static void __annotate_grow(__const_pointer __beg, __const_pointer __old_mid,
+                              __const_pointer __new_mid,
+                              __const_pointer __end) {
+  __annotate_contiguous_container(__beg, __end, __old_mid, __new_mid);
+  }
+
+private:
+  static void __annotate_contiguous_container(const void *__beg,
+                                              const void *__end,
+                                              const void *__old_mid,
+                                              const void *__new_mid) {
+#if !defined(_LIBCPP_HAS_NO_ASAN) && !defined(_LIBCPP_NO_ASAN_STD_STRING)
+    if (__beg) {
+      __sanitizer_annotate_contiguous_container(__beg, __end, __old_mid,
+                                                __new_mid);
+    }
+#endif
+  }
+};
+
 template<class _CharT, class _Traits, class _Allocator>
 class _LIBCPP_TYPE_VIS_ONLY basic_string
     : private __basic_string_common<true>
 {
 public:
     typedef basic_string                                 __self;
     typedef _Traits                                      traits_type;
     typedef typename traits_type::char_type              value_type;
     typedef _Allocator                                   allocator_type;
     typedef allocator_traits<allocator_type>             __alloc_traits;
     typedef typename __alloc_traits::size_type           size_type;
     typedef typename __alloc_traits::difference_type     difference_type;
     typedef value_type&                                  reference;
     typedef const value_type&                            const_reference;
     typedef typename __alloc_traits::pointer             pointer;
     typedef typename __alloc_traits::const_pointer       const_pointer;
+    typedef basic_string_asan_traits<_CharT, _Allocator> __asan_traits;
 
     static_assert(is_pod<value_type>::value, "Character type of basic_string must be a POD");
     static_assert((is_same<_CharT, value_type>::value),
                   "traits_type::char_type must be the same type as CharT");
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 #if defined(_LIBCPP_RAW_ITERATORS)
     typedef pointer                                      iterator;

 private:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type& __alloc() _NOEXCEPT
         {return __r_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const allocator_type& __alloc() const _NOEXCEPT
         {return __r_.second();}
 
+    const_pointer __get_beg() const _NOEXCEPT {
+      if (__is_long())
+        return __get_long_pointer();
+
+#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+      return pointer_traits<const_pointer>::pointer_to(
+          __r_.first().__s.__data_[0]);
+#else
+      return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__lx);
+#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+    }
+
+    const_pointer __get_mid(size_type __sz) const _NOEXCEPT {
+      if (__is_long())
+        return __get_long_pointer() + __sz + 1 /* terminator */;
+      else
+        return min(__get_short_pointer() + __sz + 1 /* terminator */,
+                   __get_end());
+    }
+
+    const_pointer __get_end() const _NOEXCEPT {
+      if (__is_long())
+        return __get_long_pointer() + __get_long_cap();
+
+      const_pointer __p = __get_beg() + __min_cap + 1 /* size */;
+#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+      // last byte is used for size. ASAN can't poison
+      // memory precisely in this case. Do not poison last 8 bytes.
+      __p -= 8 / sizeof(value_type) ;
+#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+
+      return __p;
+    }
+
+    void __annotate_new(size_type __sz) const {
+      __asan_traits::__annotate_new(__get_beg(), __get_mid(__sz), __get_end());
+    }
+
+    void __annotate_grow(size_type __old_size, size_type __new_size) const {
+      __asan_traits::__annotate_grow(__get_beg(), __get_mid(__old_size),
+                                     __get_mid(__new_size), __get_end());
+    }
+
+    basic_string<_CharT, _Traits, _Allocator> const *__annotate_delete() const {
+      __asan_traits::__annotate_delete(__get_beg(), __get_mid(size()),
+                                       __get_end());
+      return this;
+    }
+
 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_short_size(size_type __s) _NOEXCEPT
 #   if _LIBCPP_BIG_ENDIAN
         {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
 #   else
         {__r_.first().__s.__size_ = (unsigned char)(__s);}
#endif  // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_pointer() _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_pointer() const _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void __zero() _NOEXCEPT
-        {
-            size_type (&__a)[__n_words] = __r_.first().__r.__words;
-            for (unsigned __i = 0; __i < __n_words; ++__i)
-                __a[__i] = 0;
-        }
+    void __zero() _NOEXCEPT {
+      size_type(&__a)[__n_words] = __r_.first().__r.__words;
+      __annotate_new(0);
 
     template <size_type __a> static
         _LIBCPP_INLINE_VISIBILITY
         size_type __align_it(size_type __s) _NOEXCEPT
             {return (__s + (__a-1)) & ~(__a-1);}
     enum {__alignment = 16};
     static _LIBCPP_INLINE_VISIBILITY
     size_type __recommend(size_type __s) _NOEXCEPT
#endif
     {__move_assign_alloc(__str, integral_constant<bool,
                       __alloc_traits::propagate_on_container_move_assignment::value>());}
 
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(basic_string& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
             __alloc() = _VSTD::move(__c.__alloc());
+            __annotate_new(size());
+            __c.__annotate_delete();
         }
 
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(basic_string&, false_type)
         _NOEXCEPT
         {}
 
     _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz, size_type __reserve)
     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);
     }
+    __annotate_new(__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);
     }
+    __annotate_new(__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)
 {
#if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
     : __r_(__alloc_traits::select_on_container_copy_construction(__str.__alloc()))
 {
-    if (!__str.__is_long())
-        __r_.first().__r = __str.__r_.first().__r;
-    else
+    if (!__str.__is_long()) {
+      __str.__annotate_delete();
+      __str.__annotate_new(__str.__get_short_size());
+      __annotate_new(__get_short_size());
+    } else
           __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, const allocator_type& __a)
     : __r_(__a)
 {
-    if (!__str.__is_long())
+    if (!__str.__is_long()) {
+        __str.__annotate_delete();
         __r_.first().__r = __str.__r_.first().__r;
+        __str.__annotate_new(__str.__get_short_size());
+        __annotate_new(__get_short_size());
+    }
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
-    : __r_(_VSTD::move(__str.__r_))
+    : __r_(_VSTD::move(__str.__annotate_delete()->__r_))
 {
     __str.__zero();
+    __annotate_new(size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
     if (__is_long())
         __get_db()->swap(this, &__str);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
     : __r_(__a)
 {
     if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
     else
     {
+        __str.__annotate_delete();
         __r_.first().__r = __str.__r_.first().__r;
         __str.__zero();
+        __annotate_new(__get_short_size());
     }
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
     if (__is_long())
         __get_db()->swap(this, &__str);
 #endif
 }
 
basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
     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);
     }
+    __annotate_new(__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)
 {
<
     void
 >::type
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__sz > max_size())
         this->__throw_length_error();
     pointer __p;
+    size_type __cap;
     if (__sz < __min_cap)
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
+        __cap = __min_cap;
     }
     else
     {
-        size_type __cap = __recommend(__sz);
+        __cap = __recommend(__sz);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__sz);
     }
-    for (; __first != __last; ++__first, (void) ++__p)
+
+    __annotate_new(__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)
 {
     __init(__first, __last);
 #if _LIBCPP_DEBUG_LEVEL >= 2

 #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
+
+    __annotate_delete();
     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,
basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
     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);
+    __annotate_delete();
     __set_long_pointer(__p);
     __set_long_cap(__cap+1);
     __old_sz = __n_copy + __n_add + __sec_cp_sz;
     __set_long_size(__old_sz);
+    __annotate_new(__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);
+    __annotate_delete();
     __set_long_pointer(__p);
     __set_long_cap(__cap+1);
 }
 
 // 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();
+    size_type __sz = size();
     if (__cap >= __n)
     {
         value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
+        __annotate_grow(__sz, __n);
         traits_type::move(__p, __s, __n);
         traits_type::assign(__p[__n], value_type());
         __set_size(__n);
         __invalidate_iterators_past(__n);
     }
     else
-    {
-        size_type __sz = size();
         __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
-    }
+
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
 {
     size_type __cap = capacity();
+    size_type __sz = size();
     if (__cap < __n)
     {
-        size_type __sz = size();
         __grow_by(__cap, __n - __cap, __sz, 0, __sz);
+        __annotate_new(__sz);
     }
     else
         __invalidate_iterators_past(__n);
     value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
+    __annotate_grow(__sz, __n);
     traits_type::assign(__p, __n, __c);
     traits_type::assign(__p[__n], value_type());
     __set_size(__n);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
 {
     pointer __p;
+    size_t __sz = size();
     if (__is_long())
     {
         __p = __get_long_pointer();
         __set_long_size(1);
     }
     else
     {
         __p = __get_short_pointer();
         __set_short_size(1);
     }
+    __annotate_grow(__sz, 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>&

 #if _LIBCPP_STD_VER > 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 #endif
 {
     clear();
     shrink_to_fit();
+    __str.__annotate_delete();
+    __annotate_delete();
     __r_.first() = __str.__r_.first();
     __move_assign_alloc(__str);
     __str.__zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&

 <
     __is_forward_iterator<_ForwardIterator>::value,
     basic_string<_CharT, _Traits, _Allocator>&
 >::type
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     size_type __cap = capacity();
+    size_type __sz = size();
     if (__cap < __n)
     {
-        size_type __sz = size();
         __grow_by(__cap, __n - __cap, __sz, 0, __sz);
+        __annotate_new(__sz);
     }
     else
         __invalidate_iterators_past(__n);
     pointer __p = __get_pointer();
+    __annotate_grow(__sz, __n);
     for (; __first != __last; ++__first, ++__p)
         traits_type::assign(*__p, *__first);
     traits_type::assign(*__p, value_type());
     __set_size(__n);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>

 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
     size_type __cap = capacity();
     size_type __sz = size();
     if (__cap - __sz >= __n)
     {
         if (__n)
         {
+            __annotate_grow(__sz, __sz + __n);
             value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
             traits_type::copy(__p + __sz, __s, __n);
             __sz += __n;
             __set_size(__sz);
             traits_type::assign(__p[__sz], value_type());
         }
     }
     else
         __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
 {
     if (__n)
     {
         size_type __cap = capacity();
         size_type __sz = size();
-        if (__cap - __sz < __n)
+        if (__cap - __sz < __n) {
             __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
+            __annotate_new(__sz);
+        }
         pointer __p = __get_pointer();
+        __annotate_grow(__sz, __sz + __n);
         traits_type::assign(_VSTD::__to_raw_pointer(__p) + __sz, __n, __c);
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
     return *this;
 }
 
basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
     else
     {
         __cap = __get_long_cap() - 1;
         __sz = __get_long_size();
     }
     if (__sz == __cap)
     {
         __grow_by(__cap, 1, __sz, __sz, 0);
+        __annotate_new(__sz);
         __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);
     }
+
+    __annotate_grow(__sz, __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
 <

 >::type
 basic_string<_CharT, _Traits, _Allocator>::append(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __sz = size();
     size_type __cap = capacity();
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n)
     {
-        if (__cap - __sz < __n)
+        if (__cap - __sz < __n) {
             __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
+            __annotate_new(__sz);
+        }
         pointer __p = __get_pointer() + __sz;
+        __annotate_grow(__sz, __sz + __n);
         for (; __first != __last; ++__p, ++__first)
             traits_type::assign(*__p, *__first);
         traits_type::assign(*__p, value_type());
         __set_size(__sz + __n);
     }
     return *this;
 }
 
if (__pos > __sz)
         this->__throw_out_of_range();
     size_type __cap = capacity();
     if (__cap - __sz >= __n)
     {
         if (__n)
         {
             value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
             size_type __n_move = __sz - __pos;
+            __annotate_grow(__sz, __sz + __n);
             if (__n_move != 0)
             {
                 if (__p + __pos <= __s && __s < __p + __sz)
                     __s += __n;
                 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
             }
             traits_type::move(__p + __pos, __s, __n);
             __sz += __n;
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
     if (__pos > __sz)
         this->__throw_out_of_range();
     if (__n)
     {
         size_type __cap = capacity();
         value_type* __p;
         if (__cap - __sz >= __n)
         {
+            __annotate_grow(__sz, __sz + __n);
             __p = _VSTD::__to_raw_pointer(__get_pointer());
             size_type __n_move = __sz - __pos;
             if (__n_move != 0)
                 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
         }
         else
         {
             __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
+            __annotate_new(__sz + __n);
             __p = _VSTD::__to_raw_pointer(__get_long_pointer());
         }
         traits_type::assign(__p + __pos, __n, __c);
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
     return *this;

 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
         "string::insert(iterator, range) called with an iterator not"
         " referring to this string");
 #endif
     size_type __old_sz = size();
     difference_type __ip = __pos - begin();
-    for (; __first != __last; ++__first)
-        push_back(*__first);
+    append(__first, __last);
     pointer __p = __get_pointer();
     _VSTD::rotate(__p + __ip, __p + __old_sz, __p + size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(this, __p + __ip);
 #else
     return iterator(__p + __ip);
 #endif
 }
#endif
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n)
     {
         value_type* __p;
         if (__cap - __sz >= __n)
         {
             __p = _VSTD::__to_raw_pointer(__get_pointer());
             size_type __n_move = __sz - __ip;
+            __annotate_grow(__sz, __sz + __n);
             if (__n_move != 0)
                 traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
         }
         else
         {
             __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
+            __annotate_new(__sz + __n);
             __p = _VSTD::__to_raw_pointer(__get_long_pointer());
         }
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
         for (__p += __ip; __first != __last; ++__p, ++__first)
             traits_type::assign(*__p, *__first);
     }
     return begin() + __ip;
 }
 

 {
     size_type __ip = static_cast<size_type>(__pos - begin());
     size_type __sz = size();
     size_type __cap = capacity();
     value_type* __p;
     if (__cap == __sz)
     {
         __grow_by(__cap, 1, __sz, __ip, 0, 1);
+        __annotate_new(__sz + 1);
         __p = _VSTD::__to_raw_pointer(__get_long_pointer());
     }
     else
     {
+      __annotate_grow(__sz, __sz + 1);
         __p = _VSTD::__to_raw_pointer(__get_pointer());
         size_type __n_move = __sz - __ip;
         if (__n_move != 0)
             traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
     }
     traits_type::assign(__p[__ip], __c);
     traits_type::assign(__p[++__sz], value_type());
     __set_size(__sz);

 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
 {
     _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
     __n1 = _VSTD::min(__n1, __sz - __pos);
+    size_type __new_sz = __sz + __n2 - __n1;
     size_type __cap = capacity();
     if (__cap - __sz + __n1 >= __n2)
     {
+        if (__new_sz > __sz)
+          __annotate_grow(__sz, __new_sz);
         value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
         if (__n1 != __n2)
         {
             size_type __n_move = __sz - __pos - __n1;
             if (__n_move != 0)
             {
                 if (__n1 > __n2)
                 {
if (__cap - __sz + __n1 >= __n2)
                         __n1 = 0;
                     }
                 }
                 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
             }
         }
         traits_type::move(__p + __pos, __s, __n2);
 __finish:
+        if (__new_sz < __sz)
+          __annotate_grow(__sz, __new_sz);
         __sz += __n2 - __n1;
         __set_size(__sz);
         __invalidate_iterators_past(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
     else
         __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
 {
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
     __n1 = _VSTD::min(__n1, __sz - __pos);
+    size_t __new_sz = __sz + __n2 - __n1;
     size_type __cap = capacity();
     value_type* __p;
-    if (__cap - __sz + __n1 >= __n2)
+    if (__cap  >= __new_sz)
     {
+        if (__new_sz > __sz) {
+          __annotate_grow(__sz, __new_sz);
+        }
         __p = _VSTD::__to_raw_pointer(__get_pointer());
         if (__n1 != __n2)
         {
             size_type __n_move = __sz - __pos - __n1;
             if (__n_move != 0)
                 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
         }
     }
     else
     {
         __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
+        __annotate_new(__new_sz);
         __p = _VSTD::__to_raw_pointer(__get_long_pointer());
     }
+    if (__new_sz < __sz) {
+      __annotate_grow(__sz, __new_sz);
+    }
     traits_type::assign(__p + __pos, __n2, __c);
-    __sz += __n2 - __n1;
+    __sz = __new_sz;
     __set_size(__sz);
     __invalidate_iterators_past(__sz);
     traits_type::assign(__p[__sz], value_type());
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
if (__pos > __sz)
         this->__throw_out_of_range();
     if (__n)
     {
         value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
         __n = _VSTD::min(__n, __sz - __pos);
         size_type __n_move = __sz - __pos - __n;
         if (__n_move != 0)
             traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
+        __annotate_grow(__sz, __sz - __n);
         __sz -= __n;
         __set_size(__sz);
         __invalidate_iterators_past(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
     return *this;
 }
 
if (__is_long())
         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());
     }
+    __annotate_grow(__sz + 1, __sz);
     __invalidate_iterators_past(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
 {
+    size_t __sz = size();
     __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);
     }
+    __annotate_grow(__sz, 0);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
 {
+    size_type __sz = size();
     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);
     }
+    __annotate_grow(__sz, __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 (__res_arg != __cap)
                 if (__new_data == nullptr)
                     return;
             #endif  // _LIBCPP_NO_EXCEPTIONS
             }
             __now_long = true;
             __was_long = __is_long();
             __p = __get_pointer();
         }
+
         traits_type::copy(_VSTD::__to_raw_pointer(__new_data),
                           _VSTD::__to_raw_pointer(__p), size()+1);
+
         if (__was_long)
             __alloc_traits::deallocate(__alloc(), __p, __cap+1);
+
+        __annotate_delete();
+
         if (__now_long)
         {
             __set_long_cap(__res_arg+1);
             __set_long_size(__sz);
             __set_long_pointer(__new_data);
         }
         else
             __set_short_size(__sz);
+        __annotate_new(__sz);
         __invalidate_all_iterators();
     }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const

 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     if (!__is_long())
         __get_db()->__invalidate_all(this);
     if (!__str.__is_long())
         __get_db()->__invalidate_all(&__str);
     __get_db()->swap(this, &__str);
 #endif
+    __str.__annotate_delete();
+    __annotate_delete();
     _VSTD::swap(__r_.first(), __str.__r_.first());
     __swap_allocator(__alloc(), __str.__alloc());
+    __str.__annotate_new(__str.size());
+    __annotate_new(size());
 }
 
 // find
 
 template <class _Traits>
 struct _LIBCPP_HIDDEN __traits_eq
 {
     typedef typename _Traits::char_type char_type;

 // operator +
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
           const basic_string<_CharT, _Traits, _Allocator>& __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
-    __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
-    __r.append(__rhs.data(), __rhs_sz);
+    __r.reserve(__rhs.size() + __lhs.size());
+    __r.append(__lhs);
+    __r.append(__rhs);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs);
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
-    __r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz);
-    __r.append(__rhs.data(), __rhs_sz);
+    __r.reserve(__rhs.size() + _Traits::length(__lhs));
+    __r.append(__lhs);
+    __r.append(__rhs);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
-    __r.__init(&__lhs, 1, 1 + __rhs_sz);
-    __r.append(__rhs.data(), __rhs_sz);
+    __r.reserve(__rhs.size() + 1);
+    __r.push_back(__lhs);
+    __r.append(__rhs);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs);
-    __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
-    __r.append(__rhs, __rhs_sz);
+    __r.reserve(_Traits::length(__rhs) + __lhs.size());
+    __r.append(__lhs);
+    __r.append(__rhs);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
-    __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1);
+    __r.reserve(__lhs.size() + 1);
+    __r.append(__lhs);
     __r.push_back(__rhs);
     return __r;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY

 basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
 {
     const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n;
     return this->data() <= __p && __p < this->data() + this->size();
 }
 
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
-#if _LIBCPP_STD_VER > 11 
+#if _LIBCPP_STD_VER > 11
 // Literal suffixes for basic_string [basic.string.literals]
 inline namespace literals
 {
   inline namespace string_literals
   {
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<char> operator "" s( const char *__str, size_t __len )
     {

test/std/strings/basic.string/asan.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Test asan string annotations.
+
+#include <cassert>
+#include <vector>
+#include <string>
+#include <string.h>
+
+#include "asan_testing.h"
+
+template <typename S> void test_empty_string() {
+  fprintf(stderr, "--- test_empty_string\n");
+  S s;
+  assert(is_asan_correct_string(s));
+}
+
+template <typename S> void test_fill_constructor() {
+  fprintf(stderr, "--- test_fill_constructor\n");
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    S s(i, static_cast<typename S::value_type>('x'));
+    assert(s.size() == i);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_cstr_constructor() {
+  fprintf(stderr, "--- test_cstr_constructor\n");
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    S tmp(i, static_cast<typename S::value_type>('x'));
+    assert(tmp.size() == i);
+    assert(is_asan_correct_string(tmp));
+
+    S s(tmp.c_str());
+    assert(s.size() == i);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_copy_constructor() {
+  fprintf(stderr, "--- test_copy_constructor\n");
+  for (int i = 0; i < 100; ++i) {
+    S tmp(i, static_cast<typename S::value_type>('x'));
+    assert(tmp.size() == i);
+    assert(is_asan_correct_string(tmp));
+
+    fprintf(stderr, ">>>i=%d\n", i);
+    S s(tmp);
+    assert(s.size() == i);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_reserve() {
+  fprintf(stderr, "--- test_reserve\n");
+  for (int i = 0; i < 100; ++i) {
+    S s;
+    fprintf(stderr, ">>>i=%d\n", i);
+    s.reserve(i);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_push_back() {
+  fprintf(stderr, "--- test_push_back\n");
+  S s;
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>s.size()=%ld\n", s.size());
+    s.push_back(1);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_insert_range() {
+  fprintf(stderr, "--- test_insert_range\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    std::vector<typename S::value_type> v(
+        i, static_cast<typename S::value_type>('x'));
+    S s;
+    s.insert(s.end(), v.begin(), v.end());
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_insert_fill() {
+  fprintf(stderr, "--- test_insert_fill\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    S s;
+    s.insert(0, i, static_cast<typename S::value_type>('x'));
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_insert_cstr() {
+  fprintf(stderr, "--- test_insert_range\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    S tmp(i, static_cast<typename S::value_type>('x'));
+    S s;
+    s.insert(0, tmp.c_str());
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_assign() {
+  fprintf(stderr, "--- test_assign\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    S s;
+    s.assign(i, static_cast<typename S::value_type>('x'));
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_assign_char() {
+  fprintf(stderr, "--- test_assign\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    S s(i, static_cast<typename S::value_type>('x'));
+    s = static_cast<typename S::value_type>('z');
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_append_str() {
+  fprintf(stderr, "--- test_append_str\n");
+
+  for (int i = 0; i < 100; ++i) {
+    S tmp(i, static_cast<typename S::value_type>('x'));
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    S s;
+    s.append(tmp);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_append_fill() {
+  fprintf(stderr, "--- test_append_fill\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    S s;
+    s.append(i, static_cast<typename S::value_type>('x'));
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_resize() {
+  fprintf(stderr, "--- test_resize\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    {
+      S s;
+      s.resize(i);
+      assert(is_asan_correct_string(s));
+    }
+    {
+      S s(100, static_cast<typename S::value_type>('x'));
+      s.resize(i);
+      assert(is_asan_correct_string(s));
+    }
+  }
+}
+
+template <typename S> void test_assign_cstr() {
+  fprintf(stderr, "--- test_assign_cstr\n");
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    S tmp(i, static_cast<typename S::value_type>('x'));
+    assert(tmp.size() == i);
+    assert(is_asan_correct_string(tmp));
+
+    S s;
+    s.assign(tmp.c_str());
+    assert(s.size() == i);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_clear() {
+  fprintf(stderr, "--- test_clear\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    S s(i, static_cast<typename S::value_type>('x'));
+    s.clear();
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_append_range() {
+  fprintf(stderr, "--- test_append_range\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    std::vector<typename S::value_type> v(
+        i, static_cast<typename S::value_type>('x'));
+    S s;
+    s.append(v.begin(), v.end());
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_assign_range() {
+  fprintf(stderr, "--- test_assign_range\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    std::vector<typename S::value_type> v(
+        i, static_cast<typename S::value_type>('x'));
+    S s;
+    s.assign(v.begin(), v.end());
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_replace_cstr() {
+  fprintf(stderr, "--- test_replace\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    {
+      S tmp(i, static_cast<typename S::value_type>('x'));
+      S s;
+      s.replace(0, 0, tmp.c_str());
+      assert(is_asan_correct_string(s));
+    }
+
+    {
+      S tmp;
+      S s(i, static_cast<typename S::value_type>('x'));
+      s.replace(0, s.size() / 2, tmp.c_str());
+      assert(is_asan_correct_string(s));
+    }
+  }
+
+  {
+    S s(10, static_cast<typename S::value_type>('x'));
+    S tmp(10, static_cast<typename S::value_type>('y'));
+    s.replace(0, 0, tmp.c_str(), 2);
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_operator_plus() {
+  fprintf(stderr, "--- test_operator_plus\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+    S tmp(i, static_cast<typename S::value_type>('x'));
+    S s = static_cast<typename S::value_type>('y') + tmp;
+    assert(is_asan_correct_string(s));
+  }
+}
+
+template <typename S> void test_erase() {
+  fprintf(stderr, "--- test_erase\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    {
+      S s(i, static_cast<typename S::value_type>('x'));
+      s.erase(0, s.size());
+      assert(is_asan_correct_string(s));
+    }
+
+    {
+      S s(i, static_cast<typename S::value_type>('x'));
+      s.erase(s.size() / 4, s.size() * 3 / 4);
+      assert(is_asan_correct_string(s));
+    }
+  }
+}
+
+template <typename S> void test_pop_back() {
+  fprintf(stderr, "--- test_erase\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    S s(i, static_cast<typename S::value_type>('x'));
+    while (!s.empty()) {
+      s.pop_back();
+      assert(is_asan_correct_string(s));
+    }
+  }
+}
+
+template <typename S> void test_cstr() {
+  fprintf(stderr, "--- test_erase\n");
+
+  for (int i = 0; i < 100; ++i) {
+    fprintf(stderr, ">>>i=%d\n", i);
+
+    S s(i, static_cast<typename S::value_type>('x'));
+    assert(is_asan_correct_string(s));
+    s.c_str();
+  }
+}
+
+template <typename S> void test_all() {
+  test_empty_string<S>();
+  test_fill_constructor<S>();
+  test_cstr_constructor<S>();
+  test_copy_constructor<S>();
+  test_resize<S>();
+  test_clear<S>();
+  test_reserve<S>();
+  test_push_back<S>();
+  test_insert_range<S>();
+  test_insert_cstr<S>();
+  test_insert_fill<S>();
+  test_assign<S>();
+  test_assign_char<S>();
+  test_assign_cstr<S>();
+  test_assign_range<S>();
+  test_append_str<S>();
+  test_append_fill<S>();
+  test_append_range<S>();
+  test_replace_cstr<S>();
+  test_operator_plus<S>();
+  test_erase<S>();
+  test_cstr<S>();
+}
+
+int main() {
+  test_all<std::string>();
+  test_all<std::wstring>();
+
+  std::string s(
+      "0123456789012345678901234567890123456789012345678901234567890123456789"
+      "0123456789012345678901234567890123456789012345678901234567890123456789"
+      "0123456789012345678901234567890123456789012345678901234567890123456789"
+      "0123456789012345678901234567890123456789012345678901234567890123456789");
+  assert(s.size() == 280);
+  assert(is_asan_correct_string(s));
+  assert(strlen(s.c_str()) == 280);
+}

test/support/asan_testing.h

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ASAN_TESTING_H
 #define ASAN_TESTING_H
 
 #include <__config>
+#include <vector>
+#include <string>
 
 #ifndef _LIBCPP_HAS_NO_ASAN
-extern "C" int __sanitizer_verify_contiguous_container
-     ( const void *beg, const void *mid, const void *end );
-     
+extern "C" int __sanitizer_verify_contiguous_container(const void *beg,
+                                                       const void *mid,
+                                                       const void *end);
+
+extern "C" const void *__sanitizer_contiguous_container_find_bad_address(
+    const void *beg, const void *mid, const void *end);
 template <typename T, typename Alloc>
-bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
-{
-    if ( std::is_same<Alloc, std::allocator<T> >::value && c.data() != NULL)
-        return __sanitizer_verify_contiguous_container (
+bool is_contiguous_container_asan_correct(const std::vector<T, Alloc> &c) {
+  if (std::is_same<Alloc, std::allocator<T>>::value && c.data() != NULL)
+    return __sanitizer_verify_contiguous_container(
                c.data(), c.data() + c.size(), c.data() + c.capacity()) != 0;
-    return true;
 }
 
+template <typename T, typename Traits, typename Alloc>
+bool is_asan_correct_string(const std::basic_string<T, Traits, Alloc> &s) {
+  if (!std::is_same<Alloc, std::allocator<T>>::value || s.data() == NULL) {
+    return true;
+  }
+
+  const T *s_ptr = reinterpret_cast<const T *>(&s);
+  const T *data = reinterpret_cast<const T *>(s.data());
+  bool is_small = (data - s_ptr) < sizeof(void *);
+
+  const T *p1;
+  const T *p2;
+  const T *mid;
+  const void *bad_addr = nullptr;
+
+  if (is_small) {
+    p1 = s_ptr;
+    mid = data + s.size() + 1 /* terminator */;
+    p2 = data + s.capacity() + 1 /* terminator */;
+#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+    p2 = p2 + 1 /* size */ - 8 / sizeof(T);
+    mid = std::min(mid, p2);
+#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+  } else {
+    p1 = data;
+    mid = data + s.size() + 1 /* terminator */;
+    p2 = data + s.capacity() + 1 /* terminator */;
+  }
+
+  bad_addr = __sanitizer_contiguous_container_find_bad_address(p1, mid, p2);
+  if (bad_addr) {
+    std::ptrdiff_t offset = reinterpret_cast<const T *>(bad_addr) -
+                            reinterpret_cast<const T *>(s.data());
+
+    fprintf(stderr,
+            "ERROR: broken string: bad_addr=%p (data+%ld), this=%p, data=%p, "
+            "size=%ld, capacity=%ld [%p %p %p]\n",
+            bad_addr, offset, s_ptr, s.data(), s.size(), s.capacity(), p1, mid,
+            p2);
+    return false;
+  }
+
+  return true;
+}
+
 #else
 template <typename T, typename Alloc>
-bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
-{
-    return true;
+bool is_contiguous_container_asan_correct(const std::vector<T, Alloc> &c) {
 }
-#endif
- 
+template <typename T, typename Traits, typename Alloc>
+bool is_asan_correct_string(const std::basic_string<T, Traits, Alloc> &s) {
+  return true;
+}
+#endif
 
-#endif  // ASAN_TESTING_H
+#endif // ASAN_TESTING_H