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

1820

this division deserves a comment

2391

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

2507–2510

{}-only change?

2743

{}-only change?

3002

extra line?

3012

extra line?

3107

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

[aizatsky]

nits

[aizatsky]

ptal

include/string

3107

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

 // -*- C++ -*-
 //===--------------------------- string -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_STRING
 #define _LIBCPP_STRING
 
+#include <stdlib.h>
+#include <assert.h>
+
 /*
     string synopsis
 
 namespace std
 {
 
 template <class stateT>
 class fpos

 
 template <class _CharT>
 struct __padding<_CharT, 1>
 {
 };
 
 #endif  // _LIBCPP_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::pointer             __pointer;
+  typedef typename __alloc_traits::const_pointer       __const_pointer;
+
+  static void __annotate_contiguous_container
+      (const char* msg, const void *__beg, const void *__end, const void *__old_mid, const void *__new_mid)
+  {
+  }
+
+  static void __annotate_long_delete(__const_pointer __data, size_t __cap, size_t __s)
+  {
+  }
+
+  static void __annotate_short_delete(typename __alloc_traits::size_type const * __beg, size_t __cap, __const_pointer __mid)
+  {
+  }
+
+  static void __annotate_long_new(__const_pointer __beg, size_t __cap, size_t __size)
+  {
+  }
+
+  static void __annotate_short_new(typename __alloc_traits::size_type const *__beg, size_t __cap, __const_pointer __mid)
+  {
+  }
+
+  static void __annotate_long_grow(__const_pointer __data, size_t __cap, size_t __old_size, size_t __new_size)
+  {
+  }
+
+  static void __annotate_short_grow(typename __alloc_traits::size_type const *__beg, size_t __cap, __const_pointer __old_mid, __const_pointer __new_mid)
+  {
+  }
+};
+
+// 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::pointer             __pointer;
+  typedef typename __alloc_traits::const_pointer       __const_pointer;
+
+  static void __annotate_long_delete(__const_pointer __beg, size_t __cap, size_t __s)
+  {
+    __annotate_contiguous_container("__annotate_long_delete", __beg, __beg + __cap, __beg + __s, __beg + __cap);
+  }
+
+  static void __annotate_short_delete(typename __alloc_traits::size_type const * __beg, size_t __cap, __const_pointer __mid)
+  {
+    __annotate_contiguous_container("__annotate_short_delete", __beg, __beg + __cap, __mid, __beg + __cap);
+  }
+
+  static void __annotate_contiguous_container
+      (const char* msg, const void *__beg, const void *__end, const void *__old_mid, const void *__new_mid)
+  {
+#ifndef _LIBCPP_HAS_NO_ASAN
+      if (__beg) {
+        fprintf(stderr, "annotate %s [%p %p %s %p %p] \n", msg, __beg,
+                min(__old_mid, __new_mid), __old_mid < __new_mid ? "->" : "<-", max(__old_mid, __new_mid), __end);
+        __sanitizer_annotate_contiguous_container(__beg, __end, __old_mid, __new_mid);
+      }
+#endif
+  }
+
+  static void __annotate_long_new(__const_pointer __beg, size_t __cap, size_t __size)
+  {
+     __annotate_contiguous_container("__annotate_long_new", __beg, __beg + __cap, __beg + __cap, __beg + __size);
+  }
+
+  static void __annotate_short_new(typename __alloc_traits::size_type const * __beg, size_t __cap, __const_pointer __mid)
+  {
+     __annotate_contiguous_container("__annotate_short_new", __beg, __beg + __cap, __beg + __cap, __mid);
+  }
+
+  static void __annotate_long_grow(__const_pointer __beg, size_t __cap, size_t __old_size, size_t __new_size)
+  {
+    __annotate_contiguous_container("__annotate_long_new", __beg, __beg + __cap, __beg + __old_size, __beg + __new_size);
+ }
+
+  static void __annotate_short_grow(typename __alloc_traits::size_type const *__beg, size_t __cap, __const_pointer __old_mid, __const_pointer __new_mid)
+  {
+    __annotate_contiguous_container("__annotate_short_grow", __beg, __beg + __cap, __old_mid, __new_mid);
+  }
+};
+
 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<_CharT>                            __default_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();}
 
+    void __annotate_contiguous_container
+        (const char* msg, const void *__beg, const void *__end, const void *__old_mid, const void *__new_mid) const
+    {
+      return __asan_traits::__annotate_contiguous_container(msg, __beg, __end, __old_mid, __new_mid);
+    }
+
+    void __annotate_new(size_type __sz) const
+    {
+      if (__is_long()) {
+        __asan_traits::__annotate_long_new(__get_long_pointer(), __get_long_cap(), __sz + 1 /* terminator */);
+      } else {
+        __annotate_short_new(__sz);
+      }
+    }
+
+    void __annotate_short_new(size_type __sz) const {
+      __asan_traits::__annotate_short_new(
+          __r_.first().__r.__words, __n_words, __get_short_pointer() + __sz + 1 /* terminator */);
+    }
+
+    void __annotate_grow(size_type __old_size, size_type __new_size) const {
+      if (__is_long()) {
+        __asan_traits::__annotate_long_grow(__get_long_pointer(), __get_long_cap(), __old_size + 1, __new_size + 1);
+      } else {
+        __annotate_short_grow(__old_size, __new_size);
+      }
+    }
+    void __annotate_short_grow(size_type __old_size, size_type __new_size) const {
+      __asan_traits::__annotate_short_grow(__r_.first().__r.__words, __n_words,
+                                           __get_short_pointer() + __old_size + 1,
+                                           __get_short_pointer() + __new_size + 1);
+    }
+
+    basic_string<_CharT, _Traits, _Allocator> const * __annotate_delete() const
+    {
+      if (__is_long()) {
+        __asan_traits::__annotate_long_delete(__get_long_pointer(), __get_long_cap(), __get_long_size());
+      } else {
+        __asan_traits::__annotate_short_delete(
+            __r_.first().__r.__words, __n_words, __get_short_pointer() + __get_short_size());
+      }
+
+      return this;
+    }
+
 #ifdef _LIBCPP_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);}
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;
+            __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

 {
     if (__reserve > max_size())
         this->__throw_length_error();
     pointer __p;
     if (__reserve < __min_cap)
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
+        _LIBCPP_ASSERT(false, "HERE");
     }
     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();
+        _LIBCPP_ASSERT(false, "HERE");
     }
     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_short_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_short_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_short_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)
-        traits_type::assign(*__p, *__first);
+
+    __annotate_new(__sz);
+    for (; __first != __last; ++__first, (void) ++__p) {
+    }
     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)
 {

 #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,
      size_type __n_copy,  size_type __n_del,     size_type __n_add, const value_type* __p_new_stuff)
 {
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);
+    if (__n_copy != 0) {
+    }
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
-    if (__sec_cp_sz != 0)
+    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);
+    }
+    if (__old_cap+1 != __min_cap) {
+    }
+    __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>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 {
-    if (this != &__str)
     {
         __copy_assign_alloc(__str);
         assign(__str);
     }
     return *this;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

 #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();
+    __annotate_new(size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
     _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
 {

 <
     __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
+    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;
#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_short_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)
+            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>
basic_string<_CharT, _Traits, _Allocator>::pop_back()
     __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

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 <string>
+#include <vector>
+#include <cassert>
+
+#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_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>();
+}
+
+int main() {
+  test_all<std::string>();
+  test_all<std::wstring>();
+}

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

 
 // size_type capacity() const;
 
 #include <string>
 #include <cassert>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 void
 test(S s)
 {
     S::allocator_type::throw_after = 0;
     try
     {

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 */;
+  } 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>
+void assert_asan_correct_string(const std::basic_string<T, Traits, Alloc> &s) {}
+#endif
 
-#endif  // ASAN_TESTING_H
+#endif // ASAN_TESTING_H