[2b/3][ASan][libcxx] std::basic_string annotations

[AdvenamTacet]

Summary

This revision is a part of a series of patches extending AddressSanitizer C++ container overflow detection capabilities by adding annotations, similar to those existing in std::vector, to std::string and std::deque collections. These changes allow ASan to detect cases when the instrumented program accesses memory which is internally allocated by the collection but is still not in-use (accesses before or after the stored elements for std::deque, or between the size and capacity bounds for std::string).

The motivation for the research and those changes was a bug, found by Trail of Bits, in a real code where an out-of-bounds read could happen as two strings were compared via a std::equals function that took iter1_begin, iter1_end, iter2_begin iterators (with a custom comparison function). When object iter1 was longer than iter2, read out-of-bounds on iter2 could happen. Container sanitization would detect it.

This revision adds annotations for std::basic_string. Long string is very similar to std::vector, and therefore works well with __sanitizer_annotate_contiguous_container from LLVM 15 and therefore annotations works if that implementation is compiled with previous LLVM.
However, only the standard allocator is supported.

As D132522 extended possibilities of __sanitizer_annotate_contiguous_container, now annotations may be supported with all allocators, but that support will be added in next patch. Only strings with default allocator are annotated with that patch.

There is also support for annotating objects using short string optimization.
This is limited functionality. If ASan is extended and (for example) objects on stack should not be annotated (note that not every short string is on stack), __annotate_short_string_check should be modified to return false in those situations.

If you have any questions, please email:

• [e-mail]
• [e-mail]

[AdvenamTacet]

This update should fix problems with short string annotations.

• It adds _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS in relevant places.
• It adds a check for an allocator* in __annotate_short_string_check.
• It turns off string external templates, when compiled with ASan.

*Objects annotation cannot be supported with non-standard allocators, because some access memory inside the object.

libcxx/include/string

1838–1849

The solution seems to not work. Maybe it's inlined in an instrumented function and then it is instrumented as well (I didn't check the reason. I'm happy to test another solution, if you have an idea, how to make it work).

[AdvenamTacet]

This update applies the patch to a newer commit.

[AdvenamTacet]

fix: removed unnecesary test, which was added by mistake.

[AdvenamTacet]

This update:

• adds include for "wchar" support in tests,
• removes a few automatic style changes outside of a new code
• tries to fix issues with Windows/Mac

[AdvenamTacet]

I'm using previous diff for fuzzing to confirm that it's working at the moment, therefore I believe the implementation is correct.
But there is issue with Windows and Apple tests, described below. I believe, the main issue is: constexpr evaluation hit maximum step limit; possible infinite loop? in a tests, which I didn't modify.

Failed Tests (1):
  apple-libc++-backdeployment.cfg.in :: std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

This update:

• tries to solves an issue with wchars in a correct way (#ifndef TEST_HAS_NO_WIDE_CHARACTERS). Hopefully, this time everything will work.

Main problem:
I do not know how to fix the problem with Windows and Apple tests failing. I do not modify the failing test.
Below I post details, I will apprecieate every suggestion.

C:\ws\w32-1\llvm-project\libcxx-ci\libcxx\test\std\strings\basic.string\string.modifiers\string_insert\size_pointer_size.pass.cpp:403:17: error: static_assert expression is not an integral constant expression
  static_assert(test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>());
                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:/ws/w32-1/llvm-project/libcxx-ci/build/clang-cl-static/include/c++/v1\string:1714:15: note: constexpr evaluation hit maximum step limit; possible infinite loop?
              std::construct_at(std::addressof(__begin[__i]));
              ^
C:/ws/w32-1/llvm-project/libcxx-ci/build/clang-cl-static/include/c++/v1\string:2542:5: note: in call to '__begin_lifetime({&{*new char[192]#1220}[0]}, 192)'
    __begin_lifetime(__p, __allocation.count);
    ^
C:/ws/w32-1/llvm-project/libcxx-ci/build/clang-cl-static/include/c++/v1\string:3067:7: note: in call to '&s_short->__grow_by_and_replace(95, 0, 16, 0, 0, 16, &{*new char[96]#1219}[0])'
      __grow_by_and_replace(__cap, 0, __sz, __pos, 0, __n, __s);
      ^
C:\ws\w32-1\llvm-project\libcxx-ci\libcxx\test\std\strings\basic.string\string.modifiers\string_insert\size_pointer_size.pass.cpp:384:13: note: in call to '&s_short->insert(0, &{*new char[96]#1219}[0], 16)'
    s_short.insert(0, s_short.data(), s_short.size());
            ^
C:\ws\w32-1\llvm-project\libcxx-ci\libcxx\test\std\strings\basic.string\string.modifiers\string_insert\size_pointer_size.pass.cpp:403:17: note: in call to 'test()'
  static_assert(test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>());

Therefore there is no attempt to fix it. I will apprecieate every suggestion.

[AdvenamTacet]

This update:

• Applies the patch to newest commit from master branch.
• Fixes an issue with one test.
• Removes remaining auto-changes to style outside of a new code.

[philnik]

On a general note: I don't have a problem with formatting the code around the changes, but let's do that in an NFC patch if you want to do that. The actual changes are quite hard to find sometimes.

libcxx/include/string

1838–1886

__zero doesn't exist anymore in trunk.

1903–1904

These functions seem to be unchanged. If that's the case, please remove the formatting changes. This patch is already quite large, no need to make it larger.

1939

It's not clear to me what is actually checks for. Is it to check whether to poison the short string? I don't really have a better name right now, maybe someone has a good idea.

1941

Shouldn't it be legal to just poison the first sizeof(__rep) bytes? If the allocator is empty, it isn't allowed to access the memory anyways, and otherwise it will be layed out after the internal string representation.

1958–1961

I don't think we should design the interface for this. It should just be __annotate_delete(); do-whatever-operation; __annotate_new(size). That makes the interface simpler and avoids any problems with the invariants not holding. I don't think any function is designed for this (other than the setters of course). Any performance-gains are probably non-existant to not-worth-the-effort. Taking a quick look through the code I also couldn't find a case where the invariants don't hold.

[AdvenamTacet]

libcxx/include/string

1939

Yes, short string is poisoned if and only if this function returns true.

1941

Good point, it actually should work. I will test it and think about some edge cases.

1958–1961

That decision was made because it was necessary, but a lot changed since that code was written. I will test if it's still necessary.

[AdvenamTacet]

This update is based on the feedback from code review:

• removes __zero,
• removes unnecessary functions,
• partially removes too agressive auto refactor.

There are still requests in the code reveiw not fixed by that update.
I will try to finish it Tomorrow, as soon as possible.

The actual changes are quite hard to find sometimes.

Sorry, I used auto-refactor, which was too agressive, but I realized it much later.
I'm cleaning it!

[AdvenamTacet]

libcxx/include/string

943

I will fix order.

[AdvenamTacet]

libcxx/include/string

1941

With minor changes, it works. I added it.

1958–1961

It is no longer necessary, I removed it.

[AdvenamTacet]

This update:

• adds support for annotating short strings with every allocator,
• removes special-casing (template) from __annotate_* interface, makes it simpler,
• cleans too aggressive style changes.

I believe, this patch and the prvious one, answers all points from the code review. If there is anything I should change, please, let me know.

[AdvenamTacet]

This update applies changes to the newest commit from master and fixes a few syntax issues.

I do not see anything else to change or improve, if you think I should, let me know.
The only thing I still want to do is to test those changes by fuzzing with the newest diff.

[philnik]

libcxx/include/string

875–879

The __annotate_delete() shouldn't be necessary here, right? The function is already marked _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS, so it should be enough to call __annotate_delete() right before __default_init() if it's needed at all.

881

This seems to be redundant. __default_init() already calls __annotate_new(0).

1781–1782

What exactly is the problem here? The memory should never actually be accessed, right? __r_.second() should just return a reference to either

1. memory outside the poisoned area, or
2. a reference inside the poisoned area that will never actually be used in a meaningful way (because of EBO).

1843

1864–1876

This should be equivalent, or did I miss anything? Also, I think the + 1 for the old version is too much. __get_long_cap() returns the capacity including the null terminator. The __current_size argument should also be unnecessary if we assume the string meets the invariants. Assuming I didn't miss anything, this (in part) also applies to the other helpers.

2037

Nit: I think __old_size would be nicer. I know that's not how it's done elsewhere, but at least I'm not Hessian.

2620

What invariant doesn't hold after calling __grow_by?

2661–2663

I think this comments makes more sense above the function, since it's about it in general.

3308

Same question here: Which invariants are not met after calling __grow_by? (And maybe add a comment to __grow_by to mention that it fails to keep the invariants)

4436

These annotations shouldn't be necessary. string(__uninitialized_size_tag(), ...) already sets the correct annotations.

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

1 ↗

(On Diff #499775)

These tests are very libc++-specific, so we should just put them in test/libcxx/string/basic.string and then have one test per overload. I know this is quite a bit of refactoring work, but it makes verifying the tests and figuring out what is broken a lot easier when it's necessary. You can just mirror the naming inside test/std and add a .asan in-between, i.e. std/.../string_append/initalizer_list.pass.cpp would become libcxx/.../string_append/initializer_list.asan.pass.cpp.

I didn't take a super close look at the tests yet, but other than splitting them up they look quite good.

18 ↗

(On Diff #499775)

We normally use class here.

26–64 ↗

(On Diff #499775)

Maybe just use std::char_traits<T>::length(str)? This is currently technically UB, since you are adding overloads for a function from the standard without a user-defined type. Also, function template specializations are quite brittle. Just use overloads instead. You never call the char version, since the C version is a better match. (https://godbolt.org/z/W8qdeGqPd)

68 ↗

(On Diff #499775)

Let's use using here instead. (Also works in C++03)

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

74–99 ↗

(On Diff #499775)

It should be possible to simplify these instantiations to meta::for_each(meta::character_types(), TestClass()); (probably modulo most vexing parse).

[philnik]

libcxx/include/__string/extern_template_lists.h

30

Why is this required?

[AdvenamTacet]

libcxx/include/__string/extern_template_lists.h

30

We don't really want to use external templates here. Those we cannot control.

Without that casing, non-instrumented functions may be used. This leads to false positives. With that change, during compilation, a version with instrumentation is created. I never had a problem of missing instrumentation after that change.

Now when I look at it, && (_LIBCPP_CLANG_VER >= 1600) should be removed, same problem may happen with older LLVM.

libcxx/include/string

875–879

Unfortunately not. Sometimes instrumentation is turned on here. I tried that kind of solution first.

During las year I saw a lot of inconsistent behavior of ASan with variable initialization in constructors (... : var_name(value)) and turning off instrumentations (_LIBCPP_STRING_INTERNAL_MEMORY_ACCESS).

In that case, it's necessary with test_allocator (and probably some other of non-zero size, but I didn't confirm). Sometimes that kind of initialization is instrumented, even when function is not.

If we move it to the first line of the functions body (__r_ = std::move(__str.__r_);), then you are right.
And then, __annotate_delete() does not have to be called every time.

But with unpoisoning every time, _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS seems to be not necessary.

1864–1876

It's not same, but with new __sanitizer_annotate_contiguous_container should work.
data() returns address of content, but with old implementation address of buffer to annotate had to be aligned, therefore a byte with metadata before content had to be treated as char-in-use all the time.
Now it should work.

At the same time, thanks to _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS byte after content (Alternate String Layout) may be poisoned all the time (when string is short).
It has a nice feature of always having a poisoned separator between buffer and a next object, even when red zone is not possible (eg. arrays).

That's a nice suggestion. Thx!

2661–2663

Actually, it probably makes more sense to have it next to #define _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS ..., as a few functions should have that comment. I will move it.

[AdvenamTacet]

This update implements part of requested improvements and fixes:

• adds __annotate_new(0) to __default_init(),
• fixes use of __annotate_delete() in variable initialization,
• fixes asan_testing.h,
• fixes comments.

libcxx/include/string

875–879

But __annotate_delete() should be only called if __str is short.

881

It didn't, but it actually can. I implemented it, makes code cleaner.

1781–1782

Right, fixed.

[AdvenamTacet]

This update:

• simplifies helpers,
• class instead of typename,
• fixes UB (strlen),
• __old_size instead of __old_sz.

[AdvenamTacet]

This update:

• removes one unnecessary call to __annotate_delete(),
• typedef -> using,
• moves 3 tests.

[AdvenamTacet]

This update applies changes to the newest commit from master branch.

[AdvenamTacet]

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

1 ↗

(On Diff #499775)

I mostly removed my tests and merged them with already existing tests. In just few cases I saw a value in leaving .asan. file.

[AdvenamTacet]

This update refactors test.
I kept only few of my tests and mostly added ASan checks into existing tests.
I also extended one or two tests.

I elieve, the revision is ready for upstream.

[AdvenamTacet]

libcxx/include/string

3308

It's not about strings invariants, but ASan annotations. After __growby, those are different than size (as __growby does not set size, but extends annotations), setting size just after __grow_by is enough to make it work and it's probably a nicer decision.

[AdvenamTacet]

Double includes removed.

I think, all requests from code review are fixed.

[philnik]

libcxx/include/__string/extern_template_lists.h

30

IMO the right thing here would be to have an instrumented library, since the same problem exists for any other externally defined function, but I guess I'm OK with this for now. @ldionne are you OK with this?

31–33

This comment is wrong.

libcxx/include/string

875–879

I'm not a huge fan of this construct, but unfortunately I don't have a good suggestion right now. Let's at least add a comment explaining why it's done this way.

1864

Isn't this redundant? __annotate_short_string_check() already checks this.

3247–3248

The indentation is wrong.

3308

I think the annotations in __grow_by are wrong. Since __grow_by doesn't change the size of the string, it should annotate the memory to be __old_sz large, not that all the memory is available. That should fix the inconsistency here. Then you can just call __null_terminate_at before traits_type::assign and everything should be working properly. This would then also catch problems in a user-defined traits_type::assign.

[philnik]

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp

42

All these checks are libc++-specific, so we should mark them that way.

libcxx/test/support/asan_testing.h

35

50

53

[AdvenamTacet]

This update:

• adds requested comments,
• sets asserts to libc++ specific (LIBCPP_ASSERT),
• applies small code fixes:
  • _LIBCPP_CLANG_VER -> TEST_CLANG_VER,
  • std::__libcpp_is_constant_evaluated() -> TEST_IS_CONSTANT_EVALUATED,
  • __is_string_short -> is_string_short,
  • removes incorrect comments,
  • fixes indentation.

[AdvenamTacet]

libcxx/include/string

1864

But for long strings it also has to be checked, as every string is long during constant evaluation.

bool __is_long() const _NOEXCEPT {
    if (__libcpp_is_constant_evaluated())
        return true;

It has to be checked here and we cannot wait until the check in __annotate_contiguous_container, because during constant evaluation, next line would rise cannot perform pointer arithmetic on null pointer.

I don't want to remove it from __annotate_short_string_check(), because then returned values won't be correct.
And I don't want to remove it from __annotate_contiguous_container to make sure it can be simply called.
It also has no impact on performance.

Possibly it may be changed to __annotate_short_string_check() || (!__libcpp_is_constant_evaluated() && __is_long()), but I have a strong preference for current version, as that would suggest possibility of poisoning short string during constant evaluation.

[AdvenamTacet]

This update fixes problem with __grow_by:

• it adds __set_long_size(__old_sz); to __grow_by and thanks to that, size value is always correct,
• it changes how __grow_by annotates memory,
• it adds new annotations, required after above change.

[AdvenamTacet]

libcxx/include/string

3308

Ugh... my original comment was correct, please ignore my previous response. Sorry for confusion.

Since __grow_by doesn't change the size of the string, it should annotate the memory to be __old_sz large, not that all the memory is available.

I agree, it makes more sense. I changed it. Now it works like that.

Btw. previous implementation didn't just unpoison whole memory. as __grow_by knows how many elements will be added, it unpoisoned exact number of bytes, so the buffer were ready.

---

The problem is with size value. In original implementation, __grow_by does not call __set_long_size, therefore if it's called in a short string, size value is no longer correct.

• I added a call to __set_long_size inside __grow_by.
• Fixed how it annotates buffers (1).
• I made minimal changes to functions using __grow_by (now diff with master is much smaller).

The real problem was later in __annotate_increace(n) called by __null_terminate_at, which requires a correct size value.

---

I see that my last patch failed, but it should be easy to fix, I had to make a mistake with updating some value.
Somewhere inside ::assign(size_type __n, value_type __c).

$ "/usr/bin/python3.10" "/home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/libcxx/test/../utils/run.py" "--execdir" "/home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/test/std/strings/basic.string/string.modifiers/string_assign/Output/size_char.pass.cpp.dir" "--" "/home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/test/std/strings/basic.string/string.modifiers/string_assign/Output/size_char.pass.cpp.dir/t.tmp.exe"
# command stderr:
AddressSanitizer: CHECK failed: asan_poisoning.cpp:454 "((*(u8 *)MemToShadow(a))) == ((0))" (0x2, 0x0) (tid=354701)
    #0 0x5651a5546f51 in __asan::CheckUnwind() asan_rtl.cpp.o
    #1 0x5651a555ea32 in __sanitizer::CheckFailed(char const*, int, char const*, unsigned long long, unsigned long long) (/home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/test/std/strings/basic.string/string.modifiers/string_assign/Output/size_char.pass.cpp.dir/t.tmp.exe+0xdaa32) (BuildId: 05ded1d03f29cb11827d1b47b24d2ce97422315a)
    #2 0x5651a55402ca in __sanitizer_annotate_contiguous_container (/home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/test/std/strings/basic.string/string.modifiers/string_assign/Output/size_char.pass.cpp.dir/t.tmp.exe+0xbc2ca) (BuildId: 05ded1d03f29cb11827d1b47b24d2ce97422315a)
    #3 0x5651a557cfbb in std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>::__annotate_contiguous_container[abi:v170000](void const*, void const*, void const*, void const*) const /home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/include/c++/v1/string:1841:11
    #4 0x5651a557f60a in std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>::__annotate_shrink[abi:v170000](unsigned long) const /home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/include/c++/v1/string:1874:9
    #5 0x5651a557c32d in std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>::__null_terminate_at[abi:v170000](char*, unsigned long) /home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/include/c++/v1/string:2050:9
    #6 0x5651a557b48f in std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>::assign(unsigned long, char) /home/libcxx-builder/.buildkite-agent/builds/356fcbab9cbd-1/llvm-project/libcxx-ci/build/generic-asan/include/c++/v1/string:2608:12

[AdvenamTacet]

This update fixes issues mention above, the problem was missing if.
(__annotate_increase should be called only when size was increased).

I also refactored helpers, as every time __beg and __end are same, there
is no point to pass them every time.
Now those variables are set in __annotate_contiguous_container.

In next update I will remove support for different allocators and move them to
a new patch, similar to D136765. Here I want to confirm that everything works on CI.

[AdvenamTacet]

This update applies the patch to newest commit from master branch.

[AdvenamTacet]

Using std::addressof instead of &.
Patch applied to a newer commit from master.

[AdvenamTacet]

This update removes support for all allocators, now annotations work with only default allocator.
It updates the test, maing sure that with other allocators memory is not poisoned.

It also adds a way to turn off annotations with _LIBCPP_ASAN_ANNOTATE_ONLY_LONG, in case someone has a specific case where short strings shouldn't be annotated.

Support for annotating all allocators will be added in a separate patch.

I believe, this patch is ready for upstreaming.

[ldionne]

Could you give a really simple example of issues this allows catching? Like the "Hello world" for this new functionality. I think that would be useful for folks (at least for me) to understand concretely what we're gaining (I have no doubt we're gaining something, I just don't see it clearly in my mind).

I see a lot of added complexity in this patch. It's only a couple of ifs here and there, but it's in some of the trickiest code and most used code in the library. And that code is already very much in need of refactoring. Honestly, that makes me worried and from the maintainability and ease-to-validate-correctness perspective, this is only making things worse. It may still be worth doing if we're gaining something massive in return, but there's a clear tradeoff here. Also, this area is:

1. Super tricky cause it touches critical and already crufty code that few people understand well
2. In active development: constexpr-ification recently, hardening work, the debug mode that we gotta probably rip out, and now this

All in all, I guess I wish there had been a design document/RFC explaining this stack of changes before starting to try to get code changes into the library. If there's one, please point it out to me and apologies for my ignorance.

libcxx/include/__string/extern_template_lists.h

30

Using ASAN is an ABI affecting change, kind of like our debug mode. Doing this will only seem to make things work, but in reality it'll cause other problems. For example, if you take a string created inside the dylib (without ASAN) and you try to use it from your ASAN-compiled user program, I assume you'll run into issues, right?

The solution is (quite unfortunately) to have a different built library for that configuration, unless I missed something.

libcxx/include/string

1855

_LIBCPP_ASAN_ANNOTATE_ONLY_LONG adds yet another configuration option. We try not to add configuration options unless we absolutely need to, so I would remove it. If users need to specify whether to annotate short strings or not, IMO the feature is mis-designed. Users shouldn't even be aware of the fact that we have short strings and long strings and they are implemented differently.

[AdvenamTacet]

This update reverts part of a previous update and removes _LIBCPP_ASAN_ANNOTATE_ONLY_LONG.

[AdvenamTacet]

libcxx/include/__string/extern_template_lists.h

30

In general, ASan does accept false positives in situation when part of the program is compiled without ASan. That may happen with std::vector annotations already. But minimizing the risk of it is a good course of action.
I agree that a separate built is the goal solution. I think, it may work as a temporary solution and then be changed into a separate library built. What do you think?

But I understand if you disagree, just I'm also not sure what has to be changed here to add an ASan library build to llvm. What has to be done? Where should I look to learn it?
Please, let me know.

libcxx/include/string

1855

It's not necessary, I added it after discussion about problems ChromeOS had as another way to turn off annotations more granularly. However, I believe that D145628 already answers that problem. Removed it.

[AdvenamTacet]

@ldionne When a program is compiled with ASan, these annotations allow it to detect all accesses to memory that has been allocated but is not currently in use by an object of std::basic_string type. The only exception are functions where instrumentation has been explicitly disabled.

String annotations already exist in Microsoft C++ Standard Library.
Link: https://devblogs.microsoft.com/cppblog/stdstring-now-supports-address-sanitizer/

It’s not the same as libc++ hardening. While all accesses with operator[] or iterators are also detected, particularly important are cases with raw pointers, such as when passing data to C functions (strcpy() etc.).

The simplest example may be:

std::string s = “abcdefg”;
char *ptr = &s[4];
s = “”;
char c = *ptr; // ASan error

A write to *ptr would be detected as well.

Examples of what is detected are:

• incorrect use of C functions,
• random access to that memory (*(char *)randint() = 'x'; will be detected, if by chance unused strings memory is accessed),
• use after resize (as in the example above),
• other BO etc.

A real world bug, which motivated that research was as follow (simplified):

bool custom_cmp(const char l, const char r) {
        std::cout << "DEBUG print: " << l << " " << r << std::endl;

        return l < 'a' || l == r;
}

void foo() {
  std::string str1 = "A VERY LONG STRING IS HERE";
  std::string str2 = "short string";
  const char* iter1_begin = str1.c_str();
  const char* iter1_end   = str1.c_str() + str1.size();
  const char* iter2_begin = str2.c_str();

  std::cout << (std::equal(iter1_begin, iter1_end, buf, custom_cmp)) << std::endl;
}

Out-of-bounds read could happen as two strings were compared via a std::equals function that took iter1_begin, iter1_end, iter2_begin iterators (with a custom comparison function). When object str1 was longer than str2, read out-of-bounds on iter2 could happen. Container sanitization would detect it.
I hope it shows when those annotations are applicable. Let me know if you want me to add a bunch of samples to the patch. I can add a bunch of failing unit tests with examples. Is it a good idea?

This implementation uses the same API as std::vector (function: __sanitizer_annotate_contiguous_container) and from high level is the same here and there.
Long std::basic_string is almost the same as std::vecotr, so logic is absolutely the same. The difference is support for short strings, but that logic is very similar as well.
Long string (with standard allocators) annotations work with old ASan API (does not require rG1c5ad6d2c01294a0decde43a88e9c27d7437d157, so long-only patch wouldn't create a problem for ChromeOS). Only short string annotations require new API rG1c5ad6d2c01294a0decde43a88e9c27d7437d157.
If you think it's a good idea, I can split this patch into two. One for long only, second enabling SSO annotations.

It is worth mentioning that the change, proposed by me here, has negligible impact on performance, because when binary is already compiled with ASan, every access to strings memory is instrumented either way. Code from that change is executed only when strings size is modified and it's proportional to the change. All functions are no-ops when compiled without ASan.

---

Examples are above, here I let myself to digress a little. One may argue that some out of bounds errors may be detected by ASan without those changes, and that's true. If out of bound reaches memory outside of allocated area, ASan detects the bug without those changes. In situations like that, those changes increase speed of detecting errors. Potentially significantly, but I will come back to it. It's also worth to remember that there are no poisoned areas between elements in arrays.

std::string s[1024];
// ^ There are NO redzones between elements.

And memory is not poisoned inside classes between variables (and at the beginning and the end):

class X {
std::string x;
// NO redzone
int a[3];
};

Therefore, not every access outside of objects memory is detected. (Eg. above, s[0] is short, without detecting an error, BO can write over rest of 1023 strings memory. Error will be detected when memory after s[1023] is reached.) With those changes OOB will be detected, unless size() == capacity() before OOB happenes (case when there is no allocated and not-in-use memory).

---

Because short strings are on stack, bugs affect not only heap. Bellow I show modified example from above, with standard comparator, which leaks stack memory (including canary). Assumptions:

• user fully controls s[0],
• user has access to result of std::equals,
• it's super simplified.

bool result = false;
char x = 0;
size_t n = 0;

void user_input(std::string &s) {
  // Simulation of user providing input
  n += 1;

  if(result) {
    x = 0;
    std::cout << "Leaked " << s.size() << " bytes, with " << n << " requests." << std::endl;
    std::cout << "Leak: " << s << std::endl << std::endl;
    s.push_back('\0');
  } else {
    if(!s.empty()) s.pop_back();
    x += 1;
    s.push_back(x);
  }
}

void leak_cannary() {
  std::string s[3];
  s[2] = "secret data";
  for(int i = 0; i < 'z' * 100; ++i) {
    result = std::equal(s[0].begin(), s[0].end(), s[1].data());
    // User has access to the result.
    user_input(s[0]);
  }
}

Example result is: Leaked 169 bytes, with 12062 requests.

Chance of finding that bug with simple (random) harness and today ASan is close to zero, but it can be easily exploited.

Here I won't fully offtop how off-by-one on a buffer just before string may leak stack as well (same off-by-two on string with Alternate String Layout). If someone is interested, I'm happy to talk about ways to exploit SSO (connected with some bugs) outside of that revision, I was looking at it to create a CTF challenge.

[AdvenamTacet]

This update should resolve the conflict, it applies changes on the newest commit.

[AdvenamTacet]

This update is strictly related to refactor, which happened on the main branch.
No real changes included, newest commit from main as base.

[AdvenamTacet]

This update turns off annotations for short strings.
It is a small change and I will create another revision simply turning on annotations for short strings.

I was thinkin a lot about it and I believe it's better to have one patch turning on annotations for long strings only (with the default allocator only) and a separate one, very simple, turning on annotations for short strings as well.
My reasoning:

• Long strings with default allocator works with old ASan API. (Main reason.)
• There is much smaller chance to see a similar carse to area allocators (something we should address) with only long strings.
• If someone reports a problem, it's very helpful to see which change exactly caused the problem.

[AdvenamTacet]

This update:

• fixes problem with tests after setting _LIBCPP_SHORT_STRING_ANNOTATIONS_ALLOWED,
• removes #if ... [code] #endif from the test.

This is a fix after the previous update.

Also, I created a revision to turn on short string annotations.
Check D147680 for details.

Now short strings are not poisoned at all with this revision.

[AdvenamTacet]

This update tries to fix the merge conflict.

[ldionne]

libcxx/include/__string/extern_template_lists.h

30

I believe this means that -fsanitize=address would have to cause a different libc++.dylib to be linked. So for example, the driver would add e.g. -l c++asan instead of -l c++, and we would have to produce libc++asan.dylib in addition to libc++.dylib. That's not a small change though, since it seems like this might be the first time a sanitizer has an effect on the version of libc++ we have to link against. But it might be the right way to go (probably the only way to go, really). In practice, disabling extern templates like this is only going to give users the impression that things work and then they will run into issues.

CC @vitalybuka

libcxx/include/string

1854

Would __annotate_short_string_check be better called something like __short_string_is_annotated()?

2540

Isn't that a pre-existing problem that should be fixed in its own patch?

2627

I feel like this function would be a lot simpler if we instead called __annotate_contiguous_container directly, no?

2722

This whole set of changes feels kind of clunky. Why don't we annotate delete and then annotate new instead? Wouldn't that get rid of the special this check?

[ldionne]

Thanks a lot for the write up, I think this makes sense. I still find this more intrusive than I'd like, but let's see how we can improve this in a few places.

[AdvenamTacet]

libcxx/include/string

2540

I created a separate revision with that change: D148693
I will remove it from this patch in the next update.

[AdvenamTacet]

This update:

• changes name of __annotate_short_string_check function to __asan_short_string_is_annotated,
• removes the fix moved to D148693 revision,
• simplifies a function entioned in a code review,
• fixes use of & instead of std::addressof in libcxx/test/support/asan_testing.h.

Thank you for looking at it!

[AdvenamTacet]

libcxx/include/string

1854

I changed it to __asan_short_string_is_annotated, but I don't fully like those names. I added asan so it is clear what kind of annotations are [not] there.

2627

I do not think so, and I don't like the idea of calling __annotate_contiguous_container directly, but I did improve the function a lot. Hope it's ok now.

2722

No, it wouldn't. Here we are working on __str and not *this. We cannot __annotate_delete __str, if it's long because we would have to annotate whole string every time (big performance hit and stil check).

We also shouldn't call __annotate_delete on *this and __str if those are the same objects.

So, the check would be just earlier. Or maybe I don't see something here?

[AdvenamTacet]

libcxx/include/__string/extern_template_lists.h

30

@vitalybuka do you have any suggestion how to implement it?

Btw. a separate dylib may help with issue described here: https://github.com/llvm/llvm-project/issues/62431 (not sure, tho).

[AdvenamTacet]

This update:

• fixes annotations after changes in D148693,
• does rebase.

Now the revision is working, the only missing element is a separate dylib for ASan.

[AdvenamTacet]

libcxx/include/__string/extern_template_lists.h

30

Hey @ldionne,
could you tell me where I should look to modify it? I don't really know how to start working on that change and I believe, it's the only missing part after landing D148693. I would appreciate letting me know at what files I should look first.

Btw. it won't affect the issue mentioned above.

[ldionne]

libcxx/include/__string/extern_template_lists.h

30

I think we would want to start with a RFC on Discourse. This would be the first time that we introduce another shared library for libc++ and there are a few things to coordinate:

1. We need to build this new version of the library (do we do that with multiple CMake invocations or do we do like compiler-rt and allow building multiple libraries from a single invocation?)
2. We need to ship this library as part of the LLVM release and vendors need to also start shipping it with their own releases if they want -fsanitize=address to work
3. Do we need to also provide a -fsanitize=address version of other components in the LLVM stack? For example, if we ship another library that uses libc++ and we want it to work with -fsanitize=address, we would likely need to provide a sanitized version of it or else if e.g. a std::string is created inside that component and passed to another component that was compiled with -fsanitize=address, then you'd get a mismatch.

So this is unfortunately kind of involved, but I think knowing how to do this would benefit us since we have similar needs for other efforts. For example, it would be conceivable to ship an unstable-ABI version of the library, and a hardened version as well, and doing that would follow the exact same steps.

[vitalybuka]

libcxx/include/__string/extern_template_lists.h

30

I believe this means that -fsanitize=address would have to cause a different libc++.dylib to be linked. So for example, the driver would add e.g. -l c++asan instead of -l c++, and we would have to produce libc++asan.dylib in addition to libc++.dylib. That's not a small change though, since it seems like this might be the first time a sanitizer has an effect on the version of libc++ we have to link against. But it might be the right way to go (probably the only way to go, really). In practice, disabling extern templates like this is only going to give users the impression that things work and then they will run into issues.

For msan, tsan, instrumented libc++ was requirement all the time.
For asan, hwasan it's highly recommended.

For all use-case I work, we do that on build system level.
Our sanitizer*bootstrap build bots do that as well.

It would be nice if libc++ is shipped with each version. Sometimes additional flags may affect behavior of sanitizer, but even version instrumented with default flags will be useful.

CC @vitalybuka

@vitalybuka do you have any suggestion how to implement it?

I don't have specific thoughts on how to implemented.
I guess libc++ could install all sanitized versions with some prefixes: asan/msan/tsan/hwasan
Then the driver will pick one to link.

Btw. a separate dylib may help with issue described here: https://github.com/llvm/llvm-project/issues/62431 (not sure, tho).

30

I believe this means that -fsanitize=address would have to cause a different libc++.dylib to be linked. So for example, the driver would add e.g. -l c++asan instead of -l c++, and we would have to produce libc++asan.dylib in addition to libc++.dylib. That's not a small change though, since it seems like this might be the first time a sanitizer has an effect on the version of libc++ we have to link against. But it might be the right way to go (probably the only way to go, really). In practice, disabling extern templates like this is only going to give users the impression that things work and then they will run into issues.

CC @vitalybuka

30

I think we would want to start with a RFC on Discourse. This would be the first time that we introduce another shared library for libc++ and there are a few things to coordinate:

1. We need to build this new version of the library (do we do that with multiple CMake invocations or do we do like compiler-rt and allow building multiple libraries from a single invocation?)

Single invocation would be nice, as it's better scale on other sanitizers.

2. We need to ship this library as part of the LLVM release and vendors need to also start shipping it with their own releases if they want -fsanitize=address to work

please include msan/hwasan/tsan versions into the plan

lsan/ubsan do not needed special libc++.
dfsan is close to msan, but it's very specific tool, so we can skip for now.

[AdvenamTacet]

libcxx/include/__string/extern_template_lists.h

30

Created a RFC: https://discourse.llvm.org/t/rfc-instrumented-versions-of-libc-for-different-sanitizers/71653

Who can I/should I ping there? Who can I ping from vendors?

[AdvenamTacet]

libcxx/include/string

3308

The issue described above is addressed in D148693 and solved by rG6a9c41fdd4ca834a46fd866278c90a35f2375333. This revision has to be updated. Now the size is correct after __grow_by_without_replace.

[AdvenamTacet]

This revision has been moved into GH: https://github.com/llvm/llvm-project/pull/72677

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.
+#if !defined(_LIBCPP_HAS_NO_ASAN)
+// TODO LLVM18: Remove the special-casing (_LIBCPP_CLANG_VER)
+#  define _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_Func, _CharType)
+
+#  define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType)
+#else
 #define _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
   _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, allocator<_CharType> const&)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
#define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
   _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
   _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
   _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
-
+#endif // !defined(_LIBCPP_HAS_NO_ASAN)
 
 #endif // _LIBCPP___STRING_EXTERN_TEMPLATE_LISTS_H

libcxx/include/string

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
+#ifndef _LIBCPP_HAS_NO_ASAN
+#  define _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS __attribute__((__no_sanitize__("address")))
+// Sometimes string access own memory, which should not be accessed by different parts of program
+// (eg. not-in-use bytes of buffer in short string) and are poisoned by ASan.
+// This macro turns off instrumentation in a function, so memory accesses which normally would crash
+// work as expected.
+#else
+#  define _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // basic_string
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
struct __can_be_converted_to_string_view : public _BoolConstant<
      !is_convertible<const _Tp&, const _CharT*>::value
     > {};
 
 struct __uninitialized_size_tag {};
 
 template<class _CharT, class _Traits, class _Allocator>
 class basic_string
 {
+private:
+  using __default_allocator_type = allocator<_CharT>;
+
 public:
     typedef basic_string                                 __self;
     typedef basic_string_view<_CharT, _Traits>           __self_view;
     typedef _Traits                                      traits_type;
     typedef _CharT                                       value_type;
     typedef _Allocator                                   allocator_type;
     typedef allocator_traits<allocator_type>             __alloc_traits;
     typedef typename __alloc_traits::size_type           size_type;

 #else
       _NOEXCEPT
 #endif
       : __r_(__default_init_tag(), __a) {
     std::__debug_db_insert_c(this);
     __default_init();
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const basic_string& __str);
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const basic_string& __str, const allocator_type& __a);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS basic_string(const basic_string& __str);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
+  basic_string(const basic_string& __str, const allocator_type& __a);
 
 #ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(basic_string&& __str)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  basic_string(basic_string&& __str)
 #  if _LIBCPP_STD_VER <= 14
       _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #  else
       _NOEXCEPT
 #  endif
-      : __r_(std::move(__str.__r_)) {
+      // Turning off ASan instrumentation for variable initialization with _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
+      // is inconsistent and that initialization may be annotated.
+      // Therefore, to copy __str memory, we have to unpoison it first (if object is poisoned and not external buffer,
+      // so short string case).
+      : __r_( ( (__str.__is_long() ? 0 : (__str.__annotate_delete(), 0)), std::move(__str.__r_)) ) {
     __str.__default_init();
     std::__debug_db_insert_c(this);
     if (__is_long())
       std::__debug_db_swap(this, &__str);
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(basic_string&& __str, const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
+  basic_string(basic_string&& __str, const allocator_type& __a)
       : __r_(__default_init_tag(), __a) {
     if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
       __init(std::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
     else {
       if (__libcpp_is_constant_evaluated())
         __r_.first() = __rep();
       __r_.first() = __str.__r_.first();
+      if (!__str.__is_long()) {
+        __str.__annotate_delete();
+      }
       __str.__default_init();
     }
     std::__debug_db_insert_c(this);
     if (__is_long())
       std::__debug_db_swap(this, &__str);
   }
 #endif // _LIBCPP_CXX03_LANG
 
#endif
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(size_type __n, _CharT __c)
       : __r_(__default_init_tag(), __default_init_tag()) {
     __init(__n, __c);
     std::__debug_db_insert_c(this);
   }
 
 #if _LIBCPP_STD_VER >= 23
-  _LIBCPP_HIDE_FROM_ABI constexpr
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS constexpr
   basic_string(basic_string&& __str, size_type __pos, const _Allocator& __alloc = _Allocator())
       : basic_string(std::move(__str), __pos, npos, __alloc) {}
 
-  _LIBCPP_HIDE_FROM_ABI constexpr
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS constexpr
   basic_string(basic_string&& __str, size_type __pos, size_type __n, const _Allocator& __alloc = _Allocator())
       : __r_(__default_init_tag(), __alloc) {
     if (__pos > __str.size())
       __throw_out_of_range();
 
     auto __len = std::min<size_type>(__n, __str.size() - __pos);
     if (__alloc_traits::is_always_equal::value || __alloc == __str.__alloc()) {
       __r_.first() = __str.__r_.first();
+      if (!__str.__is_long()) {
+        __str.__annotate_delete();
+      }
       __str.__default_init();
 
       _Traits::move(data(), data() + __pos, __len);
       __set_size(__len);
       _Traits::assign(data()[__len], value_type());
     } else {
       // Perform a copy because the allocators are not compatible.
       __init(__str.data() + __pos, __len);
#endif // _LIBCPP_CXX03_LANG
     template <class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
                                                !__is_same_uncvref<_Tp, basic_string>::value> >
     _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(const _Tp& __t) {
       __self_view __sv = __t;
       return assign(__sv);
     }
 
 #ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(basic_string&& __str)
-      _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS basic_string&
+    operator=(basic_string&& __str) _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) {
     __move_assign(__str, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
     return *this;
   }
 
      _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& operator=(const value_type* __s) {return assign(__s);}
 #if _LIBCPP_STD_VER >= 23
     basic_string& operator=(nullptr_t) = delete;
 #endif
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(value_type __c);
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS basic_string& operator=(value_type __c);
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     iterator begin() _NOEXCEPT
         {return __make_iterator(__get_pointer());}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     const_iterator begin() const _NOEXCEPT
         {return __make_const_iterator(__get_pointer());}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
__enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
         >
                  assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& assign(const basic_string& __str) { return *this = __str; }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
     basic_string& assign(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
         {*this = std::move(__str); return *this;}
 #endif
     _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20
     __enable_if_t

 private:
     template<class _Alloc>
     inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     bool friend operator==(const basic_string<char, char_traits<char>, _Alloc>& __lhs,
                            const basic_string<char, char_traits<char>, _Alloc>& __rhs) _NOEXCEPT;
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __shrink_or_extend(size_type __target_capacity);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
     bool __is_long() const _NOEXCEPT {
         if (__libcpp_is_constant_evaluated())
             return true;
         return __r_.first().__s.__is_long_;
     }
 
     static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __begin_lifetime(pointer __begin, size_type __n) {
 #if _LIBCPP_STD_VER >= 20
         if (__libcpp_is_constant_evaluated()) {
             for (size_type __i = 0; __i != __n; ++__i)
                 std::construct_at(std::addressof(__begin[__i]));
         }
 #else
         (void)__begin;
         (void)__n;
 #endif // _LIBCPP_STD_VER >= 20
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __default_init() {
         __r_.first() = __rep();
+        __annotate_new(0);
         if (__libcpp_is_constant_evaluated()) {
             size_type __sz = __recommend(0) + 1;
             pointer __ptr = __alloc_traits::allocate(__alloc(), __sz);
             __begin_lifetime(__ptr, __sz);
             __set_long_pointer(__ptr);
             __set_long_cap(__sz);
             __set_long_size(0);
         }
#endif // _LIBCPP_STD_VER >= 20
     template <class _ForwardIterator>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
     iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
         size_type __sz = size();
         size_type __cap = capacity();
         value_type* __p;
         if (__cap - __sz >= __n)
         {
+          __annotate_increase(__n);
             __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);
+            __annotate_increase(__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);
 
         return begin() + __ip;
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
     void __set_short_size(size_type __s) _NOEXCEPT {
         _LIBCPP_ASSERT(__s < __min_cap, "__s should never be greater than or equal to the short string capacity");
         __r_.first().__s.__size_ = __s;
         __r_.first().__s.__is_long_ = false;
     }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
     size_type __get_short_size() const _NOEXCEPT {
         _LIBCPP_ASSERT(!__r_.first().__s.__is_long_, "String has to be short when trying to get the short size");
         return __r_.first().__s.__size_;
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __set_long_size(size_type __s) _NOEXCEPT
         {__r_.first().__l.__size_ = __s;}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     size_type __get_long_size() const _NOEXCEPT
         {return __r_.first().__l.__size_;}
#endif // _LIBCPP_STD_VER >= 20
     const_pointer __get_short_pointer() const _NOEXCEPT
         {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     pointer __get_pointer() _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     const_pointer __get_pointer() const _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
 
+    // The following functions are no-ops outside of AddressSanitizer mode.
+#ifndef _LIBCPP_HAS_NO_ASAN
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_contiguous_container(
+        const void* __old_mid, const void* __new_mid) const {
+        const void* __begin = data();
+        const void* __end = data() + capacity() + 1;
+        #  if _LIBCPP_CLANG_VER < 1600
+        if (!__libcpp_is_constant_evaluated() && __begin != nullptr && is_same<allocator_type, __default_allocator_type>::value)
+        #else
+        if (!__libcpp_is_constant_evaluated() && __begin != nullptr)
+        #  endif
+        __sanitizer_annotate_contiguous_container(__begin, __end, __old_mid, __new_mid);
+    }
+#else
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+    __annotate_contiguous_container(const void*, const void*) const {}
+#endif
+
+    // ASan: short string is poisoned if and only if this function returns true.
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __annotate_short_string_check() const _NOEXCEPT {
+#if (!defined(_LIBCPP_HAS_NO_ASAN)) && (_LIBCPP_CLANG_VER >= 1600)
+      return !__libcpp_is_constant_evaluated();
+#else
+      return false;
+#endif
+    }
+
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_new(size_type __current_size) const _NOEXCEPT {
+      if (!__libcpp_is_constant_evaluated() && (__annotate_short_string_check() || __is_long()))
+        __annotate_contiguous_container(data() + capacity() + 1, data() + __current_size + 1);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_delete() const _NOEXCEPT {
+      if (!__libcpp_is_constant_evaluated() && (__annotate_short_string_check() || __is_long()))
+        __annotate_contiguous_container(data() + size() + 1, data() + capacity() + 1);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_increase(size_type __n) const _NOEXCEPT {
+      if (!__libcpp_is_constant_evaluated() && (__annotate_short_string_check() || __is_long()))
+        __annotate_contiguous_container(data() + size() + 1, data() + size() + 1 + __n);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_shrink(size_type __old_size) const _NOEXCEPT {
+      if (!__libcpp_is_constant_evaluated() && (__annotate_short_string_check() || __is_long()))
+        __annotate_contiguous_container(data() + __old_size + 1, data() + size() + 1);
+    }
+
     template <size_type __a> static
         _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
         size_type __align_it(size_type __s) _NOEXCEPT
             {return (__s + (__a-1)) & ~(__a-1);}
     enum {__alignment = 16};
     static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     size_type __recommend(size_type __s) _NOEXCEPT
     {
         if (__s < __min_cap) {
             if (__libcpp_is_constant_evaluated())
                 return static_cast<size_type>(__min_cap);
             else
                 return static_cast<size_type>(__min_cap) - 1;
         }
         size_type __guess = __align_it<sizeof(value_type) < __alignment ?
                      __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
         if (__guess == __min_cap) ++__guess;
         return __guess;
     }
 
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __init(const value_type* __s, size_type __sz, size_type __reserve);
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __init(const value_type* __s, size_type __sz);
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __init(size_type __n, value_type __c);
 
#endif
     template <class _ForwardIterator>
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20
     __enable_if_t
     <
         __is_cpp17_forward_iterator<_ForwardIterator>::value
     >
     __init(_ForwardIterator __first, _ForwardIterator __last);
 
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     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
     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);
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __erase_to_end(size_type __pos) {
     __null_terminate_at(std::__to_address(__get_pointer()), __pos);
   }
 
     // __erase_external_with_move is invoked for erase() invocations where
     // `n ~= npos`, likely requiring memory moves on the string data.
     _LIBCPP_CONSTEXPR_SINCE_CXX20 void __erase_external_with_move(size_type __pos, size_type __n);
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __copy_assign_alloc(const basic_string& __str)
         {__copy_assign_alloc(__str, integral_constant<bool,
                       __alloc_traits::propagate_on_container_copy_assignment::value>());}
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __copy_assign_alloc(const basic_string& __str, true_type)
         {
             if (__alloc() == __str.__alloc())
                 __alloc() = __str.__alloc();
             else
             {
                 if (!__str.__is_long())
                 {
                     __clear_and_shrink();
                     __alloc() = __str.__alloc();
                 }
                 else
                 {
+                    __annotate_delete();
                     allocator_type __a = __str.__alloc();
                     auto __allocation = std::__allocate_at_least(__a, __str.__get_long_cap());
                     __begin_lifetime(__allocation.ptr, __allocation.count);
                     __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
                     __alloc() = std::move(__a);
                     __set_long_pointer(__allocation.ptr);
                     __set_long_cap(__allocation.count);
                     __set_long_size(__str.size());
+                    __annotate_new(__get_long_size());
                 }
             }
         }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
         {}
 
void __move_assign_alloc(basic_string&, false_type)
         _NOEXCEPT
         {}
 
     _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& __assign_external(const value_type* __s);
     _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& __assign_external(const value_type* __s, size_type __n);
 
     // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
     inline basic_string& __assign_short(const value_type* __s, size_type __n) {
+      size_type __old_size = size();
+      if (__n > __old_size)
+        __annotate_increase(__n - __old_size);
       pointer __p = __is_long()
                         ? (__set_long_size(__n), __get_long_pointer())
                         : (__set_short_size(__n), __get_short_pointer());
       traits_type::move(std::__to_address(__p), __s, __n);
       traits_type::assign(__p[__n], value_type());
+      if (__old_size > __n)
+        __annotate_shrink(__old_size);
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& __null_terminate_at(value_type* __p, size_type __newsz) {
+      size_type __old_size = size();
+      if (__newsz > __old_size)
+        __annotate_increase(__newsz - __old_size);
       __set_size(__newsz);
       __invalidate_iterators_past(__newsz);
       traits_type::assign(__p[__newsz], value_type());
+      if (__old_size > __newsz)
+        __annotate_shrink(__old_size);
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __invalidate_iterators_past(size_type);
 
     template<class _Tp>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     bool __addr_in_range(_Tp&& __t) const {
void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
                                                        size_type __sz,
                                                        size_type __reserve)
 {
     if (__libcpp_is_constant_evaluated())
         __r_.first() = __rep();
     if (__reserve > max_size())
         __throw_length_error();
     pointer __p;
     if (__fits_in_sso(__reserve))
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__reserve) + 1);
         __p = __allocation.ptr;
         __begin_lifetime(__p, __allocation.count);
         __set_long_pointer(__p);
         __set_long_cap(__allocation.count);
         __set_long_size(__sz);
     }
     traits_type::copy(std::__to_address(__p), __s, __sz);
     traits_type::assign(__p[__sz], value_type());
+    __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
 {
     if (__libcpp_is_constant_evaluated())
else
         __p = __allocation.ptr;
         __begin_lifetime(__p, __allocation.count);
         __set_long_pointer(__p);
         __set_long_cap(__allocation.count);
         __set_long_size(__sz);
     }
     traits_type::copy(std::__to_address(__p), __s, __sz);
     traits_type::assign(__p[__sz], value_type());
+    __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
 {
     _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
     __init(__s, traits_type::length(__s));
     std::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
     : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
 {
     if (!__str.__is_long())
+    {
         __r_.first() = __str.__r_.first();
+        __annotate_new(__get_short_size());
+    }
     else
         __init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()),
                                   __str.__get_long_size());
     std::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     const basic_string& __str, const allocator_type& __a)
     : __r_(__default_init_tag(), __a)
 {
     if (!__str.__is_long())
+    {
         __r_.first() = __str.__r_.first();
+        __annotate_new(__get_short_size());
+    }
     else
         __init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()),
                                   __str.__get_long_size());
     std::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
if (__fits_in_sso(__sz)) {
     auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
     __p = __allocation.ptr;
     __begin_lifetime(__p, __allocation.count);
     __set_long_pointer(__p);
     __set_long_cap(__allocation.count);
     __set_long_size(__sz);
   }
   traits_type::copy(std::__to_address(__p), __s, __sz + 1);
+  __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
 {
     if (__libcpp_is_constant_evaluated())
else
         __p = __allocation.ptr;
         __begin_lifetime(__p, __allocation.count);
         __set_long_pointer(__p);
         __set_long_cap(__allocation.count);
         __set_long_size(__n);
     }
     traits_type::assign(std::__to_address(__p), __n, __c);
     traits_type::assign(__p[__n], value_type());
+    __annotate_new(__n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
 {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
     for (; __first != __last; ++__first)
         push_back(*__first);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
+        __annotate_delete();
         if (__is_long())
             __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
         throw;
     }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <class _CharT, class _Traits, class _Allocator>

 #endif  // _LIBCPP_HAS_NO_EXCEPTIONS
     for (; __first != __last; ++__first, (void) ++__p)
         traits_type::assign(*__p, *__first);
     traits_type::assign(*__p, value_type());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
+        __annotate_delete();
         if (__is_long())
             __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
         throw;
     }
 #endif  // _LIBCPP_HAS_NO_EXCEPTIONS
+    __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>::~basic_string()
 {
+    __annotate_delete();
     std::__debug_db_erase_c(this);
     if (__is_long())
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 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)
 {
     size_type __ms = max_size();
     if (__delta_cap > __ms - __old_cap - 1)
         __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)) :
                           __ms - 1;
+    __annotate_delete();
     auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
     pointer __p = __allocation.ptr;
     __begin_lifetime(__p, __allocation.count);
     std::__debug_db_invalidate_all(this);
     if (__n_copy != 0)
         traits_type::copy(std::__to_address(__p),
                           std::__to_address(__old_p), __n_copy);
     if (__n_add != 0)
         traits_type::copy(std::__to_address(__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(std::__to_address(__p) + __n_copy + __n_add,
                           std::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
     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());
+    __annotate_new(__old_cap + __delta_cap);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 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)) :
                           __ms - 1;
+    __annotate_delete();
     auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
     pointer __p = __allocation.ptr;
     __begin_lifetime(__p, __allocation.count);
     std::__debug_db_invalidate_all(this);
     if (__n_copy != 0)
         traits_type::copy(std::__to_address(__p),
                           std::__to_address(__old_p), __n_copy);
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
     if (__sec_cp_sz != 0)
         traits_type::copy(std::__to_address(__p) + __n_copy + __n_add,
                           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);
+    __set_long_size(__old_sz);
+    __annotate_new(__old_sz);
 }
 
 // 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) {
   size_type __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap();
   if (__n < __cap) {
+    size_type __old_size = __is_short ? __get_short_size() : __get_long_size();
+    if (__n > __old_size)
+      __annotate_increase(__n - __old_size);
     pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
     __is_short ? __set_short_size(__n) : __set_long_size(__n);
     traits_type::copy(std::__to_address(__p), __s, __n);
     traits_type::assign(__p[__n], value_type());
     __invalidate_iterators_past(__n);
+    if (__old_size > __n)
+      __annotate_shrink(__old_size);
   } else {
     size_type __sz = __is_short ? __get_short_size() : __get_long_size();
     __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s);
   }
   return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_external(
     const value_type* __s, size_type __n) {
   size_type __cap = capacity();
   if (__cap >= __n) {
+    size_type __old_size = size();
+    if (__n > __old_size)
+      __annotate_increase(__n - __old_size);
     value_type* __p = std::__to_address(__get_pointer());
     traits_type::move(__p, __s, __n);
     return __null_terminate_at(__p, __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>
 _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();
+    size_type __old_size = size();
     if (__cap < __n)
     {
         size_type __sz = size();
         __grow_by(__cap, __n - __cap, __sz, 0, __sz);
     }
+    if(__n > __old_size)
+        __annotate_increase(__n - __old_size);
     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>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
 {
-    pointer __p;
-    if (__is_long())
-    {
-        __p = __get_long_pointer();
-        __set_long_size(1);
-    }
-    else
-    {
-        __p = __get_short_pointer();
-        __set_short_size(1);
-    }
-    traits_type::assign(*__p, __c);
-    traits_type::assign(*++__p, value_type());
-    __invalidate_iterators_past(1);
-    return *this;
+  size_type __old_size;
+  if (__is_long()) {
+    __old_size = __get_long_size();
+    if (__old_size == 0)
+      __annotate_increase(1);
+  } else {
+    __old_size = __get_short_size();
+    if (__old_size == 0)
+      __annotate_increase(1);
+  if (__old_size > 1)
+    __annotate_shrink(__old_size);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 {
   if (this != std::addressof(__str)) {
     __copy_assign_alloc(__str);
     if (!__is_long()) {
       if (!__str.__is_long()) {
+        size_type __old_size = __get_short_size();
+        if (__get_short_size() < __str.__get_short_size())
+          __annotate_increase(__str.__get_short_size() - __get_short_size());
         __r_.first() = __str.__r_.first();
+        if (__old_size > __get_short_size())
+          __annotate_shrink(__old_size);
       } else {
         return __assign_no_alias<true>(__str.data(), __str.size());
       }
     } else {
       return __assign_no_alias<false>(__str.data(), __str.size());
     }
   }
   return *this;

 {
     if (__alloc() != __str.__alloc())
         assign(__str);
     else
         __move_assign(__str, true_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
 #if _LIBCPP_STD_VER >= 17
     _NOEXCEPT
 #else
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 #endif
 {
+  __annotate_delete();
   if (__is_long()) {
     __alloc_traits::deallocate(__alloc(), __get_long_pointer(),
                                __get_long_cap());
 #if _LIBCPP_STD_VER <= 14
     if (!is_nothrow_move_assignable<allocator_type>::value) {
       __set_short_size(0);
       traits_type::assign(__get_short_pointer()[0], value_type());
+      __annotate_new(0);
     }
 #endif
   }
   __move_assign_alloc(__str);
+  size_type __str_old_size = __str.size();
+  bool __str_was_short   = !__str.__is_long();
+
   __r_.first() = __str.__r_.first();
   if (__libcpp_is_constant_evaluated()) {
     __str.__default_init();
   } else {
     __str.__set_short_size(0);
     traits_type::assign(__str.__get_short_pointer()[0], value_type());
   }
+
+  if (__str_was_short && this != &__str)
+    __str.__annotate_shrink(__str_old_size);
+  else
+    // ASan annotations: was long, so object memory is unpoisoned as new.
+    // Or is same as *this, and __annotate_delete() was called.
+    __str.__annotate_new(0);
+
+  // ASan annotations: Guard against `std::string s; s = std::move(s);`
+  // You can find more here: https://en.cppreference.com/w/cpp/utility/move
+  // Quote: "Unless otherwise specified, all standard library objects that have been moved
+  // from are placed in a "valid but unspecified state", meaning the object's class
+  // invariants hold (so functions without preconditions, such as the assignment operator,
+  // can be safely used on the object after it was moved from):"
+  // Quote: "v = std::move(v); // the value of v is unspecified"
+  if (!__is_long() && &__str != this)
+    // If it is long string, delete was never called.
+    __annotate_new(__get_short_size());
 }
 
 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t

 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
     basic_string<_CharT, _Traits, _Allocator>&
 >
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
+    size_type __old_size = size();
     size_type __cap = capacity();
     size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ?
         static_cast<size_type>(std::distance(__first, __last)) : 0;
 
     if (__string_is_trivial_iterator<_ForwardIterator>::value &&
         (__cap >= __n || !__addr_in_range(*__first)))
     {
         if (__cap < __n)
         {
             size_type __sz = size();
             __grow_by(__cap, __n - __cap, __sz, 0, __sz);
         }
+        if (__n > __old_size)
+            __annotate_increase(__n - __old_size);
         pointer __p = __get_pointer();
         for (; __first != __last; ++__p, (void) ++__first)
             traits_type::assign(*__p, *__first);
         traits_type::assign(*__p, value_type());
         __set_size(__n);
         __invalidate_iterators_past(__n);
+        if (__n < __old_size)
+            __annotate_shrink(__old_size);
     }
     else
     {
         const basic_string __temp(__first, __last, __alloc());
         assign(__temp.data(), __temp.size());
     }
     return *this;
 }

 {
     _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_increase(__n);
             value_type* __p = std::__to_address(__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>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 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);
+        __annotate_increase(__n);
         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);
+        __annotate_increase(__n);
         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);
+        __annotate_increase(1);
         __is_short = false; // the string is always long after __grow_by
-    }
+    } else
+        __annotate_increase(1);
     pointer __p = __get_pointer();
     if (__is_short)
     {
         __p = __get_short_pointer() + __sz;
         __set_short_size(__sz+1);
     }
     else
     {
basic_string<_CharT, _Traits, _Allocator>::append(
     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);
+            __annotate_increase(__n);
             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 (__libcpp_is_constant_evaluated()) {
         else
             __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
         return *this;
     }
     if (__cap - __sz >= __n)
     {
         if (__n)
         {
+            __annotate_increase(__n);
             value_type* __p = std::__to_address(__get_pointer());
             size_type __n_move = __sz - __pos;
             if (__n_move != 0)
             {
                 if (__p + __pos <= __s && __s < __p + __sz)
                     __s += __n;
                 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
             }
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
     if (__pos > __sz)
         __throw_out_of_range();
     if (__n)
     {
         size_type __cap = capacity();
         value_type* __p;
         if (__cap - __sz >= __n)
         {
+            __annotate_increase(__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);
+            __annotate_increase(__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);
+        __annotate_increase(1);
         __p = std::__to_address(__get_long_pointer());
     }
     else
     {
+        __annotate_increase(1);
         __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);
     }
     traits_type::assign(__p[__ip], __c);
     traits_type::assign(__p[++__sz], value_type());
     __set_size(__sz);
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
     {
         if (__libcpp_is_constant_evaluated()) {
             __grow_by_and_replace(__cap, 0, __sz, __pos, __n1, __n2, __s);
             return *this;
         }
         value_type* __p = std::__to_address(__get_pointer());
         if (__n1 != __n2)
         {
+            if (__n2 > __n1)
+                __annotate_increase(__n2 - __n1);
             size_type __n_move = __sz - __pos - __n1;
             if (__n_move != 0)
             {
                 if (__n1 > __n2)
                 {
                     traits_type::move(__p + __pos, __s, __n2);
                     traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
                     return __null_terminate_at(__p, __sz + (__n2 - __n1));

 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)
         __throw_out_of_range();
     __n1 = std::min(__n1, __sz - __pos);
     size_type __cap = capacity();
     value_type* __p;
-    if (__cap - __sz + __n1 >= __n2)
-    {
-        __p = std::__to_address(__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);
-        __p = std::__to_address(__get_long_pointer());
+    if (__cap - __sz + __n1 >= __n2) {
+      if (__n1 != __n2) {
+        if (__n2 > __n1)
+          __annotate_increase(__n2 - __n1);
+    } else {
+      __annotate_increase(__n2 - __n1);
+      __set_long_size(__sz - __n1 + __n2);
     }
     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>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __enable_if_t
 <
basic_string<_CharT, _Traits, _Allocator>::pop_back()
     __erase_to_end(size() - 1);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
 {
+    size_type __old_size = size();
     std::__debug_db_invalidate_all(this);
     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_shrink(__old_size);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
 {
     size_type __sz = size();
basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT
     __shrink_or_extend(__target_capacity);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
 {
+    __annotate_delete();
     size_type __cap = capacity();
     size_type __sz = size();
 
     pointer __new_data, __p;
     bool __was_long, __now_long;
     if (__fits_in_sso(__target_capacity))
     {
         __was_long = true;
basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
     {
         __set_long_cap(__target_capacity+1);
         __set_long_size(__sz);
         __set_long_pointer(__new_data);
     }
     else
         __set_short_size(__sz);
     std::__debug_db_invalidate_all(this);
+    __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
 {
     if (__n >= size())
#endif
     if (!__str.__is_long())
         std::__debug_db_invalidate_all(&__str);
     std::__debug_db_swap(this, &__str);
 
     _LIBCPP_ASSERT(
         __alloc_traits::propagate_on_container_swap::value ||
         __alloc_traits::is_always_equal::value ||
         __alloc() == __str.__alloc(), "swapping non-equal allocators");
+    if (!__is_long())
+      __annotate_delete();
+    if (this != &__str && !__str.__is_long())
+      __str.__annotate_delete();
     std::swap(__r_.first(), __str.__r_.first());
     std::__swap_allocator(__alloc(), __str.__alloc());
+    if (!__is_long())
+      __annotate_new(__get_short_size());
+    if (this != &__str && !__str.__is_long())
+      __str.__annotate_new(__str.__get_short_size());
 }
 
 // find
 
 template <class _Traits>
 struct _LIBCPP_HIDDEN __traits_eq
 {
     typedef typename _Traits::char_type char_type;

 
 // __clear_and_shrink
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
 {
-    clear();
-    if(__is_long())
-    {
-        __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
-        __default_init();
-    }
+  if (__is_long()) {
+    __annotate_delete();
 }
 
 // operator==
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
 bool
 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
           const basic_string<_CharT, _Traits, _Allocator>& __rhs)
 {
     using _String = basic_string<_CharT, _Traits, _Allocator>;
     auto __lhs_sz = __lhs.size();
     auto __rhs_sz = __rhs.size();
     _String __r(__uninitialized_size_tag(),
                 __lhs_sz + __rhs_sz,
                 _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
     auto __ptr = std::__to_address(__r.__get_pointer());
     _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
     _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
     _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+    __r.__annotate_new(__lhs_sz + __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
 {
     using _String = basic_string<_CharT, _Traits, _Allocator>;
     auto __lhs_sz = _Traits::length(__lhs);
     auto __rhs_sz = __rhs.size();
     _String __r(__uninitialized_size_tag(),
                 __lhs_sz + __rhs_sz,
                 _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
+    __r.__annotate_delete();
     auto __ptr = std::__to_address(__r.__get_pointer());
     _Traits::copy(__ptr, __lhs, __lhs_sz);
     _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
     _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+    __r.__annotate_new(__lhs_sz + __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>
 operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
 {
     using _String = basic_string<_CharT, _Traits, _Allocator>;
     typename _String::size_type __rhs_sz = __rhs.size();
     _String __r(__uninitialized_size_tag(),
                 __rhs_sz + 1,
                 _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
+    __r.__annotate_delete();
     auto __ptr = std::__to_address(__r.__get_pointer());
     _Traits::assign(__ptr, 1, __lhs);
     _Traits::copy(__ptr + 1, __rhs.data(), __rhs_sz);
     _Traits::assign(__ptr + 1 + __rhs_sz, 1, _CharT());
+    __r.__annotate_new(1 + __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
 {
     using _String = basic_string<_CharT, _Traits, _Allocator>;
     typename _String::size_type __lhs_sz = __lhs.size();
     typename _String::size_type __rhs_sz = _Traits::length(__rhs);
     _String __r(__uninitialized_size_tag(),
                 __lhs_sz + __rhs_sz,
                 _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
+    __r.__annotate_delete();
     auto __ptr = std::__to_address(__r.__get_pointer());
     _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
     _Traits::copy(__ptr + __lhs_sz, __rhs, __rhs_sz);
     _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+    __r.__annotate_new(__lhs_sz + __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
 {
     using _String = basic_string<_CharT, _Traits, _Allocator>;
     typename _String::size_type __lhs_sz = __lhs.size();
     _String __r(__uninitialized_size_tag(),
                 __lhs_sz + 1,
                 _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
+    __r.__annotate_delete();
     auto __ptr = std::__to_address(__r.__get_pointer());
     _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
     _Traits::assign(__ptr + __lhs_sz, 1, __rhs);
     _Traits::assign(__ptr + 1 + __lhs_sz, 1, _CharT());
+    __r.__annotate_new(__lhs_sz + 1);
     return __r;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>

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

 
 // size_type capacity() const; // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 #include "test_macros.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, test_allocator_statistics& alloc_stats)
 {
     alloc_stats.throw_after = 0;

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

 
 // void clear(); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     s.clear();
     assert(s.size() == 0);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s;
   test(s);
+  LIBCPP_ASSERT(is_string_asan_correct(s));
 
   s.assign(10, 'a');
   s.erase(5);
+  LIBCPP_ASSERT(is_string_asan_correct(s));
   test(s);
 
   s.assign(100, 'a');
   s.erase(50);
+  LIBCPP_ASSERT(is_string_asan_correct(s));
   test(s);
+  LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 void
 test(typename S::size_type min_cap, typename S::size_type erased_index)
 {
     S s(min_cap, 'a');
     s.erase(erased_index);
     assert(s.size() == erased_index);
     assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
 
     typename S::size_type old_cap = s.capacity();
     S s0 = s;
     s.reserve();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 void test_string() {
   test<S>(0, 0);
   test<S>(10, 5);
   test<S>(100, 50);
 }
 
 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/reserve_size.asan.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "asan_testing.h"
+
+template <class S>
+void test() {
+  S short_s1(3, 'a'), long_s1(100, 'c');
+  short_s1.reserve(0x1337);
+  long_s1.reserve(0x1337);
+
+  LIBCPP_ASSERT(is_string_asan_correct(short_s1));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s1));
+#if TEST_STD_VER >= 11
+  short_s1.shrink_to_fit();
+  long_s1.shrink_to_fit();
+
+  LIBCPP_ASSERT(is_string_asan_correct(short_s1));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s1));
+#endif
+  short_s1.clear();
+  long_s1.clear();
+
+  LIBCPP_ASSERT(is_string_asan_correct(short_s1));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s1));
+#if TEST_STD_VER >= 11
+  short_s1.shrink_to_fit();
+  long_s1.shrink_to_fit();
+
+  LIBCPP_ASSERT(is_string_asan_correct(short_s1));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s1));
+#endif
+  S short_s2(3, 'a'), long_s2(100, 'c');
+  short_s2.reserve(0x1);
+  long_s2.reserve(0x1);
+
+  LIBCPP_ASSERT(is_string_asan_correct(short_s2));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s2));
+}
+
+int main(int, char**) {
+  {
+    using S = std::string;
+    test<S>();
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    using S = std::wstring;
+    test<S>();
+  }
+#endif
+#if TEST_STD_VER >= 11
+  {
+    using S = std::u16string;
+    test<S>();
+  }
+  {
+    using S = std::u32string;
+    test<S>();
+  }
+#endif
+#if TEST_STD_VER >= 20
+  {
+    using S = std::u8string;
+    test<S>();
+  }
+#endif
+
+  return 0;
+}

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

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0}}
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg)
 {
     S s(min_cap, 'a');
     s.erase(erased_index);
     assert(s.size() == erased_index);

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

 // void resize_and_overwrite(size_type n, Operation op)
 
 #include <algorithm>
 #include <cassert>
 #include <string>
 
 #include "make_string.h"
 #include "test_macros.h"
+#include "asan_testing.h"
 
 template <class S>
 constexpr void test_appending(size_t k, size_t N, size_t new_capacity) {
   assert(N > k);
   assert(new_capacity >= N);
   auto s = S(k, 'a');
   s.resize_and_overwrite(new_capacity, [&](auto* p, auto n) {
     assert(n == new_capacity);
constexpr bool test() {
   test_truncating<S>(40, 10);
 
   return true;
 }
 
 void test_value_categories() {
   std::string s;
   s.resize_and_overwrite(10, [](char*&&, size_t&&) { return 0; });
+  LIBCPP_ASSERT(is_string_asan_correct(s));
   s.resize_and_overwrite(10, [](char* const&, const size_t&) { return 0; });
+  LIBCPP_ASSERT(is_string_asan_correct(s));
   struct RefQualified {
     int operator()(char*, size_t) && { return 0; }
   };
   s.resize_and_overwrite(10, RefQualified{});
+  LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 int main(int, char**) {
   test<char>();
   test<char8_t>();
   test<char16_t>();
   test<char32_t>();
 

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

 // void resize(size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, S expected)
 {
     if (n <= s.max_size())
     {
         s.resize(n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.resize(n);
             assert(false);
test(S("12345678901234567890123456789012345678901234567890"), 60,
         S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
   test(S(), S::npos, S("not going to happen"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

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

 // void resize(size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     if (n <= s.max_size())
     {
         s.resize(n, c);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.resize(n, c);
             assert(false);
TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("12345678901234567890123456789012345678901234567890"), 0, 'a', S());
   test(S("12345678901234567890123456789012345678901234567890"), 10, 'a',
         S("1234567890"));
   test(S("12345678901234567890123456789012345678901234567890"), 50, 'a',
         S("12345678901234567890123456789012345678901234567890"));
   test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
         S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
   test(S(), S::npos, 'a', S("not going to happen"));
+  //ASan:
+  test(S(), 21, 'a', S("aaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 22, 'a', S("aaaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 23, 'a', S("aaaaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 24, 'a', S("aaaaaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 29, 'a', S("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 30, 'a', S("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 31, 'a', S("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 32, 'a', S("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
+  test(S(), 33, 'a', S("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 

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

 
 // void shrink_to_fit(); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     typename S::size_type old_cap = s.capacity();
     S s0 = s;
     s.shrink_to_fit();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s;
   test(s);
 
   s.assign(10, 'a');
   s.erase(5);
   test(s);
 
   s.assign(100, 'a');
   s.erase(50);
   test(s);
+
+  s.assign(100, 'a');
+  for(int i = 0; i < 90; ++i)
+    s.erase(1);
+  test(s);
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp

 #include <string_view>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(SV sv, std::size_t pos, std::size_t n)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     typedef typename S::size_type Size;
     if (pos <= sv.size())
     {
         S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
         LIBCPP_ASSERT(s2.__invariants());
         assert(pos <= sv.size());
         std::size_t rlen = std::min(sv.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
+        LIBCPP_ASSERT(is_string_asan_correct(s2));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
             assert(false);

libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp

 // explicit basic_string(const Allocator& a = Allocator()); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
     {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
     S s;
     LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
     assert(s.get_allocator() == typename S::allocator_type());
+    LIBCPP_ASSERT(is_string_asan_correct(s));
     }
     {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{typename S::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type(5));
     LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
     assert(s.get_allocator() == typename S::allocator_type(5));
+    LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 }
 
 #if TEST_STD_VER >= 11
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test2()
 {
     {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
     S s;
     LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
     assert(s.get_allocator() == typename S::allocator_type());
+    LIBCPP_ASSERT(is_string_asan_correct(s));
     }
     {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{typename S::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type{});
     LIBCPP_ASSERT(s.__invariants());
     assert(s.data());
     assert(s.size() == 0);
     assert(s.capacity() >= s.size());
     assert(s.get_allocator() == typename S::allocator_type());
+    LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 }
 
 #endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #if TEST_STD_VER >= 11
   test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
+  test2<std::basic_string<char, std::char_traits<char>, safe_allocator<char> > >();
   test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp

 
 // basic_string<charT,traits,Allocator>&
 //   operator=(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "asan_testing.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
   // Test that assignment from {} and {ptr, len} are allowed and are not
   // ambiguous.
   {
     std::string s = "hello world";
     s = {};
     assert(s.empty());
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
   {
     std::string s = "hello world";
     s = {"abc", 2};
     assert(s == "ab");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp

 
 // basic_string<charT,traits,Allocator>& operator=(charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, typename S::value_type s2)
 {
     typedef typename S::traits_type T;
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == 1);
     assert(T::eq(s1[0], s2));
     assert(s1.capacity() >= s1.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 'a');
   test(S("1"), 'a');
   test(S("123456789"), 'a');
   test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');

libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp

 // basic_string(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1)
 {
     S s2 = s1;
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == s1.get_allocator());
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
   }
 #if TEST_STD_VER >= 11
   {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A{}));
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
   }
+  {
+    typedef safe_allocator<char> A;
+    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    test(S(A{}));
+    test(S("1", A()));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+  }
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

 // basic_string(const basic_string& str, const Allocator& alloc); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct alloc_imp {
     bool active;
 
     TEST_CONSTEXPR alloc_imp() : active(true) {}
 
     template <class T>

 TEST_CONSTEXPR_CXX20 void
 test(S s1, const typename S::allocator_type& a)
 {
     S s2(s1, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == a);
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A(3));
     test(S("1"), A(5));

libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   operator=(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, const S& s2)
 {
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1 == s2);
     assert(s1.capacity() >= s1.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), S());
   test(S("1"), S());
   test(S(), S("1"));
   test(S("1"), S("2"));

libcxx/test/std/strings/basic.string/string.cons/default.pass.cpp

 
 // basic_string() noexcept(is_nothrow_default_constructible<allocator_type>::value); // constexpr since C++20
 
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
 #include "test_allocator.h"
+#include "asan_testing.h"
 
 #if TEST_STD_VER >= 11
 // Test the noexcept specification, which is a conforming extension
 LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<std::string>::value, "");
 LIBCPP_STATIC_ASSERT(std::is_nothrow_default_constructible<
                      std::basic_string<char, std::char_traits<char>, test_allocator<char>>>::value, "");
 LIBCPP_STATIC_ASSERT(!std::is_nothrow_default_constructible<
                      std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10>>>::value, "");
 #endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
   std::string str;
   assert(str.empty());
+  LIBCPP_ASSERT(is_string_asan_correct(str));
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp

 // basic_string(initializer_list<charT> il, const Allocator& a = Allocator()); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string s = {'a', 'b', 'c'};
     assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     std::wstring s;
     s = {L'a', L'b', L'c'};
     assert(s == L"abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 #endif
   {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s = {'a', 'b', 'c'};
     assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, safe_allocator<char>> S;
+    S s = {'a', 'b', 'c'};
+    assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
     S s;
     s = {L'a', L'b', L'c'};
     assert(s == L"abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp

 
 // basic_string& operator=(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string s;
     s = {'a', 'b', 'c'};
     assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
   {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     s = {'a', 'b', 'c'};
     assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, safe_allocator<char>> S;
+    S s;
+    s = {'a', 'b', 'c'};
+    assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, safe_allocator<char>> S;
+    S s;
+    s = {'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a'};
+    assert(s == "aaaaaaaaaaaaaaaaaaaaaaaa");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class It>
 TEST_CONSTEXPR_CXX20 void
 test(It first, It last)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::allocator_type A;
     S s2(first, last);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last;) {
         assert(s2[i] == *it);
         ++it;
         ++i;
     }
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class It, class A>
 TEST_CONSTEXPR_CXX20 void
 test(It first, It last, const A& a)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     S s2(first, last, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last;) {
         assert(s2[i] == *it);
         ++it;
         ++i;
     }
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef test_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
 
     test(s, s);

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

 #include <cstddef>
 #include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 class NotAnIterator {};
 using NotAnInputIterator = std::back_insert_iterator<std::basic_string<char16_t>>;
 
 template <typename T>
 struct NotAnAllocator { typedef T value_type; };
 
 template <class Iter, class Alloc, class = void>

libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp

 // basic_string(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s0)
 {
     S s1 = s0;
     S s2 = std::move(s0);
     LIBCPP_ASSERT(s2.__invariants());
     LIBCPP_ASSERT(s0.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == s1.get_allocator());
+    LIBCPP_ASSERT(is_string_asan_correct(s0));
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
   }
   {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A{}));
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
   }
+  {
+    typedef safe_allocator<char> A;
+    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    test(S(A{}));
+    test(S("1", A()));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
+  }
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp

 // basic_string(basic_string&& str, const Allocator& alloc); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s0, const typename S::allocator_type& a)
 {
     S s1 = s0;
     S s2(std::move(s0), a);
     LIBCPP_ASSERT(s2.__invariants());
     LIBCPP_ASSERT(s0.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == a);
+    LIBCPP_ASSERT(is_string_asan_correct(s0));
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_allocator_statistics alloc_stats;
   {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14

libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp

 //   operator=(basic_string<charT,traits,Allocator>&& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s0 = s2;
     s1 = std::move(s2);
     LIBCPP_ASSERT(s1.__invariants());
     LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s0);
     assert(s1.capacity() >= s1.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s0));
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), S());
   test(S("1"), S());
   test(S(), S("1"));
   test(S("1"), S("2"));
test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
           "1234567890123456789012345678901234567890123456789012345678901234567890"),
         S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp

 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class charT>
 TEST_CONSTEXPR_CXX20 void
 test(const charT* s)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     std::size_t n = T::length(s);
     S s2(s);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class charT, class A>
 TEST_CONSTEXPR_CXX20 void
 test(const charT* s, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     std::size_t n = T::length(s);
     S s2(s, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef test_allocator<char> A;
 
     test("");
     test("", A(2));

libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   operator=(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, const typename S::value_type* s2)
 {
     typedef typename S::traits_type T;
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == T::length(s2));
     assert(T::compare(s1.data(), s2, s1.size()) == 0);
     assert(s1.capacity() >= s1.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "");
   test(S("1"), "");
   test(S(), "1");
   test(S("1"), "2");
test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
           "1234567890123456789012345678901234567890123456789012345678901234567890"),
         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class charT>
 TEST_CONSTEXPR_CXX20 void
 test(const charT* s, unsigned n)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     S s2(s, n);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class charT, class A>
 TEST_CONSTEXPR_CXX20 void
 test(const charT* s, unsigned n, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     S s2(s, n, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef test_allocator<char> A;
 
     test("", 0);
     test("", 0, A(2));

libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp

 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class charT>
 TEST_CONSTEXPR_CXX20 void
 test(unsigned n, charT c)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::allocator_type A;
     S s2(n, c);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class charT, class A>
 TEST_CONSTEXPR_CXX20 void
 test(unsigned n, charT c, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     S s2(n, c, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class Tp>
 TEST_CONSTEXPR_CXX20 void
 test(Tp n, Tp c)
 {
     typedef char charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
#if TEST_STD_VER >= 11
     test(10, 'a', A());
 
     test(100, 'a');
     test(100, 'a', A());
 
     test(static_cast<char>(100), static_cast<char>(65));
     test(static_cast<char>(100), static_cast<char>(65), A());
   }
+  {
+    typedef safe_allocator<char> A;
+
+    test(0, 'a');
+    test(0, 'a', A());
+
+    test(1, 'a');
+    test(1, 'a', A());
+
+    test(10, 'a');
+    test(10, 'a', A());
+
+    test(100, 'a');
+    test(100, 'a', A());
+
+    test(static_cast<char>(100), static_cast<char>(65));
+    test(static_cast<char>(100), static_cast<char>(65), A());
+  }
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp

 #include <stdexcept>
 #include <string_view>
 #include <string>
 #include <type_traits>
 
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "test_macros.h"
+#include "asan_testing.h"
 
 static_assert(!std::is_convertible<std::string_view, std::string const&>::value, "");
 static_assert(!std::is_convertible<std::string_view, std::string>::value, "");
 
 template <class charT>
 TEST_CONSTEXPR_CXX20 void
 test(std::basic_string_view<charT> sv)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
   {
     S s2(sv);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
   }
   {
     S s2;
     s2 = sv;
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
   }
 }
 
 template <class charT, class A>
 TEST_CONSTEXPR_CXX20 void
 test(std::basic_string_view<charT> sv, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
   {
     S s2(sv, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
   }
   {
     S s2(a);
     s2 = sv;
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
   }
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef test_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
 

libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp

 
 // basic_string<charT,traits,Allocator>& operator=(basic_string_view<charT, traits> sv); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, SV sv)
 {
     typedef typename S::traits_type T;
     s1 = sv;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == sv.size());
     assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
     assert(s1.capacity() >= s1.size());
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   typedef std::string_view SV;
   test(S(), SV(""));
   test(S("1"), SV(""));
   test(S(), SV("1"));
test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
           "1234567890123456789012345678901234567890123456789012345678901234567890"),
         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp

 #include <algorithm>
 #include <vector>
 #include <scoped_allocator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
 
     if (pos <= str.size())
     {
         S s2(str, pos);
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = str.size() - pos;
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
+        LIBCPP_ASSERT(is_string_asan_correct(s2));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(str, pos);
             assert(false);
test(S str, unsigned pos, unsigned n)
     {
         S s2(str, pos, n);
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
+        LIBCPP_ASSERT(is_string_asan_correct(s2));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(str, pos, n);
             assert(false);
test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
     {
         S s2(str, pos, n, a);
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
+        LIBCPP_ASSERT(is_string_asan_correct(s2));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(str, pos, n, a);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp

 // basic_string& append(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "nasty_string.h"
-
+#include "asan_testing.h"
 template <class S>
 TEST_CONSTEXPR_CXX20 void test() {
   using CharT = typename S::value_type;
 
   S s(CONVERT_TO_CSTRING(CharT, "123"));
   s.append({CharT('a'), CharT('b'), CharT('c')});
   assert(s == CONVERT_TO_CSTRING(CharT, "123abc"));
+  LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test<std::string>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<std::wstring>();
 #endif
 #if TEST_STD_VER >= 20
   test<std::u8string>();
 #endif
   test<std::u16string>();
   test<std::u32string>();
 
   test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #ifndef TEST_HAS_NO_NASTY_STRING
   test<nasty_string>();
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

 //   basic_string& append(InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
     s.append(first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, It first, It last)

libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp

 // basic_string<charT,traits,Allocator>& append(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.append(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "", S());
   test(S(), "12345", S("12345"));
   test(S(), "12345678901234567890", S("12345678901234567890"));
 

libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp

 //   append(const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.append(str, n);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "", 0, S());
   test(S(), "12345", 3, S("123"));
   test(S(), "12345", 4, S("1234"));
   test(S(), "12345678901234567890", 0, S());

libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp

 // void push_back(charT c) // constexpr since C++20
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 struct VeryLarge {
   long long a;
   char b;
 };
 
 namespace std {
   template <>

 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::value_type c, S expected)
 {
     s.push_back(c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string S;
     test(S(), 'a', S(1, 'a'));
     test(S("12345"), 'a', S("12345a"));
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));

libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   append(size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.append(n, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0, 'a', S());
   test(S(), 1, 'a', S(1, 'a'));
   test(S(), 10, 'a', S(10, 'a'));
   test(S(), 100, 'a', S(100, 'a'));

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   append(const basic_string<charT,traits>& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.append(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), S(), S());
   test(S(), S("12345"), S("12345"));
   test(S(), S("1234567890"), S("1234567890"));
   test(S(), S("12345678901234567890"), S("12345678901234567890"));

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

 //  the "= npos" was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
     {
         s.append(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.append(str, pos, n);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp

 //    basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.assign(sv, pos, n);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp

 
 // basic_string& assign(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string s("123");
     s.assign({'a', 'b', 'c'});
     assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
   {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s("123");
     s.assign({'a', 'b', 'c'});
     assert(s == "abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

 //   basic_string& assign(InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
     s.assign(first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
 void
 test_exceptions(S s, It first, It last)

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp

 // basic_string<charT,traits,Allocator>& assign(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.assign(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "", S());
   test(S(), "12345", S("12345"));
   test(S(), "12345678901234567890", S("12345678901234567890"));
 

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp

 //   assign(const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.assign(str, n);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "", 0, S());
   test(S(), "12345", 3, S("123"));
   test(S(), "12345", 4, S("1234"));
   test(S(), "12345678901234567890", 0, S());

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   assign(size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.assign(n, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0, 'a', S());
   test(S(), 1, 'a', S(1, 'a'));
   test(S(), 10, 'a', S(10, 'a'));
   test(S(), 100, 'a', S(100, 'a'));

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "nasty_string.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test(S dest, S src) {
   dest.assign(src);
   LIBCPP_ASSERT(dest.__invariants());
   assert(dest == src);
+  LIBCPP_ASSERT(is_string_asan_correct(src));
+  LIBCPP_ASSERT(is_string_asan_correct(dest));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 testAlloc(S dest, S src, const typename S::allocator_type& a)
 {
     dest.assign(src);
     LIBCPP_ASSERT(dest.__invariants());

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp

 // the =npos was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
     {
         s.assign(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.assign(str, pos, n);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S str, typename S::value_type* s, typename S::size_type n,
      typename S::size_type pos)
 {
     const S& cs = str;
     if (pos <= cs.size())
     {
         typename S::size_type r = cs.copy(s, n, pos);
         typename S::size_type rlen = std::min(n, cs.size() - pos);
         assert(r == rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(str));
+        LIBCPP_ASSERT(is_string_asan_correct(cs));
+
         for (r = 0; r < rlen; ++r)
             assert(S::traits_type::eq(cs[pos+r], s[r]));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp

 
 // iterator erase(const_iterator p); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, S expected)
 {
     typename S::const_iterator p = s.begin() + pos;
     typename S::iterator i = s.erase(p);
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
     assert(i - s.begin() == pos);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcde"), 0, S("bcde"));
   test(S("abcde"), 1, S("acde"));
   test(S("abcde"), 2, S("abde"));
   test(S("abcde"), 4, S("abcd"));

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp

 
 // iterator erase(const_iterator first, const_iterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, typename S::difference_type n, S expected)
 {
     typename S::const_iterator first = s.cbegin() + pos;
     typename S::const_iterator last = s.cbegin() + pos + n;
     typename S::iterator i = s.erase(first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
     assert(i - s.begin() == pos);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(""), 0, 0, S(""));
   test(S("abcde"), 0, 0, S("abcde"));
   test(S("abcde"), 0, 1, S("bcde"));
   test(S("abcde"), 0, 2, S("cde"));

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.asan.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <string>
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "asan_testing.h"
+
+template <class CharT>
+void test(const CharT val) {
+  using S = std::basic_string<CharT>;
+
+  S s;
+  while (s.size() < 8000) {
+    s.push_back(val);
+
+    LIBCPP_ASSERT(is_string_asan_correct(s));
+  }
+  while (s.size() > 0) {
+    s.pop_back();
+
+    LIBCPP_ASSERT(is_string_asan_correct(s));
+  }
+}
+
+int main(int, char**) {
+  {
+    using CharT = char;
+    test<CharT>('x');
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    using CharT = wchar_t;
+    test<CharT>(L'x');
+  }
+#endif
+#if TEST_STD_VER >= 11
+  {
+    using CharT = char16_t;
+    test<CharT>(u'x');
+  }
+  {
+    using CharT = char32_t;
+    test<CharT>(U'x');
+  }
+#endif
+#if TEST_STD_VER >= 20
+  {
+    using CharT = char8_t;
+    test<CharT>(u8'x');
+  }
+#endif
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp

 
 // void pop_back(); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S expected)
 {
     s.pop_back();
     LIBCPP_ASSERT(s.__invariants());
     assert(s[s.size()] == typename S::value_type());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S("abcde"), S("abcd"));
   test(S("abcdefghij"), S("abcdefghi"));
   test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp

 //   erase(size_type pos = 0, size_type n = npos); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.erase(pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s[s.size()] == typename S::value_type());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.erase(pos, n);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp

 // iterator insert(const_iterator p, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S& s, typename S::const_iterator p, typename S::value_type c, S expected)
 {
+    LIBCPP_ASSERT(is_string_asan_correct(s));
     bool sufficient_cap = s.size() < s.capacity();
     typename S::difference_type pos = p - s.begin();
     typename S::iterator i = s.insert(p, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     assert(i - s.begin() == pos);
     assert(*i == c);
     if (sufficient_cap)
         assert(i == p);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
+
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   S s;
   test(s, s.begin(), '1', S("1"));
   test(s, s.begin(), 'a', S("a1"));
   test(s, s.end(), 'b', S("a1b"));
TEST_CONSTEXPR_CXX20 void test_string() {
   test(s, s.begin()+5, 'B', S("a567AB1432dcb"));
   test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_string<std::string>();
 #if TEST_STD_VER >= 11
   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp

 // iterator insert(const_iterator p, initializer_list<charT> il); // constexpr since C++20
 
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string s("123456");
     std::string::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
     assert(i - s.begin() == 3);
     assert(s == "123abc456");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
   {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s("123456");
     S::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
     assert(i - s.begin() == 3);
     assert(s == "123abc456");
   }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

 //   iterator insert(const_iterator p, InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, It first, It last, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(i - s.begin() == pos);
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, typename S::difference_type pos, It first, It last)

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp

 
 // iterator insert(const_iterator p, size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, typename S::size_type n,
      typename S::value_type c, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
     typename S::iterator i = s.insert(p, n, c);
     LIBCPP_ASSERT(s.__invariants());
     assert(i - s.begin() == pos);
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(""), 0, 0, '1', S(""));
   test(S(""), 0, 5, '1', S("11111"));
   test(S(""), 0, 10, '1', S("1111111111"));
   test(S(""), 0, 20, '1', S("11111111111111111111"));

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp

 //   insert(size_type pos, const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos, str);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

 //   insert(size_type pos, const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos, str, n);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp

 //   insert(size_type pos, size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n,
      typename S::value_type str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, n, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos, n, str);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp

 //   insert(size_type pos1, const basic_string& str); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos, str);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

 // the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos1, str, pos2, n);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp

 
 // basic_string<charT,traits,Allocator>& operator+=(charT c); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::value_type str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string S;
     test(S(), 'a', S("a"));
     test(S("12345"), 'a', S("12345a"));
     test(S("1234567890"), 'a', S("1234567890a"));

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp

 
 // basic_string& operator+=(initializer_list<charT> il); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     std::string s("123");
     s += {'a', 'b', 'c'};
     assert(s == "123abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
   {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s("123");
     s += {'a', 'b', 'c'};
     assert(s == "123abc");
+    LIBCPP_ASSERT(is_string_asan_correct(s));
   }
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp

 
 // basic_string<charT,traits,Allocator>& operator+=(const charT* s); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), "", S());
   test(S(), "12345", S("12345"));
   test(S(), "1234567890", S("1234567890"));
   test(S(), "12345678901234567890", S("12345678901234567890"));

libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   operator+=(const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s += str;
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), S(), S());
   test(S(), S("12345"), S("12345"));
   test(S(), S("1234567890"), S("1234567890"));
   test(S(), S("12345678901234567890"), S("12345678901234567890"));

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp

 //   replace(const_iterator i1, const_iterator i2, const basic_string& str); // constexpr since C++20
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = str.size();
     assert(s.size() == old_size - xlen + rlen);
+    LIBCPP_ASSERT(is_string_asan_correct(s));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, S(""), S(""));
     test(S(""), 0, 0, S("12345"), S("12345"));
     test(S(""), 0, 0, S("1234567890"), S("1234567890"));

 #endif
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
   test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     typedef typename S::size_type SizeT;
     static_assert((!std::is_same<S, SV>::value), "");
 
     // String and string_view may not always share the same size type,
     // but both types should have the same size (ex. int vs long)
     static_assert(sizeof(SizeT) == sizeof(typename SV::size_type), "");
 
     const SizeT old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.replace(pos1, n1, sv, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         SizeT xlen = std::min<SizeT>(n1, old_size - pos1);
         SizeT rlen = std::min<SizeT>(n2, sv.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.replace(pos1, n1, sv, pos2, n2);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.replace(pos, n1, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = S::traits_type::length(str);
         assert(s.size() == old_size - xlen + rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.replace(pos, n1, str);
             assert(false);
#endif
   }
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
   test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.replace(pos, n1, str, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.replace(pos, n1, str, n2);
             assert(false);

 #endif
 }
 
 int main(int, char**)
 {
   test<std::string>();
 #if TEST_STD_VER >= 11
   test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+  test<std::basic_string<char, std::char_traits<char>, safe_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      typename S::size_type n2, typename S::value_type c,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.replace(pos, n1, n2, c);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.replace(pos, n1, n2, c);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
     {
         s.replace(pos1, n1, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = str.size();
         assert(s.size() == old_size - xlen + rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.replace(pos1, n1, str);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      S str, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.replace(pos1, n1, str, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(n2, str.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.replace(pos1, n1, str, pos2, n2);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
     {
         s.replace(pos1, n1, sv);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = sv.size();
         assert(s.size() == old_size - xlen + rlen);
+        LIBCPP_ASSERT(is_string_asan_correct(s));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.replace(pos1, n1, sv);
             assert(false);

libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.asan.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "asan_testing.h"
+
+template <class CharT>
+void test(const CharT val) {
+  using S = std::basic_string<CharT>;
+
+  S empty_s;
+  S short_s(3, val);
+  S long_s(1100, val);
+
+  std::swap(empty_s, empty_s);
+  std::swap(short_s, short_s);
+  std::swap(long_s, long_s);
+  LIBCPP_ASSERT(is_string_asan_correct(empty_s));
+  LIBCPP_ASSERT(is_string_asan_correct(short_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+
+  std::swap(empty_s, short_s);
+  LIBCPP_ASSERT(is_string_asan_correct(empty_s));
+  LIBCPP_ASSERT(is_string_asan_correct(short_s));
+
+  std::swap(empty_s, short_s);
+  LIBCPP_ASSERT(is_string_asan_correct(empty_s));
+  LIBCPP_ASSERT(is_string_asan_correct(short_s));
+
+  std::swap(empty_s, long_s);
+  LIBCPP_ASSERT(is_string_asan_correct(empty_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+
+  std::swap(empty_s, long_s);
+  LIBCPP_ASSERT(is_string_asan_correct(empty_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+
+  std::swap(short_s, long_s);
+  LIBCPP_ASSERT(is_string_asan_correct(short_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+
+  std::swap(short_s, long_s);
+  LIBCPP_ASSERT(is_string_asan_correct(short_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+
+  S long_s2(11100, val);
+
+  std::swap(long_s, long_s2);
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s2));
+
+  std::swap(long_s, long_s2);
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s2));
+
+  S long_s3(111, val);
+
+  std::swap(long_s, long_s3);
+  LIBCPP_ASSERT(is_string_asan_correct(long_s));
+  LIBCPP_ASSERT(is_string_asan_correct(long_s2));
+}
+
+int main(int, char**) {
+  {
+    using CharT = char;
+    test<CharT>('x');
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    using CharT = wchar_t;
+    test<CharT>(L'x');
+  }
+#endif
+#if TEST_STD_VER >= 11
+  {
+    using CharT = char16_t;
+    test<CharT>(u'x');
+  }
+  {
+    using CharT = char32_t ;
+    test<CharT>(U'x');
+  }
+#endif
+#if TEST_STD_VER >= 20
+  {
+    using CharT = char8_t;
+    test<CharT>(u8'x');
+  }
+#endif
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s1_ = s1;
     S s2_ = s2;
     s1.swap(s2);
     LIBCPP_ASSERT(s1.__invariants());
     LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s2_);
     assert(s2 == s1_);
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(""), S(""));
   test(S(""), S("12345"));
   test(S(""), S("1234567890"));
   test(S(""), S("12345678901234567890"));

libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s1_ = s1;
     S s2_ = s2;
     swap(s1, s2);
     LIBCPP_ASSERT(s1.__invariants());
     LIBCPP_ASSERT(s2.__invariants());
     assert(s1 == s2_);
     assert(s2 == s1_);
+    LIBCPP_ASSERT(is_string_asan_correct(s1));
+    LIBCPP_ASSERT(is_string_asan_correct(s2));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string S;
     test(S(""), S(""));
     test(S(""), S("12345"));
     test(S(""), S("1234567890"));

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp

 //   operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(typename S::value_type lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
+  LIBCPP_ASSERT(is_string_asan_correct(lhs + rhs));
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(typename S::value_type lhs, S&& rhs, const S& x) {
   assert(lhs + std::move(rhs) == x);
 }
 #endif

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp

 //   operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(const S& lhs, typename S::value_type rhs, const S& x) {
   assert(lhs + rhs == x);
+  LIBCPP_ASSERT(is_string_asan_correct(lhs + rhs));
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(S&& lhs, typename S::value_type rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
 #endif

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp

 //   operator+(basic_string<charT,traits,Allocator>&& lhs, const charT* rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const typename S::value_type* rhs, const S& x) {
   assert(lhs + rhs == x);
+  LIBCPP_ASSERT(is_string_asan_correct(lhs + rhs));
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
 #endif

libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp

 //             const basic_string<charT,traits,Allocator>&& rhs); // constexpr since C++20
 
 #include <string>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
+#include "asan_testing.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
+  LIBCPP_ASSERT(is_string_asan_correct(lhs + rhs));
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
 TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const S& rhs, const S& x) {
   assert(std::move(lhs) + rhs == x);
 }
 

libcxx/test/support/asan_testing.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ASAN_TESTING_H
 #define ASAN_TESTING_H
 
 #include "test_macros.h"
 
 #if TEST_HAS_FEATURE(address_sanitizer)
-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);
 
 template <typename T, typename Alloc>
-TEST_CONSTEXPR bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &c )
-{
-    if (std::__libcpp_is_constant_evaluated())
-        return true;
-    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;
+TEST_CONSTEXPR bool is_contiguous_container_asan_correct(const std::vector<T, Alloc>& c) {
+  if (TEST_IS_CONSTANT_EVALUATED)
+    return __sanitizer_verify_contiguous_container(c.data(), c.data() + c.size(), c.data() + c.capacity()) != 0;
 }
-
 #else
 template <typename T, typename Alloc>
-TEST_CONSTEXPR bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &)
-{
-    return true;
+TEST_CONSTEXPR bool is_contiguous_container_asan_correct(const std::vector<T, Alloc>&) {
 }
 #endif
 
+#if TEST_HAS_FEATURE(address_sanitizer)
+#  include <string>
+#  include <memory>
+template <typename S>
+bool is_string_short(S const& s) {
+  // We do not have access to __is_long(), but we can check if strings
+  // buffer is inside strings memory. If strings memory contains its content,
+  // SSO is in use. To check it, we can just confirm that the beginning is in
+  // the string object memory block.
+  // &s    - beginning of objects memory
+  // &s[0] - beginning of the buffer
+  // (&s+1) - end of objects memory
+  return (void*)std::addressof(s) <= (void*)std::addressof(s[0]) &&
+    (void*)std::addressof(s[0]) < (void*)(std::addressof(s) + 1);
+}
 
+template <typename ChrT, typename TraitsT, typename Alloc>
+TEST_CONSTEXPR bool is_string_asan_correct(const std::basic_string<ChrT, TraitsT, Alloc>& c) {
+  if (TEST_IS_CONSTANT_EVALUATED)
+    return true;
+  if (c.data() != NULL) {
+#if TEST_CLANG_VER < 16000
+    // TODO LLVM18: remove special case
+  if(!is_string_short(c))
+#endif
+    return __sanitizer_verify_contiguous_container(c.data(), c.data() + c.size() + 1, c.data() + c.capacity() + 1) != 0;
+  }
+  return true;
+}
+#else
+#  include <string>
+template <typename ChrT, typename TraitsT, typename Alloc>
+TEST_CONSTEXPR bool is_string_asan_correct(const std::basic_string<ChrT, TraitsT, Alloc>&) {
+  return true;
+}
+#endif // TEST_HAS_FEATURE(address_sanitizer)
 #endif // ASAN_TESTING_H