[libc++] Set correct size at the end of growing std::string

[AdvenamTacet]

Summary

This commit deprecates std::basic_string::__grow_by, which is part of ABIv1. The function is replaced by std::basic_string:__grow_by_without_replace, which is not part of ABI.

• The original function __grow_by is deprecated because it does not set the string size, therefore it may not update the size when the size is changed, and it may also not set the size at all when the string was short initially. This leads to unpredictable size value. It is not removed or changed to avoid breaking the ABI.
• The commit adds _LIBCPP_HIDE_FROM_ABI guarded by _LIBCPP_ABI_VERSION >= 2 to __grow_by. This allows the function to be used in the dylib in ABIv1 without raising the [abi:v170000] error and removes it from future ABIs. _LIBCPP_HIDE_FROM_ABI_AFTER_V1 cannot be used.
• Additionally, __grow_by has been removed from _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST in libcxx/include/__string/extern_template_lists.h.

This bugfix is necessary to implement string ASan annotations, because it mitigates the problems encountered in D132769.

[ldionne]

Is there a test that can catch this issue?

[philnik]

I don't think we can do this change. This changes the postconditions of a function in the dylib, which is an ABI break.

[AdvenamTacet]

Is there a test that can catch this issue?

@ldionne __grow_by is private and every public function using it increases the size and eventually sets a new value. So I'm not sure how to create a test for it.

I realized that it's incorrect when I tried to use .size() value to annotate container and it failed.

This changes the postconditions of a function in the dylib, which is an ABI break.

@philnik I would argue that it's a bug and should be fixed.

https://github.com/llvm/llvm-project/blob/75196f8e72be3f18c5a831e23f385c4ae3eb62b5/libcxx/include/string#L703-L720

Let's look at layout (ASL as example, but the same reasoning works with the second layout):

struct __long
{
    pointer   __data_;
    size_type __size_;
    size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
    size_type __is_long_ : 1;
};

struct __short
{
    value_type __data_[__min_cap];
    unsigned char __padding_[sizeof(value_type) - 1];
    unsigned char __size_ : 7;
    unsigned char __is_long_ : 1;
};

If string is short, its size is in its last byte, rest of the object is its content.
Then __grow_by is called and string is going to became long. The function sets data pointer and capacity (bytes at the beginning and the end, but middle bytes (size) are unchanged).

__set_long_pointer(__p);
__set_long_cap(__allocation.count);

It means that size is set to "random value" (old content) as previously it was strings content (eg. it could be 0x4974277341537472 - `"It'sAStr" - and it will be its size now).

I see no value in that kind of behavior and I think it may be changed.

---

But let me know if it's desired/cannot be changed, I will modify D132769 so __grow_by unpoisons memory for future elements already, then a call to .size() is not necessary.

[philnik]

In D148693#4286435, @AdvenamTacet wrote:

Is there a test that can catch this issue?

@ldionne __grow_by is private and every public function using it increases the size and eventually sets a new value. So I'm not sure how to create a test for it.

I realized that it's incorrect when I tried to use .size() value to annotate container and it failed.

This changes the postconditions of a function in the dylib, which is an ABI break.

@philnik I would argue that it's a bug and should be fixed.

https://github.com/llvm/llvm-project/blob/75196f8e72be3f18c5a831e23f385c4ae3eb62b5/libcxx/include/string#L703-L720

Let's look at layout (ASL as example, but the same reasoning works with the second layout):

struct __long
{
    pointer   __data_;
    size_type __size_;
    size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
    size_type __is_long_ : 1;
};

struct __short
{
    value_type __data_[__min_cap];
    unsigned char __padding_[sizeof(value_type) - 1];
    unsigned char __size_ : 7;
    unsigned char __is_long_ : 1;
};

If string is short, its size is in its last byte, rest of the object is its content.
Then __grow_by is called and string is going to became long. The function sets data pointer and capacity (bytes at the beginning and the end, but middle bytes (size) are unchanged).

__set_long_pointer(__p);
__set_long_cap(__allocation.count);

It means that size is set to "random value" (old content) as previously it was strings content (eg. it could be 0x4974277341537472 - `"It'sAStr" - and it will be its size now).

I see no value in that kind of behavior and I think it may be changed.

---

But let me know if it's desired/cannot be changed, I will modify D132769 so __grow_by unpoisons memory for future elements already, then a call to .size() is not necessary.

I don't disagree that it's a bug, but if we started to rely on __grow_by setting the size anywhere (or the compiler removes redundant stores), it would result in broken code and unhappy users. Maybe we could make a new function that calls __grow_by which has the correct postconditions? We could then remove __grow_by from ABIv2 and add the new function. That way we have the better interface without and ABI break.

[AdvenamTacet]

Maybe we could make a new function that calls __grow_by which has the correct postconditions?

Sounds good to me. As __grow_by_and_replace exists, maybe a new function may be named __grow_by_without_replace?

---

While I was reading it, I realized that my patch suggestion is also incorrect. It should be __set_long_size(__old_sz - __n_del + __n_add), I will appreciate if someone confirms it.

[AdvenamTacet]

This update:

• adds a new function __grow_by_without_replace,
• replaces calls to __grow_by with the new function,
• adds new names to ABI (is it correct?).

[AdvenamTacet]

Should I change something?

[philnik]

libcxx/include/__string/extern_template_lists.h

31

This is unfortunately also not possible (at least without some policy changes). Fortunately it's also not necessary for this patch.

80–81

Let's remove this when we add __grow_by_without_replace.

libcxx/include/string

1921–1930

We should mark this as _LIBCPP_DEPRECATED_("use __grow_by_without_replace") to avoid calling it accidentally.

1931

This should be something like _LIBCPP_HIDE_FROM_ABI_V1 or similar.

2383

Please clang-format!

2389

The template arguments shouldn't be necessary.

[AdvenamTacet]

libcxx/include/__string/extern_template_lists.h

31

I don't understand.

[philnik]

libcxx/include/__string/extern_template_lists.h

31

Adding a new symbol to the dylib requires having availability annotations to aid in back-porting to older systems. If we add a new symbol in string, essentially all users would be required to target the latest OS when they use std::string in their programs, which isn't really an option.

[AdvenamTacet]

This update fixes issues mentioned in the code review:

• adds _LIBCPP_DEPRECATED_("use __grow_by_without_replace"),
• adds _LIBCPP_HIDE_FROM_ABI_AFTER_V1,
• changes deprecated call to __grow_by in __grow_by_without_replace with a copy-paste code of the function.
• in libcxx/include/__string/extern_template_lists.h removes references to __grow_by and __grow_by_without_replace,
• clang-format, I hope this time I used the correct config!

[AdvenamTacet]

I hope I understood all comments. I'm in the middle of testing right now.

libcxx/include/__string/extern_template_lists.h

31

Ok, I removed all references to __grow_by_without_replace.

80–81

Removed __grow_by from the file.

libcxx/include/string

1921–1930

Cannot call deprecated function, so I had to copy-paste the code.

1931

I used _LIBCPP_HIDE_FROM_ABI_AFTER_V1.

[AdvenamTacet]

rebase

[AdvenamTacet]

To the best of my knowledge, that implementation is correct.

• The same value as in __grow_by_and_replace.
• D132769 is working with that patch.
• I tested it with more than unit tests.

The patch seems to be ready to land.

[AdvenamTacet]

rebase

[ldionne]

libcxx/include/__string/extern_template_lists.h

30–31

We can't remove this function from the explicit instantiation list, since that would be an ABI break.

libcxx/include/string

1932

I would be tempted to make this _LIBCPP_HIDE_FROM_ABI and not include it in the explicit instantiation list. So far, our explicit instantiation lists have only made our lives really hard with std::string (e.g. getting in the way of fixing bugs).

2351–2356

Please document the bug that this function has and why we're keeping it around.

[AdvenamTacet]

As suggested, this update:

• reverts changes in libcxx/include/__string/extern_template_lists.h,
• in a comment, describes the bug and explains why the function is preserved,
• adds _LIBCPP_HIDE_FROM_ABI to __grow_by_without_replace (),
• removes changes in libcxx/lib/abi.

I hope, the patch may land after that change.

[philnik]

libcxx/include/string

1921–1930

You can use _LIBCPP_SUPPRESS_DEPRECATED_PUSH and _LIBCPP_SUPPRESS_DEPRECATED_POP to ignore the diagnostic. IMO that's also what we should do to avoid code bloat.

1932

I don't really see the problem of adding this to the ABIv2 list. It's not like we will freeze ABIv2 any time soon, and we probably want to reassess what we export from the dylib and what we don't before doing that anyways.

2348

It's not like we would care about the old behavior otherwise.

[AdvenamTacet]

This update improves a comment.

[AdvenamTacet]

libcxx/include/string

1921–1930

Thx! I tried it, but __grow_by doesn't work because of _LIBCPP_HIDE_FROM_ABI_AFTER_V1:

undefined reference to `std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::__grow_by[abi:v170000](unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)'
clang++: error: linker command failed with exit code 1 (use -v to see invocation)

Is there one more work-around?

It works when I remove _LIBCPP_HIDE_FROM_ABI_AFTER_V1, but I believe it's worse solution than a few more copy-pasted lines.
Let me know what you think!

1932

If you decide that I should revert the revert, let me know, I don't have an opinion about it. But also I don't see any real advantage of adding this function to ABI.

[AdvenamTacet]

rebase

[ldionne]

LGTM with a suggestion to rephrase a comment.

libcxx/include/string

2346–2348

Just rewording, IMO this is easier to read. WDYT?

[AdvenamTacet]

This update:

• applies comment change suggested by @ldionne (thank you!),
• resolves conflicts.

[AdvenamTacet]

libcxx/include/string

1921–1930

Hey @philnik, does it look ok for you? If yes, please, accept the review. If you want me to work on something, please, let me know how I should improve it.

2346–2348

Looks good, thank you! I applied that change.

[AdvenamTacet]

A fix for rebase.

[AdvenamTacet]

Rebase.

[AdvenamTacet]

Removing std::__debug_db_invalidate_all(this); from __grow_by_without_replace as it was removed form __grow_by.

[philnik]

libcxx/include/string

1921–1930

Where does that happen? The inline version should always be emitted, so there should never be a linker error with [abi:v170000]. IMO code duplication isn't the right thing here, since the code is quite complex and will get out of sync in the future.

[AdvenamTacet]

To test the issue on CI, this update does:

• rebase,
• add _LIBCPP_SUPPRESS_DEPRECATED_PUSH and _LIBCPP_SUPPRESS_DEPRECATED_POP to not duplicate code.

I hope I did it correctly.

[AdvenamTacet]

libcxx/include/string

1921–1930

Hey @philnik, I recreated this error on CI. Let me know if I used _LIBCPP_SUPPRESS_DEPRECATED_POP correctly and if you know how to fix it. I agree that code duplication is far from ideal, but I don't know how to avoid it, keeping everything other requested. Possibly I'm just incorrectly using a macro.

[philnik]

libcxx/include/string

1921–1930

Ah, I understand the problem now. I think we can just do

#if _LIBCPP_ABI_VERSION >= 2 // We want to use the function in the dylib in ABIv1
  _LIBCPP_HIDE_FROM_ABI
#endif

That should solve the problem.

[AdvenamTacet]

Testing a potential fix.

[AdvenamTacet]

This patch reverts previous attempt and is fixing the preoblem.

The solution is like suggested, using _LIBCPP_ABI_VERSION but around _LIBCPP_HIDE_FROM_ABI_AFTER_V1. Locally works.

[philnik]

LGTM with green CI % nit.

libcxx/include/string

1923

This is already guarded; no need to make it more confusing.

[AdvenamTacet]

This update:

• adds a comment explaining why we guard _LIBCPP_HIDE_FROM_ABI,
• changes guarded _LIBCPP_HIDE_FROM_ABI_AFTER_V1 to _LIBCPP_HIDE_FROM_ABI.

I will land the patch, if CI stays green.

[AdvenamTacet]

This update removes __grow_by from _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST in libcxx/include/__string/extern_template_lists.h.

Hey @philnik, I made additional self-review and realized that the commit does not remove the function from _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST, so I fix it in this update. Unfortunatelly, _LIBCPP_HIDE_FROM_ABI_AFTER_V1 still does not work.

[AdvenamTacet]

libcxx/include/string

1921–1930

Thank you for suggestions! It works!

But fact that we cannot use _LIBCPP_HIDE_FROM_ABI_AFTER_V1 made me ask a question, if we are doing everything correctly, which led to realization that I don't remove __grow_by function from ABIv2. I fixed it by removing it from _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST.

Unfortunately, _LIBCPP_HIDE_FROM_ABI_AFTER_V1 still does not work.
Now I believe everything it correct and ready to land. I will land it Tomorrow.

libcxx/include/__string/extern_template_lists.h

 //
 // For unstable, we may explicitly remove function that are external in V1,
 // and add (new) external functions to better control inlining and compiler
 // optimization opportunities.
 //
 // For stable, the ABI list should rarely change, except for adding new
 // functions supporting new c++ version / API changes. Typically entries
 // must never be removed from the stable list.
 #define _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::basic_string(basic_string const&)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::basic_string(basic_string const&, allocator<_CharType> const&)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::~basic_string()) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
#define _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::operator=(basic_string const&)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::resize(size_type, value_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
 
 #define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::~basic_string()) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
#define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, allocator<_CharType> const&)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(size_type, value_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<false>(value_type const*, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<true>(value_type const*, size_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::push_back(value_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
   _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \

libcxx/include/string

iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _Sentinel __last) {
         {
             __p = std::__to_address(__get_pointer());
             size_type __n_move = __sz - __ip;
             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);
+            __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
             __p = std::__to_address(__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);
 
#endif // _LIBCPP_STD_VER >= 20
 
     template <class _InputIterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __init_with_sentinel(_InputIterator __first, _Sentinel __last);
     template <class _InputIterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz);
 
     _LIBCPP_CONSTEXPR_SINCE_CXX20
+#if _LIBCPP_ABI_VERSION >= 2 //  We want to use the function in the dylib in ABIv1
+    _LIBCPP_HIDE_FROM_ABI
+#endif
+    _LIBCPP_DEPRECATED_("use __grow_by_without_replace")
     void __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 = 0);
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __grow_by_without_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 = 0);
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __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);
 
     // __assign_no_alias is invoked for assignment operations where we
     // have proof that the input does not alias the current instance.
     // For example, operator=(basic_string) performs a 'self' check.
     template <bool __is_short>
     _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& __assign_no_alias(const value_type* __s, size_type __n);
if (__old_cap+1 != __min_cap || __libcpp_is_constant_evaluated())
         __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
     __set_long_pointer(__p);
     __set_long_cap(__allocation.count);
     __old_sz = __n_copy + __n_add + __sec_cp_sz;
     __set_long_size(__old_sz);
     traits_type::assign(__p[__old_sz], value_type());
 }
 
+// __grow_by is deprecated because it does not set the size. It may not update the size when the size is changed, and it
+// may also not set the size at all when the string was short initially. This leads to unpredictable size value. It is
+// not removed or changed to avoid breaking the ABI.
 template <class _CharT, class _Traits, class _Allocator>
 void
 _LIBCPP_CONSTEXPR_SINCE_CXX20
+#if _LIBCPP_ABI_VERSION >= 2 // We want to use the function in the dylib in ABIv1
+    _LIBCPP_HIDE_FROM_ABI
+#endif
+    _LIBCPP_DEPRECATED_("use __grow_by_without_replace")
 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)
         __throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
                           __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) :
if (__sec_cp_sz != 0)
                           std::__to_address(__old_p) + __n_copy + __n_del,
                           __sec_cp_sz);
     if (__libcpp_is_constant_evaluated() || __old_cap + 1 != __min_cap)
         __alloc_traits::deallocate(__alloc(), __old_p, __old_cap + 1);
     __set_long_pointer(__p);
     __set_long_cap(__allocation.count);
 }
 
+template <class _CharT, class _Traits, class _Allocator>
+void _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+basic_string<_CharT, _Traits, _Allocator>::__grow_by_without_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) {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    __grow_by(__old_cap, __delta_cap, __old_sz, __n_copy, __n_del, __n_add);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+    __set_long_size(__old_sz - __n_del + __n_add);
+}
+
 // assign
 
 template <class _CharT, class _Traits, class _Allocator>
 template <bool __is_short>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
     const value_type* __s, size_type __n) {

 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
 {
     size_type __cap = capacity();
     if (__cap < __n)
     {
         size_type __sz = size();
-        __grow_by(__cap, __n - __cap, __sz, 0, __sz);
+        __grow_by_without_replace(__cap, __n - __cap, __sz, 0, __sz);
     }
     value_type* __p = std::__to_address(__get_pointer());
     traits_type::assign(__p, __n, __c);
     return __null_terminate_at(__p, __n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string<_CharT, _Traits, _Allocator>::__assign_trivial(_Iterator __first, _Sentinel __last, size_type __n) {
   if (__cap < __n) {
     // Unlike `append` functions, if the input range points into the string itself, there is no case that the input
     // range could get invalidated by reallocation:
     // 1. If the input range is a subset of the string itself, its size cannot exceed the capacity of the string,
     //    thus no reallocation would happen.
     // 2. In the exotic case where the input range is the byte representation of the string itself, the string
     //    object itself stays valid even if reallocation happens.
     size_type __sz = size();
-    __grow_by(__cap, __n - __cap, __sz, 0, __sz);
+    __grow_by_without_replace(__cap, __n - __cap, __sz, 0, __sz);
     }
     pointer __p = __get_pointer();
     for (; __first != __last; ++__p, (void) ++__first)
         traits_type::assign(*__p, *__first);
     traits_type::assign(*__p, value_type());
     __set_size(__n);
 }
 

 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)
-            __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
+            __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
         pointer __p = __get_pointer();
         traits_type::assign(std::__to_address(__p) + __sz, __n, __c);
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
 basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n)
 {
     if (__n)
     {
         size_type __cap = capacity();
         size_type __sz = size();
         if (__cap - __sz < __n)
-            __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
+            __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
         pointer __p = __get_pointer();
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
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);
+        __grow_by_without_replace(__cap, 1, __sz, __sz, 0);
         __is_short = false; // the string is always long after __grow_by
     }
     pointer __p = __get_pointer();
     if (__is_short)
     {
         __p = __get_short_pointer() + __sz;
         __set_short_size(__sz+1);
     }
basic_string<_CharT, _Traits, _Allocator>::append(
     size_type __cap = capacity();
     size_type __n = static_cast<size_type>(std::distance(__first, __last));
     if (__n)
     {
         if (__string_is_trivial_iterator<_ForwardIterator>::value &&
             !__addr_in_range(*__first))
         {
             if (__cap - __sz < __n)
-                __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
+              __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
             pointer __p = __get_pointer() + __sz;
             for (; __first != __last; ++__p, (void) ++__first)
                 traits_type::assign(*__p, *__first);
             traits_type::assign(*__p, value_type());
             __set_size(__sz + __n);
         }
         else
         {
if (__n)
         {
             __p = std::__to_address(__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);
+            __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
             __p = std::__to_address(__get_long_pointer());
         }
         traits_type::assign(__p + __pos, __n, __c);
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
     return *this;

 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
 {
     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);
+        __grow_by_without_replace(__cap, 1, __sz, __ip, 0, 1);
         __p = std::__to_address(__get_long_pointer());
     }
     else
     {
         __p = std::__to_address(__get_pointer());
         size_type __n_move = __sz - __ip;
         if (__n_move != 0)
             traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
if (__cap - __sz + __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);
+        __grow_by_without_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
         __p = std::__to_address(__get_long_pointer());
     }
     traits_type::assign(__p + __pos, __n2, __c);
     return __null_terminate_at(__p, __sz - (__n1 - __n2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> >