[2a/3][ASan][libcxx] std::deque 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 introduces annotations for std::deque. Each chunk of the container can now be annotated using the __sanitizer_annotate_double_ended_contiguous_container function, which was added in the rG1c5ad6d2c01294a0decde43a88e9c27d7437d157. Any attempt to access poisoned memory will trigger an ASan error. Although false negatives are rare, they are possible due to limitations in the ASan API, where a few (usually up to 7) bytes before the container may remain unpoisoned. There are no false positives in the same way as with std::vector annotations.

This patch only supports objects (deques) that use the standard allocator. However, it can be easily extended to support all allocators, as suggested in the D146815 revision.

Furthermore, the patch includes the addition of the is_double_ended_contiguous_container_asan_correct function to libcxx/test/support/asan_testing.h. This function can be used to verify whether a std::deque object has been correctly annotated.

Finally, the patch extends the unit tests to verify ASan annotations (added LIBCPP_ASSERTs).
If a program is compiled without ASan, all helper functions will be no-ops. In binaries with ASan, there is a negligible performance impact since the code from the change is only executed when the deque container changes in size and it’s proportional to the change. It is important to note that regardless of whether or not these changes are in use, every access to the container's memory is instrumented.

If you have any questions, please email:

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

[philnik]

libcxx/include/deque

1023

The same through out.

1216

Every implementation-detail symbol should either be _Uglified or __uglified, but never __Uglified.

1275

Please add an end comment to longer preprocessor blocks.

[AdvenamTacet]

The udpate is fixing issues mentioned in the code review.
Content:

• fixed formating,
• use of _LIBCPP_HIDE_FROM_ABI,
• names and style improvements.

[AdvenamTacet]

This update should fix failing unit tests and improve code quality.
Content:

• Fixed includes (thx philnik for pointing that)
• Improved variable names (more consistent)
• Values passed to compiler-rt functions are correct now. (There

was an optimization depending on compiler-rt implementation, now
it should be correct even when implementation is extended.)

Overall, it's a very small update.

[AdvenamTacet]

Duplicated file removed.

[AdvenamTacet]

This update should fix failure of C++03 tests and a format check test.

[AdvenamTacet]

This update adds clang version check (_LIBCPP_CLANG_VER >= 16000),
because the change requires compiler-rt functions from a parent revision.

As a result, it changes implementation of libcxx/test/support/asan_testing.h.

It also removes a comment fix in compiler-rt function. I will add it to
the parent revision (D132090).

[AdvenamTacet]

Changin _de_ in names into _double_ended_, based on a review for compiler-rt part.
There will be one more change based on the review.

[AdvenamTacet]

clang-format (sorry for double update)

[AdvenamTacet]

Update of API. (A change was requested in review for D132090 and this
patch is reflecting that change - only one function is in API.)

[AdvenamTacet]

Moving libc++ code from D132090.

[AdvenamTacet]

I'm sending this update to test annotations with CI.
Updated changes to newer commit.
When I see green CI, I will send an update unifying those changes with D136765 and D132769, as well as minimizing code.

[AdvenamTacet]

Tests update, code refactor in next update.

[AdvenamTacet]

This update is a big refactor of code responsible for annotations.
This update reduced size of the patch significantly.
There are only two helper function (one wrapper), both are minimal.

I added a lot of comment to the (new) code, if you want a smaller patch those comments may be removed, but I think it's good to have them.

I belive, the code is ready for a review. I tested it locally (but only with one C++ standard, so there may be some failure, I will fix it asap).

[AdvenamTacet]

This update:

• removes incorrect extern,
• fixes a typo,
• adds sanity ASan test (not tested).

[AdvenamTacet]

This update:

• removed unnecessary macro and related limitations,
• updates formatting in __annotate_from_to,
• simplifies calls to helpers in __add_front_capacity.

[philnik]

Looks pretty good. I haven't looked closely at the annotation placements and tests yet.

libcxx/include/deque

586–588

Same below.

1219

As in other patches, let's give the parameters proper names.

1225

1233

Please don't add a 10th version of formatting. We are trying to reduce the formatting differences, not increase them.

1235

You have specialized functions for there IIUC. Why don't you use them here? There are a few more cases below.

1252

throughout the patch

1331

Missing _LIBCPP_HIDE_FROM_ABI

1336

Please add braces.

2297

Please avoid NFC changes in such a large patch.

2397–2405

Maybe add a function __annotate_whole_block?

libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp

92–99

Maybe just call both in the same loop?

[AdvenamTacet]

Based on the code review, this update:

• adds __annotate_whole_block and __annotate_poison_block helpers,
• updates arguements and variables names in __annotate_from_to and __verify_asan_annotations,
• changes _VSTD to std,
• adds missing _LIBCPP_HIDE_FROM_ABI,
• removes NFC,
• fixes formatting and comments.

[AdvenamTacet]

libcxx/include/deque

1219

I changed __b and __e to __beg and __end. I believe same length makes the code easier to read. Updated also local variable names.

1235

There was no helper for a single block and use of __annotate_shrink_* is impossible as it requires annotated memory area to be just before or just after the container in-use area, but new block may be added not directly before/after. I added __annotate_whole_block.

2397–2405

I added __annotate_poison_block for this. It's not very similar to other helpers, because here we are annotating a memory block in __buf and not in __map_.

libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp

92–99

I started doing it, but stopped. I don't think it's a good idea to introduce that change in this patch. There is already a lot of copy-paste of tests, so it would require to refactor all of them or have two different styles in one file.

[philnik]

libcxx/include/deque

964

Let's add a LLVM 18 TODO to clean this up.

982

Maybe having two enums like

enum {
  __asan_poinson,
  __asan_unposion
};

enum {
  __asan_front_moved,
  __asan_back_moved,
};

would make this more readable? (and remove the need for the comments below)

989

I think it's pretty clear what a return; does.

994

Maybe use __map_const_pointer?

995

What does the mp stand for?

1085–1089

I would reverse the condition here to match __annotate_new.

2397–2405

Ah. Makes sense.

2550

[AdvenamTacet]

This update:

• adds enums (poisoning, unpoisoning; back, front)
• adds LLVM 18 TODO comment; improves other comments
• reverses the condition in __annotate_delete.

[AdvenamTacet]

libcxx/include/deque

994

I did try it at the beginning and there are type related issues. It's much cleaner that way than working around it.

995

I believe map_pointer, but I used this name based on the rest of the code where it's used.

[AdvenamTacet]

This update updates a base commit.

[philnik]

LGTM % nits.

libcxx/include/deque

994

Let's adda new alias __map_const_iterator then. The typename __map::const_iterator is really irritating.

995

Let's drop it if nobody knows what it actually stands for.

1136–1138

I think this comment is wrong now?

[AdvenamTacet]

This update addresses all nits.

• Adds __map_const_iterator.
• Removes incorrect comments.
• Addresses _mp sufix.

libcxx/include/deque

995

I changed it to map, I feel that it makes code much easier to read when it is clear if it points on the map (buffer of buffers) or the actual buffer. Hope it's clear now.

[AdvenamTacet]

This update fixes an issue with name shadowing and hopefully resolves all CI problems.

[vitalybuka]

Asan bots are broken, reverted.

[philnik]

In D132092#4323869, @vitalybuka wrote:

Asan bots are broken, reverted.

Could you maybe provide some more information? Which bots were broken by this and what was the error? Without any information we can't address the problem.

[AdvenamTacet]

It looks like the problem was created when I added __annotate_whole_block. Example buildbot output relevant for this revision: https://lab.llvm.org/buildbot/#/builders/5/builds/33480/steps/13/logs/stdio

==296484==ERROR: AddressSanitizer: bad parameters to __sanitizer_annotate_double_ended_contiguous_container:
      storage_beg        : 0x6210000d0d00
      storage_end        : 0x6210000d1d00
      old_container_beg  : 0x6210000d1b40
      old_container_end  : 0x6210000d1d00
      new_container_beg  : 0x6210000d1b40
      new_container_end  : 0x6210000d0d00
    #0 0x56178e14cac5 in __sanitizer_annotate_double_ended_contiguous_container /b/sanitizer-x86_64-linux-fast/build/llvm-project/compiler-rt/lib/asan/asan_poisoning.cpp:499:5
    #1 0x56178efd3474 in __annotate_double_ended_contiguous_container /b/sanitizer-x86_64-linux-fast/build/libcxx_build_asan/include/c++/v1/deque:893:13
    #2 0x56178efd3474 in __annotate_from_to /b/sanitizer-x86_64-linux-fast/build/libcxx_build_asan/include/c++/v1/deque:991:13
    #3 0x56178efd3474 in __annotate_whole_block /b/sanitizer-x86_64-linux-fast/build/libcxx_build_asan/include/c++/v1/deque:1037:9
    #4 0x56178efd3474 in std::__1::deque<std::__1::pair<std::__1::function<void ()>, llvm::ThreadPoolTaskGroup*>, std::__1::allocator<std::__1::pair<std::__1::function<void ()>, llvm::ThreadPoolTaskGroup*>>>::__add_back_capacity() /b/sanitizer-x86_64-linux-fast/build/libcxx_build_asan/include/c++/v1/deque:2233:13
    #5 0x56178efd1aaf in std::__1::pair<std::__1::function<void ()>, llvm::ThreadPoolTaskGroup*>& std::__1::deque<std::__1::pair<std::__1::function<void ()>, llvm::ThreadPoolTaskGroup*>, std::__1::allocator<std::__1::pair<std::__1::function<void ()>, llvm::ThreadPoolTaskGroup*>>>::emplace_back<std::__1::pair<std::__1::function<void ()>, llvm::ThreadPoolTaskGroup*>>(std::__1::pair<std::__1::function<void ()>, llvm::ThreadPoolTaskGroup*>&&) /b/sanitizer-x86_64-linux-fast/build/libcxx_build_asan/include/c++/v1/deque:1596:9
    [...]

All errors I could find seem to have an origin in __add_back_capacity and I'm almost sure that I see a problem in the function.

I am trying to create unit test catching it and then I will send the next update with fix and tests.

[AdvenamTacet]

I have a hard time trying to create a stand alone test.
To go to the problematic if branch, push_back should be called when:

• __back_spare() == 0
• __front_spare() < __block_size
• __map_.size() < __map_.capacity()
• __map_.__back_spare() == 0

The problem is incorrect value argument to a helper function __annotate_whole_block, but actually there is no need to call this function yet (it can be called later after whole if-else block). It's easy to see what is wrong and how to fix it. I have a hard time creating a unit test covering it.

[AdvenamTacet]

This update fixes the issue with incorrect arguments during deque annotations. Now the patch should work without a problem after landing.

[AdvenamTacet]

This update resolves merge conflicts with the new head commin on the main branch.

I believe, this revision is ready to land.

[alexfh]

Hi @AdvenamTacet, is it expected that the std::deque<const T> can't be compiled after the patch? I couldn't find a clause in the standard that requires deque to have non-const value_type.

Example: https://gcc.godbolt.org/z/sbcvzzbKd

#include <deque>

std::deque<const int> q;
std::deque<const int> qq = q;

[alexfh]

@ldionne @EricWF do you know if std::deque<const T> is allowed by the standard? If it's not, can we have a proper static assert (similar to the one in libstdc++: https://gcc.godbolt.org/z/jjzbP3bd4) instead of a vague compiler error?

[AdvenamTacet]

@alexfh it's not by design. A const_cast is missing (or should I use (void *)?). We may add it in the very place where error happens or later before calling API, but type has to be changed here.

Working on the fix right now.

• I am going to add a const deque test.
• Add the const_cast, I believe it's the correct choice.

[AdvenamTacet]

Ok, I just learned that deque objects have to be assignable/movable, so std::deque<const int> is not correct (from what I understand). Therefore tests for it cannot exist. But it's not my intention to change behavior of std::deque<const T> and therefore I created D151777. The new patch adds a few const. All examples working previously seem to work with D151777, but I found some not working even before this patch.

As - if I'm correct - deque object cannot be of const type, I think I did as much as I could.

[eaeltsin]

It looks like std::deque elements do not need to be copy assignable since C++11 (https://en.cppreference.com/w/cpp/container/deque).

Though it says member functions can impose stricter requirements - I'm not sure if there is a member that still requires copy assignable

[vitalybuka]

D151836 triggers asserts

[vitalybuka]

I believe it's reasonable to revert for investigation.

[vitalybuka]

Sorry that I had to revert this second time. This one discovered a lot of real bugs in our code.
Please include D151836 or similar test into the patch?

[AdvenamTacet]

This update (hopefully) brings back old behavior of deque with const elements.

To understand the problem better, I tried to create tests for deque with const elements, but those are failing even in functions that might work. It seems like resize is failing, but it should be possible to make it work changing iterator to const_iterator (didn't test it, tho).
https://godbolt.org/z/qfxTW7aK7

Hey @alexfh, I hope this will solve your problem!
But deque<const T> seems to be poorly supported in general.

PS
MinGW prints:

std::deque must have a non-const, non-volatile value_type

https://godbolt.org/z/zerMG7GTf

[AdvenamTacet]

This update:

• adds a test suggested by @vitalybuka (extended to do that kind of caterpillar from every side),
• removes the issue,
• reimplementes __annotate_whole_block (last arguments removed; no longer calling __annotate_from_to).

The problem was a very similar to the previous one. Incorrect last argument (argument informing if end or begin of the container moved). It wasn't easy to spot, even that now it's obvious.
I was checking for issues like that previously but I had to miss that one. However, the argument doesn't have much sense, whole block has to be annotated anyway and it's not always obvious what value should be passed in some situations. I reimplemented problematic function, so it does not require the argument. Hope it will help to avoid similar issues in future.

I believe it's ready to land again, as both probles are solved (const element type bahaviour and incorrect annotations), a new test is added and tests passed (locally).

[AdvenamTacet]

This update changes how __annotate_delete() for an empty container is executed and makrs two functions as const.
It solves issues with non-standard allocators.

Now it's tested with D146815 and both revisions can land.

[AdvenamTacet]

This update renames the new test and updates it slightly.

[AdvenamTacet]

Hey @vitalybuka, thanks for the standalone failing test (D151836)! It was really helpful! I fixed the problem and hope there are no more issues with that revision (and for no more reverts).

This one discovered a lot of real bugs in our code.

I'm really happy that my code could help!

Hey @philnik, I hope I fixed the patch already and it can go back to upstream, for good this time. Also, D136765 wasn't reverted for a while already, so maybe we can land D146815 as well?

[AdvenamTacet]

This update fixes a naming issue.

[AdvenamTacet]

rebase, I hope it fixes the CI fail (doesn't look like issue made by this revision).

[AdvenamTacet]

Rebase, I hope it will fix the issue with the fail on MacOS.

ld: warning: object file (/Users/libcxx-buildkite-agent/libcxx.buildkite-agent/builds/y10-8-macminivault-com/llvm-project/libcxx-ci/build/apple-system-backdeployment-10.15/lib/libc++experimental.a(memory_resource.cpp.o)) was built for newer macOS version (12.0) than being linked (10.15)
ld: warning: dylib (/Users/libcxx-buildkite-agent/libcxx.buildkite-agent/builds/y10-8-macminivault-com/llvm-project/libcxx-ci/build/apple-system-backdeployment-10.15/lib/libc++.dylib) was built for newer macOS version (12.0) than being linked (10.15)
ld: warning: dylib (/Users/libcxx-buildkite-agent/libcxx.buildkite-agent/builds/y10-8-macminivault-com/llvm-project/libcxx-ci/build/apple-system-backdeployment-10.15/lib/libunwind.dylib) was built for newer macOS version (12.0) than being linked (10.15)
ld: warning: dylib (/Users/libcxx-buildkite-agent/libcxx.buildkite-agent/builds/y10-8-macminivault-com/llvm-project/libcxx-ci/build/apple-system-backdeployment-10.15/lib/libunwind.dylib) was built for newer macOS version (12.0) than being linked (10.15)

[AdvenamTacet]

This update:

• removes XFAIL as the test should always pass,
• removes _LIBCPP_ENABLE_ASSERTIONS=1 because ASan assertions are catched anyway.

I copt-pasted those, but there is no need for them, I believe.

[AdvenamTacet]

Rebase.

[AdvenamTacet]

Updating libcxx/include/__config in response to _LIBCPP_FUNC_VIS removal.

Used: _LIBCPP_EXPORTED_FROM_ABI

[AdvenamTacet]

rebase

[AdvenamTacet]

Rebase.

[AdvenamTacet]

I hope I fixed everything requested, cannot find anything else to fix. I hope this time it landed for the last time...
I see buildbot failures, but I don't see how my patch may be the cause (one, two).

This one discovered a lot of real bugs in our code.

Hey @vitalybuka, could you share a little bit more? Like statistics, in what projects, how those bugs look like, was there any more interesting? I will appreciate any and every data which we can use!

[vitalybuka]

In D132092#4451255, @AdvenamTacet wrote:

I hope I fixed everything requested, cannot find anything else to fix. I hope this time it landed for the last time...
I see buildbot failures, but I don't see how my patch may be the cause (one, two).

This one discovered a lot of real bugs in our code.

Hey @vitalybuka, could you share a little bit more? Like statistics, in what projects, how those bugs look like, was there any more interesting? I will appreciate any and every data which we can use!

I have number of bugs we had to fix after the first attempt to integrate, but, I guess, it's meaningless on it's own, without any baseline.
From my experience of enabling https://libcxx.llvm.org/UsingLibcxx.html#enabling-the-safe-libc-mode on the same code-base, my very rough estimate is that your patch fetched at least 10% of additional bugs to the "safe libc++ mode".

Unfortunately all discoveries so far are in internal code, nothing to share from open sourced components yet. Maybe chromium.org or https://github.com/google/oss-fuzz will find bugs in open source libraries. But they didn't integrated the patch yet.

At least 90% of these bugs look like https://godbolt.org/z/eGddPd3qs or std::stack equivalent. Note that for large 'n' you can already expect SEGV or 'heap-use-after-free' with existing Asan. But smaller 'n' was not covered before your patches.

Also very good news that fixing those bugs very easy, either remove the reference or swap use and pop(). This mean fix rate for discovered bugs should be very high.

BTW. This pattern is quote similar to typical implementations work-lists, BFS and DFS algorithms. We have them in LLVM. We run LLVM under Asan here https://lab.llvm.org/buildbot/#/builders/168, but I didn't see any related reports.

[ldionne]

libcxx/include/__config

907

This breaks on AppleClang when using asan, because then _LIBCPP_CLANG_VER isn't defined and we check for _LIBCPP_CLANG_VER >= 1600. That triggers -Wundef, which is turned into an error in our test suite.

[ldionne]

libcxx/include/deque

974

Same here for -Wundef.

[AdvenamTacet]

libcxx/include/__config

907

Hey! What is the correct way of checking the version then?

Also, can I fix it in another commit, or should we revert the whole commit, fix it and land it again?

libcxx/include/__config

 #    define _LIBCPP_NO_DESTROY __attribute__((__no_destroy__))
 #  else
 #    define _LIBCPP_NO_DESTROY
 #  endif
 
 #  ifndef _LIBCPP_HAS_NO_ASAN
     extern "C" _LIBCPP_FUNC_VIS void
     __sanitizer_annotate_contiguous_container(const void*, const void*, const void*, const void*);
+#    if _LIBCPP_CLANG_VER >= 1600
+extern "C" _LIBCPP_FUNC_VIS void __sanitizer_annotate_double_ended_contiguous_container(
+    const void*, const void*, const void*, const void*, const void*, const void*);
+extern "C" _LIBCPP_FUNC_VIS int
+__sanitizer_verify_double_ended_contiguous_container(const void*, const void*, const void*, const void*);
+#    endif
 #  endif
 
 // Try to find out if RTTI is disabled.
 #  if !defined(__cpp_rtti) || __cpp_rtti < 199711L
 #    define _LIBCPP_HAS_NO_RTTI
 #  endif
 
 #  ifndef _LIBCPP_WEAK

libcxx/include/deque

template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
           class _DiffType, _DiffType _BlockSize>
 const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer,
                                  _DiffType, _BlockSize>::__block_size =
     __deque_block_size<_ValueType, _DiffType>::value;
 
 template <class _Tp, class _Allocator /*= allocator<_Tp>*/>
 class _LIBCPP_TEMPLATE_VIS deque
 {
+private:
+  using __default_allocator_type = allocator<_Tp>;
+
 public:
     // types:
 
   using value_type = _Tp;
 
   static_assert((is_same<typename _Allocator::value_type, value_type>::value),
                 "Allocator::value_type must be same type as value_type");
 
   using allocator_type = _Allocator;
   using __alloc_traits = allocator_traits<allocator_type>;
 
   using size_type       = typename __alloc_traits::size_type;
   using difference_type = typename __alloc_traits::difference_type;
 
   using pointer       = typename __alloc_traits::pointer;
   using const_pointer = typename __alloc_traits::const_pointer;
 
   using __pointer_allocator       = __rebind_alloc<__alloc_traits, pointer>;
   using __const_pointer_allocator = __rebind_alloc<__alloc_traits, const_pointer>;
   using __map                     = __split_buffer<pointer, __pointer_allocator>;
   using __map_alloc_traits        = allocator_traits<__pointer_allocator>;
   using __map_pointer             = typename __map_alloc_traits::pointer;
   using __map_const_pointer       = typename allocator_traits<__const_pointer_allocator>::const_pointer;
+  using __map_const_iterator      = typename __map::const_iterator;
 
   using reference       = value_type&;
   using const_reference = const value_type&;
 
   using iterator = __deque_iterator<value_type, pointer, reference, __map_pointer, difference_type>;
   using const_iterator =
       __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer, difference_type>;
   using reverse_iterator       = std::reverse_iterator<iterator>;
private:
 
   static const difference_type __block_size;
 
   __map __map_;
   size_type __start_;
   __compressed_pair<size_type, allocator_type> __size_;
 
 public:
 
     // construct/copy/destroy:
     _LIBCPP_HIDE_FROM_ABI
     deque() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-        : __start_(0), __size_(0, __default_init_tag()) {}
+        : __start_(0), __size_(0, __default_init_tag()) {
+      __annotate_new(0);
+    }
 
     _LIBCPP_HIDE_FROM_ABI ~deque() {
       clear();
+      __annotate_delete();
       typename __map::iterator __i = __map_.begin();
       typename __map::iterator __e = __map_.end();
       for (; __i != __e; ++__i)
           __alloc_traits::deallocate(__alloc(), *__i, __block_size);
     }
 
     _LIBCPP_HIDE_FROM_ABI explicit deque(const allocator_type& __a)
-        : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {}
+        : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+      __annotate_new(0);
+    }
 
     explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n);
 #if _LIBCPP_STD_VER >= 14
     explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const _Allocator& __a);
 #endif
     _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v);
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
     _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a)
         : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
     {
+        __annotate_new(0);
         if (__n > 0)
             __append(__n, __v);
     }
 
     template <class _InputIter>
     _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l,
               typename enable_if<__has_input_iterator_category<_InputIter>::value>::type* = 0);
     template <class _InputIter>
#endif
     void clear() _NOEXCEPT;
 
     _LIBCPP_HIDE_FROM_ABI
     bool __invariants() const {
         if (!__map_.__invariants())
             return false;
         if (__map_.size() >= size_type(-1) / __block_size)
             return false;
-        for (typename __map::const_iterator __i = __map_.begin(), __e = __map_.end();
+        for (__map_const_iterator __i = __map_.begin(), __e = __map_.end();
             __i != __e; ++__i)
             if (*__i == nullptr)
                 return false;
         if (__map_.size() != 0)
         {
             if (size() >= __map_.size() * __block_size)
                 return false;
             if (__start_ >= __map_.size() * __block_size - size())
size_type __back_spare() const
         return __capacity() - (__start_ + size());
     }
     _LIBCPP_HIDE_FROM_ABI
     size_type __back_spare_blocks() const {
       return __back_spare() / __block_size;
     }
 
  private:
+   enum __asan_annotation_type {
+     __asan_unposion,
+     __asan_poison
+   };
+
+   enum __asan_annotation_place {
+     __asan_front_moved,
+     __asan_back_moved,
+   };
+
+// The following functions are no-ops outside of AddressSanitizer mode.
+// We call annotations only for the default Allocator.
+#if !defined(_LIBCPP_HAS_NO_ASAN) && _LIBCPP_CLANG_VER >= 1600
+    // TODO LLVM18: Remove the special-casing
+    _LIBCPP_HIDE_FROM_ABI void __annotate_double_ended_contiguous_container(
+        const void* __beg,
+        const void* __end,
+        const void* __old_con_beg,
+        const void* __old_con_end,
+        const void* __new_con_beg,
+        const void* __new_con_end) const {
+        if (__beg && is_same<allocator_type, __default_allocator_type>::value)
+            __sanitizer_annotate_double_ended_contiguous_container(
+                __beg, __end, __old_con_beg, __old_con_end, __new_con_beg, __new_con_end);
+    }
+#else
+    _LIBCPP_HIDE_FROM_ABI void __annotate_double_ended_contiguous_container(
+        const void*, const void*, const void*, const void*, const void*, const void*) const _NOEXCEPT {}
+#endif // !defined(_LIBCPP_HAS_NO_ASAN) && _LIBCPP_CLANG_VER >= 1600
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_from_to(size_type __beg, size_type __end, __asan_annotation_type __annotation_type, __asan_annotation_place __place) const _NOEXCEPT {
+        // __beg - index of the first item to annotate
+        // __end - index behind the last item to annotate (so last item + 1)
+        // __annotation_type - __asan_unposion or __asan_poison
+        // __place - __asan_front_moved or __asan_back_moved
+        // Note: All indexes in __map_
+        if (__beg == __end)
+            return;
+        // __annotations_beg_map - first chunk which annotations we want to modify
+        // __annotations_end_map - last chunk which annotations we want to modify
+        // NOTE: if __end % __block_size == 0, __annotations_end_map points at the next block, which may not exist
+        __map_const_iterator __annotations_beg_map = __map_.begin() + __beg / __block_size;
+        __map_const_iterator __annotations_end_map = __map_.begin() + __end / __block_size;
+
+        bool const __poisoning = __annotation_type == __asan_poison;
+        // __old_c_beg_index - index of the first element in old container
+        // __old_c_end_index - index of the end of old container (last + 1)
+        // Note: may be outside the area we are annotating
+        size_t __old_c_beg_index = (__poisoning && __place == __asan_front_moved) ? __beg : __start_;
+        size_t __old_c_end_index = (__poisoning && __place == __asan_back_moved)  ? __end : __start_ + size();
+        bool const __front = __place == __asan_front_moved;
+
+        if (__poisoning && empty()) {
+            // Special case: we shouldn't trust __start_
+            __old_c_beg_index = __beg;
+            __old_c_end_index = __end;
+        }
+        // __old_c_beg_map - memory block (chunk) with first element
+        // __old_c_end_map - memory block (chunk) with end of old container
+        // Note: if __old_c_end_index % __block_size == 0, __old_c_end_map points at the next block,
+        // which may not exist
+        __map_const_iterator __old_c_beg_map = __map_.begin() + __old_c_beg_index / __block_size;
+        __map_const_iterator __old_c_end_map = __map_.begin() + __old_c_end_index / __block_size;
+
+        // One edge (front/end) of the container was moved and one was not modified.
+        // __new_edge_index - index of new edge
+        // __new_edge_map    - memory block (chunk) with new edge, it always equals to
+        //                    __annotations_beg_map or __annotations_end_map
+        // __old_edge_map    - memory block (chunk) with old edge, it always equals to
+        //                    __old_c_beg_map or __old_c_end_map
+        size_t __new_edge_index                      = (__poisoning ^ __front) ? __beg : __end;
+        __map_const_iterator __new_edge_map = __map_.begin() + __new_edge_index / __block_size;
+        __map_const_iterator __old_edge_map = __front ? __old_c_end_map : __old_c_beg_map;
+
+        // We iterate over map pointers (chunks) and fully poison all memory blocks between the first and the last.
+        // First and last chunk may be partially poisoned.
+        // __annotate_end_map may point at not existing chunk, therefore we have to have a check for it.
+        for (__map_const_iterator __map_it = __annotations_beg_map; __map_it <= __annotations_end_map; ++__map_it) {
+            if (__map_it == __annotations_end_map && __end % __block_size == 0)
+                // Chunk may not exist, but nothing to do here anyway
+                break;
+
+            // The beginning and the end of the current memory block
+            const void* __mem_beg = std::__to_address(*__map_it);
+            const void* __mem_end = std::__to_address(*__map_it + __block_size);
+
+            // The beginning of memory-in-use in the memory block before container modification
+            const void* __old_beg =
+                (__map_it == __old_c_beg_map) ? std::__to_address(*__map_it + (__old_c_beg_index % __block_size)) : __mem_beg;
+
+            // The end of memory-in-use in the memory block before container modification
+            const void* __old_end;
+            if (__map_it < __old_c_beg_map || __map_it > __old_c_end_map || (!__poisoning && empty()))
+                __old_end = __old_beg;
+            else
+                __old_end = (__map_it == __old_c_end_map) ? std::__to_address(*__map_it + (__old_c_end_index % __block_size))
+                                                   : __mem_end;
+
+            // New edge of the container in current memory block
+            // If the edge is in a different chunk it points on corresponding end of the memory block
+            const void* __new_edge;
+            if (__map_it == __new_edge_map)
+                __new_edge = std::__to_address(*__map_it + (__new_edge_index % __block_size));
+            else
+                __new_edge = (__poisoning ^ __front) ? __mem_beg : __mem_end;
+
+            // Not modified edge of the container
+            // If the edge is in a different chunk it points on corresponding end of the memory block
+            const void* __old_edge;
+            if (__map_it == __old_edge_map)
+                __old_edge = __front ? __old_end : __old_beg;
+            else
+                __old_edge = __front ? __mem_end : __mem_beg;
+
+            // __new_beg - the beginning of memory-in-use in the memory block after container modification
+            // __new_end - the end of memory-in-use in the memory block after container modification
+            const void* __new_beg = __front ? __new_edge : __old_edge;
+            const void* __new_end = __front ? __old_edge : __new_edge;
+
+            __annotate_double_ended_contiguous_container(__mem_beg, __mem_end, __old_beg, __old_end, __new_beg, __new_end);
+        }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_new(size_type __current_size) const _NOEXCEPT {
+        if (__current_size == 0)
+            __annotate_from_to(0, __map_.size() * __block_size, __asan_poison, __asan_back_moved);
+        else {
+            __annotate_from_to(0, __start_, __asan_poison, __asan_front_moved);
+            __annotate_from_to(__start_ + __current_size, __map_.size() * __block_size, __asan_poison, __asan_back_moved);
+        }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_delete() const _NOEXCEPT {
+        if (empty()) {
+            for(size_t __i = 0; __i < __map_.size(); ++__i) {
+                __annotate_whole_block(__i, __asan_unposion);
+            }
+        }
+        else {
+            __annotate_from_to(0, __start_, __asan_unposion, __asan_front_moved);
+            __annotate_from_to(__start_ + size(), __map_.size() * __block_size, __asan_unposion, __asan_back_moved);
+        }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_increase_front(size_type __n) const _NOEXCEPT {
+        __annotate_from_to(__start_ - __n, __start_, __asan_unposion, __asan_front_moved);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_increase_back(size_type __n) const _NOEXCEPT {
+        __annotate_from_to(__start_ + size(), __start_ + size() + __n, __asan_unposion, __asan_back_moved);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_shrink_front(size_type __old_size, size_type __old_start) const _NOEXCEPT {
+        __annotate_from_to(__old_start, __old_start + (__old_size - size()), __asan_poison, __asan_front_moved);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_shrink_back(size_type __old_size, size_type __old_start) const _NOEXCEPT {
+        __annotate_from_to(__old_start + size(), __old_start + __old_size, __asan_poison, __asan_back_moved);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_poison_block(const void *__beginning, const void *__end) const _NOEXCEPT {
+        __annotate_double_ended_contiguous_container(__beginning, __end, __beginning, __end, __end, __end);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void __annotate_whole_block(size_t __block_index, __asan_annotation_type __annotation_type) const _NOEXCEPT {
+        __map_const_iterator __block_it = __map_.begin() + __block_index;
+        const void* __block_start = std::__to_address(*__block_it);
+        const void* __block_end = std::__to_address(*__block_it + __block_size);
+
+        if(__annotation_type == __asan_poison)
+            __annotate_poison_block(__block_start, __block_end);
+        else {
+            __annotate_double_ended_contiguous_container(
+                __block_start, __block_end, __block_start, __block_start, __block_start, __block_end);
+        }
+    }
+#if !defined(_LIBCPP_HAS_NO_ASAN)
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    bool __verify_asan_annotations() const _NOEXCEPT {
+        // This function tests deque object annotations.
+        if (empty()) {
+            for (__map_const_iterator __it = __map_.begin(); __it != __map_.end(); ++__it) {
+                if (!__sanitizer_verify_double_ended_contiguous_container(
+                        std::__to_address(*__it),
+                        std::__to_address(*__it),
+                        std::__to_address(*__it),
+                        std::__to_address(*__it + __block_size)))
+                  return false;
+            }
+
+            return true;
+        }
+
+        size_type __end                           = __start_ + size();
+        __map_const_iterator __first_mp = __map_.begin() + __start_ / __block_size;
+        __map_const_iterator __last_mp  = __map_.begin() + (__end - 1) / __block_size;
+
+        // Pointers to first and after last elements
+        // Those can be in different deque blocks
+        const void* __p_beg = std::__to_address(*__first_mp + (__start_ % __block_size));
+        const void* __p_end =
+            std::__to_address(*__last_mp + ((__end % __block_size == 0) ? __block_size : __end % __block_size));
+
+        for (__map_const_iterator __it = __map_.begin(); __it != __map_.end(); ++__it) {
+            // Go over all blocks, find the place we are in and verify its annotations
+            // Note that __p_end points *behind* the last item.
+
+            // - blocks before the first block with container elements
+            // - first block with items
+            // - last block with items
+            // - blocks after last block with ciontainer elements
+
+            // Is the block before or after deque blocks that contain elements?
+            if (__it < __first_mp || __it > __last_mp) {
+                if (!__sanitizer_verify_double_ended_contiguous_container(
+                        std::__to_address(*__it),
+                        std::__to_address(*__it),
+                        std::__to_address(*__it),
+                        std::__to_address(*__it + __block_size)))
+                  return false;
+            } else {
+                const void* __containers_buffer_beg = (__it == __first_mp) ? __p_beg : (const void*)std::__to_address(*__it);
+                const void* __containers_buffer_end =
+                    (__it == __last_mp) ? __p_end : (const void*)std::__to_address(*__it + __block_size);
+                if (!__sanitizer_verify_double_ended_contiguous_container(
+                        std::__to_address(*__it),
+                        __containers_buffer_beg,
+                        __containers_buffer_end,
+                        std::__to_address(*__it + __block_size))) {
+                  return false;
+                }
+            }
+        }
+        return true;
+    }
+
+  private:
+#endif // _LIBCPP_VERIFY_ASAN_DEQUE_ANNOTATIONS
     _LIBCPP_HIDE_FROM_ABI
     bool __maybe_remove_front_spare(bool __keep_one = true) {
       if (__front_spare_blocks() >= 2 || (!__keep_one && __front_spare_blocks())) {
+        __annotate_whole_block(0, __asan_unposion);
         __alloc_traits::deallocate(__alloc(), __map_.front(),
                                    __block_size);
         __map_.pop_front();
         __start_ -= __block_size;
         return true;
       }
       return false;
     }
 
     _LIBCPP_HIDE_FROM_ABI
     bool __maybe_remove_back_spare(bool __keep_one = true) {
       if (__back_spare_blocks() >= 2 || (!__keep_one && __back_spare_blocks())) {
+        __annotate_whole_block(__map_.size() - 1, __asan_unposion);
         __alloc_traits::deallocate(__alloc(), __map_.back(),
                                    __block_size);
         __map_.pop_back();
         return true;
       }
       return false;
     }
 
     template <class _Iterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI
     void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
 
     template <class _RandomAccessIterator>
     _LIBCPP_HIDE_FROM_ABI
     void __assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n);
     template <class _Iterator>
     _LIBCPP_HIDE_FROM_ABI
     void __assign_with_size(_Iterator __f, difference_type __n);
 
     template <class _Iterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI
     iterator __insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l);
 
     template <class _Iterator>
     _LIBCPP_HIDE_FROM_ABI
     iterator __insert_with_size(const_iterator __p, _Iterator __f, size_type __n);
 
     template <class _BiIter, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI
     iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel __sent, size_type __n);
     template <class _BiIter>
     _LIBCPP_HIDE_FROM_ABI
     iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n);
 
     template <class _InpIter>
     _LIBCPP_HIDE_FROM_ABI void __append(_InpIter __f, _InpIter __l,
                  typename enable_if<__has_exactly_input_iterator_category<_InpIter>::value>::type* = 0);
     template <class _ForIter>
     _LIBCPP_HIDE_FROM_ABI void __append(_ForIter __f, _ForIter __l,
                       typename enable_if<__has_forward_iterator_category<_ForIter>::value>::type* = 0);
 
     template <class _InputIterator>
     _LIBCPP_HIDE_FROM_ABI void __append_with_size(_InputIterator __from, size_type __n);
     template <class _InputIterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI void __append_with_sentinel(_InputIterator __f, _Sentinel __l);
 
     _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
     _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const value_type& __v);
     _LIBCPP_HIDE_FROM_ABI void __erase_to_end(const_iterator __f);
     _LIBCPP_HIDE_FROM_ABI void __add_front_capacity();
     _LIBCPP_HIDE_FROM_ABI void __add_front_capacity(size_type __n);
     _LIBCPP_HIDE_FROM_ABI void __add_back_capacity();
     _LIBCPP_HIDE_FROM_ABI void __add_back_capacity(size_type __n);
     _LIBCPP_HIDE_FROM_ABI iterator __move_and_check(iterator __f, iterator __l, iterator __r,
                               const_pointer& __vt);
     _LIBCPP_HIDE_FROM_ABI iterator __move_backward_and_check(iterator __f, iterator __l, iterator __r,
template<class _InputIterator,
          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
          class = enable_if_t<__is_allocator<_Alloc>::value>
          >
 deque(_InputIterator, _InputIterator)
   -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 
 template<class _InputIterator,
          class _Alloc,
          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
          class = enable_if_t<__is_allocator<_Alloc>::value>
          >
 deque(_InputIterator, _InputIterator, _Alloc)
   -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
 #if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Alloc = allocator<ranges::range_value_t<_Range>>,
           class = enable_if_t<__is_allocator<_Alloc>::value>
           >
 deque(from_range_t, _Range&&, _Alloc = _Alloc())
   -> deque<ranges::range_value_t<_Range>, _Alloc>;
 #endif
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(size_type __n)
     : __start_(0), __size_(0, __default_init_tag())
 {
+    __annotate_new(0);
     if (__n > 0)
         __append(__n);
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a)
     : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
 {
+    __annotate_new(0);
     if (__n > 0)
         __append(__n);
 }
 #endif
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v)
     : __start_(0), __size_(0, __default_init_tag())
 {
+    __annotate_new(0);
     if (__n > 0)
         __append(__n, __v);
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,
               typename enable_if<__has_input_iterator_category<_InputIter>::value>::type*)
     : __start_(0), __size_(0, __default_init_tag())
 {
+    __annotate_new(0);
     __append(__f, __l);
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
               typename enable_if<__has_input_iterator_category<_InputIter>::value>::type*)
     : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
 {
+    __annotate_new(0);
     __append(__f, __l);
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(const deque& __c)
     : __map_(__pointer_allocator(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))),
       __start_(0),
       __size_(0, __map_.__alloc())
 {
+    __annotate_new(0);
     __append(__c.begin(), __c.end());
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(const deque& __c, const __type_identity_t<allocator_type>& __a)
     : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
 {
+    __annotate_new(0);
     __append(__c.begin(), __c.end());
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>&
 deque<_Tp, _Allocator>::operator=(const deque& __c)
 {
     if (this != _VSTD::addressof(__c))
     {
         __copy_assign_alloc(__c);
         assign(__c.begin(), __c.end());
     }
     return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il)
     : __start_(0), __size_(0, __default_init_tag())
 {
+    __annotate_new(0);
     __append(__il.begin(), __il.end());
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il, const allocator_type& __a)
     : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
 {
+    __annotate_new(0);
     __append(__il.begin(), __il.end());
 }
 
 template <class _Tp, class _Allocator>
 inline
 deque<_Tp, _Allocator>::deque(deque&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __map_(std::move(__c.__map_)), __start_(std::move(__c.__start_)), __size_(std::move(__c.__size_))

 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
 {
     allocator_type& __a = __alloc();
     if (empty())
     {
+        __annotate_delete();
         while (__map_.size() > 0)
         {
             __alloc_traits::deallocate(__a, __map_.back(), __block_size);
             __map_.pop_back();
         }
         __start_ = 0;
     }
     else

 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::push_back(const value_type& __v)
 {
     allocator_type& __a = __alloc();
     if (__back_spare() == 0)
         __add_back_capacity();
     // __back_spare() >= 1
+    __annotate_increase_back(1);
     __alloc_traits::construct(__a, _VSTD::addressof(*end()), __v);
     ++__size();
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::push_front(const value_type& __v)
 {
     allocator_type& __a = __alloc();
     if (__front_spare() == 0)
         __add_front_capacity();
     // __front_spare() >= 1
+    __annotate_increase_front(1);
     __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), __v);
     --__start_;
     ++__size();
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::push_back(value_type&& __v)
 {
     allocator_type& __a = __alloc();
     if (__back_spare() == 0)
         __add_back_capacity();
     // __back_spare() >= 1
+    __annotate_increase_back(1);
     __alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::move(__v));
     ++__size();
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
 #if _LIBCPP_STD_VER >= 17
 typename deque<_Tp, _Allocator>::reference
 #else
 void
 #endif
 deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 {
     allocator_type& __a = __alloc();
     if (__back_spare() == 0)
         __add_back_capacity();
     // __back_spare() >= 1
+    __annotate_increase_back(1);
     __alloc_traits::construct(__a, _VSTD::addressof(*end()),
                               _VSTD::forward<_Args>(__args)...);
     ++__size();
 #if _LIBCPP_STD_VER >= 17
     return *--end();
 #endif
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::push_front(value_type&& __v)
 {
     allocator_type& __a = __alloc();
     if (__front_spare() == 0)
         __add_front_capacity();
     // __front_spare() >= 1
+    __annotate_increase_front(1);
     __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::move(__v));
     --__start_;
     ++__size();
 }
 
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
 #if _LIBCPP_STD_VER >= 17
 typename deque<_Tp, _Allocator>::reference
 #else
 void
 #endif
 deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
 {
     allocator_type& __a = __alloc();
     if (__front_spare() == 0)
         __add_front_capacity();
     // __front_spare() >= 1
+    __annotate_increase_front(1);
     __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::forward<_Args>(__args)...);
     --__start_;
     ++__size();
 #if _LIBCPP_STD_VER >= 17
     return *begin();
 #endif
 }
 
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
 {
     size_type __pos = __p - begin();
     size_type __to_end = size() - __pos;
     allocator_type& __a = __alloc();
     if (__pos < __to_end)
     {   // insert by shifting things backward
         if (__front_spare() == 0)
             __add_front_capacity();
         // __front_spare() >= 1
+        __annotate_increase_front(1);
         if (__pos == 0)
         {
             __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::move(__v));
             --__start_;
             ++__size();
         }
         else
         {
             iterator __b = begin();
             iterator __bm1 = _VSTD::prev(__b);
             __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
             --__start_;
             ++__size();
             if (__pos > 1)
                 __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
             *__b = _VSTD::move(__v);
         }
     }
     else
     {   // insert by shifting things forward
         if (__back_spare() == 0)
             __add_back_capacity();
         // __back_capacity >= 1
+        __annotate_increase_back(1);
         size_type __de = size() - __pos;
         if (__de == 0)
         {
             __alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::move(__v));
             ++__size();
         }
         else
         {
deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
     size_type __pos = __p - begin();
     size_type __to_end = size() - __pos;
     allocator_type& __a = __alloc();
     if (__pos < __to_end)
     {   // insert by shifting things backward
         if (__front_spare() == 0)
             __add_front_capacity();
         // __front_spare() >= 1
+        __annotate_increase_front(1);
         if (__pos == 0)
         {
             __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::forward<_Args>(__args)...);
             --__start_;
             ++__size();
         }
         else
         {
             __temp_value<value_type, _Allocator> __tmp(__alloc(), _VSTD::forward<_Args>(__args)...);
             iterator __b = begin();
             iterator __bm1 = _VSTD::prev(__b);
             __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
             --__start_;
             ++__size();
             if (__pos > 1)
                 __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
             *__b = _VSTD::move(__tmp.get());
         }
     }
     else
     {   // insert by shifting things forward
         if (__back_spare() == 0)
             __add_back_capacity();
         // __back_capacity >= 1
+        __annotate_increase_back(1);
         size_type __de = size() - __pos;
         if (__de == 0)
         {
             __alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::forward<_Args>(__args)...);
             ++__size();
         }
         else
         {
deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
     size_type __pos = __p - begin();
     size_type __to_end = size() - __pos;
     allocator_type& __a = __alloc();
     if (__pos < __to_end)
     {   // insert by shifting things backward
         if (__front_spare() == 0)
             __add_front_capacity();
         // __front_spare() >= 1
+        __annotate_increase_front(1);
         if (__pos == 0)
         {
             __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), __v);
             --__start_;
             ++__size();
         }
         else
         {
if (__pos < __to_end)
             *__b = *__vt;
         }
     }
     else
     {   // insert by shifting things forward
         if (__back_spare() == 0)
             __add_back_capacity();
         // __back_capacity >= 1
+        __annotate_increase_back(1);
         size_type __de = size() - __pos;
         if (__de == 0)
         {
             __alloc_traits::construct(__a, _VSTD::addressof(*end()), __v);
             ++__size();
         }
         else
         {
deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v)
     size_type __pos = __p - begin();
     size_type __to_end = __size() - __pos;
     allocator_type& __a = __alloc();
     if (__pos < __to_end)
     {   // insert by shifting things backward
         if (__n > __front_spare())
             __add_front_capacity(__n - __front_spare());
         // __n <= __front_spare()
+        __annotate_increase_front(__n);
         iterator __old_begin = begin();
         iterator __i = __old_begin;
         if (__n > __pos)
         {
             for (size_type __m = __n - __pos; __m; --__m, --__start_, ++__size())
                 __alloc_traits::construct(__a, _VSTD::addressof(*--__i), __v);
             __n = __pos;
         }
         if (__n > 0)
         {
             const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
             iterator __obn = __old_begin + __n;
             __move_construct_backward_and_check(__old_begin, __obn, __i, __vt);
             if (__n < __pos)
                 __old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt);
             _VSTD::fill_n(__old_begin, __n, *__vt);
         }
     }
     else
     {   // insert by shifting things forward
         size_type __back_capacity = __back_spare();
         if (__n > __back_capacity)
             __add_back_capacity(__n - __back_capacity);
         // __n <= __back_capacity
+        __annotate_increase_back(__n);
         iterator __old_end = end();
         iterator __i = __old_end;
         size_type __de = size() - __pos;
         if (__n > __de)
         {
             for (size_type __m = __n - __de; __m; --__m, (void) ++__i, ++__size())
                 __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
             __n = __de;
deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n) {
     size_type __pos = __p - begin();
     size_type __to_end = size() - __pos;
     allocator_type& __a = __alloc();
     if (__pos < __to_end)
     {   // insert by shifting things backward
         if (__n > __front_spare())
             __add_front_capacity(__n - __front_spare());
         // __n <= __front_spare()
+        __annotate_increase_front(__n);
         iterator __old_begin = begin();
         iterator __i = __old_begin;
         _BiIter __m = __f;
         if (__n > __pos)
         {
             __m = __pos < __n / 2 ? _VSTD::prev(__l, __pos) : _VSTD::next(__f, __n - __pos);
             for (_BiIter __j = __m; __j != __f; --__start_, ++__size())
                 __alloc_traits::construct(__a, _VSTD::addressof(*--__i), *--__j);
if (__pos < __to_end)
         }
     }
     else
     {   // insert by shifting things forward
         size_type __back_capacity = __back_spare();
         if (__n > __back_capacity)
             __add_back_capacity(__n - __back_capacity);
         // __n <= __back_capacity
+        __annotate_increase_back(__n);
         iterator __old_end = end();
         iterator __i = __old_end;
         _BiIter __m = __l;
         size_type __de = size() - __pos;
         if (__n > __de)
         {
             __m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de);
             for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__size())

 _LIBCPP_HIDE_FROM_ABI
 void deque<_Tp, _Allocator>::__append_with_size(_InputIterator __f, size_type __n) {
     allocator_type& __a = __alloc();
     size_type __back_capacity = __back_spare();
     if (__n > __back_capacity)
         __add_back_capacity(__n - __back_capacity);
 
     // __n <= __back_capacity
+    __annotate_increase_back(__n);
     for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
       _ConstructTransaction __tx(this, __br);
       for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {
         __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), *__f);
       }
     }
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__append(size_type __n)
 {
     allocator_type& __a = __alloc();
     size_type __back_capacity = __back_spare();
     if (__n > __back_capacity)
         __add_back_capacity(__n - __back_capacity);
     // __n <= __back_capacity
+    __annotate_increase_back(__n);
     for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
       _ConstructTransaction __tx(this, __br);
       for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
         __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_));
       }
     }
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
 {
     allocator_type& __a = __alloc();
     size_type __back_capacity = __back_spare();
     if (__n > __back_capacity)
         __add_back_capacity(__n - __back_capacity);
     // __n <= __back_capacity
+    __annotate_increase_back(__n);
     for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
       _ConstructTransaction __tx(this, __br);
       for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
         __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), __v);
       }
     }
 
 }
deque<_Tp, _Allocator>::__add_front_capacity()
     // Else if __map_.size() < __map_.capacity() then we need to allocate 1 buffer
     else if (__map_.size() < __map_.capacity())
     {   // we can put the new buffer into the map, but don't shift things around
         // until all buffers are allocated.  If we throw, we don't need to fix
         // anything up (any added buffers are undetectible)
         if (__map_.__front_spare() > 0)
             __map_.push_front(__alloc_traits::allocate(__a, __block_size));
         else
         {
             __map_.push_back(__alloc_traits::allocate(__a, __block_size));
             // Done allocating, reorder capacity
             pointer __pt = __map_.back();
             __map_.pop_back();
             __map_.push_front(__pt);
         }
         __start_ = __map_.size() == 1 ?
                                __block_size / 2 :
else
         _VSTD::swap(__map_.__first_, __buf.__first_);
         _VSTD::swap(__map_.__begin_, __buf.__begin_);
         _VSTD::swap(__map_.__end_, __buf.__end_);
         _VSTD::swap(__map_.__end_cap(), __buf.__end_cap());
         __start_ = __map_.size() == 1 ?
                                __block_size / 2 :
                                __start_ + __block_size;
     }
+    __annotate_whole_block(0, __asan_poison);
 }
 
 // Create front capacity for __n elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
 {
deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
     {   // we can put the new buffers into the map, but don't shift things around
         // until all buffers are allocated.  If we throw, we don't need to fix
         // anything up (any added buffers are undetectible)
         for (; __nb > 0; --__nb, __start_ += __block_size - (__map_.size() == 1))
         {
             if (__map_.__front_spare() == 0)
                 break;
             __map_.push_front(__alloc_traits::allocate(__a, __block_size));
+            __annotate_whole_block(0, __asan_poison);
         }
         for (; __nb > 0; --__nb, ++__back_capacity)
             __map_.push_back(__alloc_traits::allocate(__a, __block_size));
         // Done allocating, reorder capacity
         __start_ += __back_capacity * __block_size;
         for (; __back_capacity > 0; --__back_capacity)
         {
             pointer __pt = __map_.back();
             __map_.pop_back();
             __map_.push_front(__pt);
+            __annotate_whole_block(0, __asan_poison);
         }
     }
     // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
     else
     {
         size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty();
         __split_buffer<pointer, __pointer_allocator&>
             __buf(std::max<size_type>(2* __map_.capacity(),
                                       __nb + __map_.size()),
                   0, __map_.__alloc());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (; __nb > 0; --__nb)
+            for (; __nb > 0; --__nb) {
                 __buf.push_back(__alloc_traits::allocate(__a, __block_size));
+                // ASan: this is empty container, we have to poison whole block
+                __annotate_poison_block(
+                    std::__to_address(__buf.back()),
+                    std::__to_address(__buf.back() + __block_size));
+            }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         }
         catch (...)
         {
+            __annotate_delete();
             for (__map_pointer __i = __buf.begin();
                     __i != __buf.end(); ++__i)
                 __alloc_traits::deallocate(__a, *__i, __block_size);
             throw;
         }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
         for (; __back_capacity > 0; --__back_capacity)
         {
else if (__map_.size() < __map_.capacity())
         else
         {
             __map_.push_front(__alloc_traits::allocate(__a, __block_size));
             // Done allocating, reorder capacity
             pointer __pt = __map_.front();
             __map_.pop_front();
             __map_.push_back(__pt);
         }
+        __annotate_whole_block(__map_.size() - 1, __asan_poison);
     }
     // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
     else
     {
         __split_buffer<pointer, __pointer_allocator&>
             __buf(std::max<size_type>(2* __map_.capacity(), 1),
                   __map_.size(),
                   __map_.__alloc());
 
         typedef __allocator_destructor<_Allocator> _Dp;
         unique_ptr<pointer, _Dp> __hold(
             __alloc_traits::allocate(__a, __block_size),
                 _Dp(__a, __block_size));
         __buf.push_back(__hold.get());
         __hold.release();
 
         for (__map_pointer __i = __map_.end();
                 __i != __map_.begin();)
             __buf.push_front(*--__i);
         _VSTD::swap(__map_.__first_, __buf.__first_);
         _VSTD::swap(__map_.__begin_, __buf.__begin_);
         _VSTD::swap(__map_.__end_, __buf.__end_);
         _VSTD::swap(__map_.__end_cap(), __buf.__end_cap());
+        __annotate_whole_block(__map_.size() - 1, __asan_poison);
     }
 }
 
 // Create back capacity for __n elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
     {   // we can put the new buffers into the map, but don't shift things around
         // until all buffers are allocated.  If we throw, we don't need to fix
         // anything up (any added buffers are undetectible)
         for (; __nb > 0; --__nb)
         {
             if (__map_.__back_spare() == 0)
                 break;
             __map_.push_back(__alloc_traits::allocate(__a, __block_size));
+            __annotate_whole_block(__map_.size() - 1, __asan_poison);
         }
         for (; __nb > 0; --__nb, ++__front_capacity, __start_ +=
-                                 __block_size - (__map_.size() == 1))
+                                 __block_size - (__map_.size() == 1)) {
             __map_.push_front(__alloc_traits::allocate(__a, __block_size));
+            __annotate_whole_block(0, __asan_poison);
+        }
         // Done allocating, reorder capacity
         __start_ -= __block_size * __front_capacity;
         for (; __front_capacity > 0; --__front_capacity)
         {
             pointer __pt = __map_.front();
             __map_.pop_front();
             __map_.push_back(__pt);
         }
     }
     // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
     else
     {
         size_type __ds = __front_capacity * __block_size;
         __split_buffer<pointer, __pointer_allocator&>
             __buf(std::max<size_type>(2* __map_.capacity(),
                                       __nb + __map_.size()),
                   __map_.size() - __front_capacity,
                   __map_.__alloc());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (; __nb > 0; --__nb)
+            for (; __nb > 0; --__nb) {
                 __buf.push_back(__alloc_traits::allocate(__a, __block_size));
+                // ASan: this is an empty container, we have to poison the whole block
+                __annotate_poison_block(
+                    std::__to_address(__buf.back()),
+                    std::__to_address(__buf.back() + __block_size));
+            }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         }
         catch (...)
         {
+            __annotate_delete();
             for (__map_pointer __i = __buf.begin();
                     __i != __buf.end(); ++__i)
                 __alloc_traits::deallocate(__a, *__i, __block_size);
             throw;
         }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
         for (; __front_capacity > 0; --__front_capacity)
         {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
         __start_ -= __ds;
     }
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::pop_front()
 {
+    size_type __old_sz    = size();
+    size_type __old_start = __start_;
     allocator_type& __a = __alloc();
     __alloc_traits::destroy(__a, _VSTD::__to_address(*(__map_.begin() +
                                                     __start_ / __block_size) +
                                                     __start_ % __block_size));
     --__size();
     ++__start_;
+    __annotate_shrink_front(__old_sz, __old_start);
     __maybe_remove_front_spare();
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::pop_back()
 {
     _LIBCPP_ASSERT(!empty(), "deque::pop_back called on an empty deque");
+    size_type __old_sz    = size();
+    size_type __old_start = __start_;
     allocator_type& __a = __alloc();
     size_type __p = size() + __start_ - 1;
     __alloc_traits::destroy(__a, _VSTD::__to_address(*(__map_.begin() +
                                                     __p / __block_size) +
                                                     __p % __block_size));
     --__size();
+    __annotate_shrink_back(__old_sz, __old_start);
     __maybe_remove_back_spare();
 }
 
 // move assign [__f, __l) to [__r, __r + (__l-__f)).
 // If __vt points into [__f, __l), then subtract (__f - __r) from __vt.
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __r,
while (__n > 0)
         __l -= __bs - 1;
     }
 }
 
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::erase(const_iterator __f)
 {
+    size_type __old_sz    = size();
+    size_type __old_start = __start_;
     iterator __b = begin();
     difference_type __pos = __f - __b;
     iterator __p = __b + __pos;
     allocator_type& __a = __alloc();
     if (static_cast<size_t>(__pos) <= (size() - 1) / 2)
     {   // erase from front
         _VSTD::move_backward(__b, __p, _VSTD::next(__p));
         __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
         --__size();
         ++__start_;
+        __annotate_shrink_front(__old_sz, __old_start);
         __maybe_remove_front_spare();
     }
     else
     {   // erase from back
         iterator __i = _VSTD::move(_VSTD::next(__p), end(), __p);
         __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
         --__size();
+        __annotate_shrink_back(__old_sz, __old_start);
         __maybe_remove_back_spare();
     }
     return begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
 {
+    size_type __old_sz    = size();
+    size_type __old_start = __start_;
     difference_type __n = __l - __f;
     iterator __b = begin();
     difference_type __pos = __f - __b;
     iterator __p = __b + __pos;
     if (__n > 0)
     {
         allocator_type& __a = __alloc();
         if (static_cast<size_t>(__pos) <= (size() - __n) / 2)
         {   // erase from front
             iterator __i = _VSTD::move_backward(__b, __p, __p + __n);
             for (; __b != __i; ++__b)
                 __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
             __size() -= __n;
             __start_ += __n;
+            __annotate_shrink_front(__old_sz, __old_start);
             while (__maybe_remove_front_spare()) {
             }
         }
         else
         {   // erase from back
             iterator __i = _VSTD::move(__p + __n, end(), __p);
             for (iterator __e = end(); __i != __e; ++__i)
                 __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
             __size() -= __n;
+            __annotate_shrink_back(__old_sz, __old_start);
             while (__maybe_remove_back_spare()) {
             }
         }
     }
     return begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
 {
+    size_type __old_sz    = size();
+    size_type __old_start = __start_;
     iterator __e = end();
     difference_type __n = __e - __f;
     if (__n > 0)
     {
         allocator_type& __a = __alloc();
         iterator __b = begin();
         difference_type __pos = __f - __b;
         for (iterator __p = __b + __pos; __p != __e; ++__p)
             __alloc_traits::destroy(__a, _VSTD::addressof(*__p));
         __size() -= __n;
+        __annotate_shrink_back(__old_sz, __old_start);
         while (__maybe_remove_back_spare()) {
         }
     }
 }
 
 template <class _Tp, class _Allocator>
 inline
 void
#endif
     _VSTD::__swap_allocator(__alloc(), __c.__alloc());
 }
 
 template <class _Tp, class _Allocator>
 inline
 void
 deque<_Tp, _Allocator>::clear() _NOEXCEPT
 {
+    __annotate_delete();
     allocator_type& __a = __alloc();
     for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
         __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
     __size() = 0;
     while (__map_.size() > 2)
     {
         __alloc_traits::deallocate(__a, __map_.front(), __block_size);
         __map_.pop_front();
     }
     switch (__map_.size())
     {
     case 1:
         __start_ = __block_size / 2;
         break;
     case 2:
         __start_ = __block_size;
         break;
     }
+    __annotate_new(0);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_HIDE_FROM_ABI
 bool
 operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
     const typename deque<_Tp, _Allocator>::size_type __sz = __x.size();

libcxx/test/libcxx/containers/sequences/deque/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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: asan
+
+// <deque>
+
+// reference operator[](size_type n);
+
+#include "asan_testing.h"
+#include <deque>
+#include <cassert>
+#include <cstdlib>
+
+#include "min_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+extern "C" void __sanitizer_set_death_callback(void (*callback)(void));
+
+void do_exit() {
+  exit(0);
+}
+
+int main(int, char**)
+{
+    {
+        typedef cpp17_input_iterator<int*> MyInputIter;
+        // Sould not trigger ASan.
+        std::deque<int> v;
+        int i[] = {42};
+        v.insert(v.begin(), MyInputIter(i), MyInputIter(i + 1));
+        assert(v[0] == 42);
+        assert(is_double_ended_contiguous_container_asan_correct(v));
+    }
+    __sanitizer_set_death_callback(do_exit);
+    {
+        typedef int T;
+        typedef std::deque<T> C;
+        const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        C c(std::begin(t), std::end(t));
+        assert(is_double_ended_contiguous_container_asan_correct(c));
+        T* ptr = &c[0];
+        for(size_t i = 0; i < (8 + sizeof(T) - 1)/sizeof(T); ++i)
+          c.pop_front();
+        *ptr = 1;
+        volatile T foo = c[c.size()]; // should trigger ASAN. Use volatile to prevent being optimized away.
+        assert(false);          // if we got here, ASAN didn't trigger
+        ((void)foo);
+    }
+}

libcxx/test/libcxx/containers/sequences/deque/asan_caterpillar.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
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// Regression test to error in deque::__annotate_from_to in deque,
+// with origin in deque::__add_back_capacity.
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03
+// XFAIL: availability-verbose_abort-missing
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+#include <deque>
+#include <cstdio>
+#include "check_assertion.h"
+
+void test1() {
+  std::deque<char> test;
+  char buff[100000];
+  test.insert(test.begin(), buff, buff + 64000);
+
+  for (int i = 0; i < 1100; i += 1) {
+    test.insert(test.begin(), buff, buff + 320);
+    test.erase(test.end(), test.end() - 320);
+  }
+
+  test.insert(test.begin(), buff, buff + 32000);
+}
+
+void test2() {
+  std::deque<char> test;
+  char buff[100000];
+  test.insert(test.end(), buff, buff + 64000);
+
+  for (int i = 0; i < 1100; i += 1) {
+    test.insert(test.end(), buff, buff + 320);
+    test.erase(test.begin(), test.begin() + 320);
+  }
+
+  test.insert(test.end(), buff, buff + 32000);
+}
+
+int main(int, char**) {
+  test1();
+  test2();
+
+  return 0;
+}

libcxx/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp

 //
 //       reference front();
 // const_reference front() const;
 //
 //       reference back();
 // const_reference back() const;
 // libc++ marks these as 'noexcept'
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "test_macros.h"
 
 template <class C>
 C
int main(int, char**)
         LIBCPP_ASSERT_NOEXCEPT(   c.back());
         ASSERT_SAME_TYPE(decltype(c.back()), C::reference);
         for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
         for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
     {
         typedef std::deque<int> C;
         const C c = make<std::deque<int> >(10);
         ASSERT_SAME_TYPE(decltype(c[0]), C::const_reference);
         LIBCPP_ASSERT_NOEXCEPT(   c[0]);
         LIBCPP_ASSERT_NOEXCEPT(   c.front());
         ASSERT_SAME_TYPE(decltype(c.front()), C::const_reference);
         LIBCPP_ASSERT_NOEXCEPT(   c.back());
         ASSERT_SAME_TYPE(decltype(c.back()), C::const_reference);
         for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
         for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::deque<int, min_allocator<int>> C;
         C c = make<std::deque<int, min_allocator<int>> >(10);
         ASSERT_SAME_TYPE(decltype(c[0]), C::reference);
         LIBCPP_ASSERT_NOEXCEPT(   c[0]);
         LIBCPP_ASSERT_NOEXCEPT(   c.front());
         ASSERT_SAME_TYPE(decltype(c.front()), C::reference);
         LIBCPP_ASSERT_NOEXCEPT(   c.back());
         ASSERT_SAME_TYPE(decltype(c.back()), C::reference);
         for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
         for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
     {
         typedef std::deque<int, min_allocator<int>> C;
         const C c = make<std::deque<int, min_allocator<int>> >(10);
         ASSERT_SAME_TYPE(decltype(c[0]), C::const_reference);
         LIBCPP_ASSERT_NOEXCEPT(   c[0]);
         LIBCPP_ASSERT_NOEXCEPT(   c.front());
         ASSERT_SAME_TYPE(decltype(c.front()), C::const_reference);
         LIBCPP_ASSERT_NOEXCEPT(   c.back());
         ASSERT_SAME_TYPE(decltype(c.back()), C::const_reference);
         for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
         for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/empty.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // class deque
 
 // bool empty() const noexcept;
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::deque<int> C;
     C c;
     ASSERT_NOEXCEPT(c.empty());
     assert(c.empty());
     c.push_back(C::value_type(1));
     assert(!c.empty());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.clear();
     assert(c.empty());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::deque<int, min_allocator<int>> C;
     C c;
     ASSERT_NOEXCEPT(c.empty());
     assert(c.empty());
     c.push_back(C::value_type(1));
     assert(!c.empty());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.clear();
     assert(c.empty());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/max_size.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // size_type max_size() const;
 
+#include "asan_testing.h"
 #include <cassert>
 #include <deque>
 #include <limits>
 #include <type_traits>
 
 #include "test_allocator.h"
 #include "test_macros.h"
 
 int main(int, char**) {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::deque<int, A> C;
     C c;
     assert(c.max_size() <= 10);
     LIBCPP_ASSERT(c.max_size() == 10);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
   }
   {
     typedef limited_allocator<int, (std::size_t)-1> A;
     typedef std::deque<int, A> C;
     const C::size_type max_dist =
         static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
     C c;
     assert(c.max_size() <= max_dist);
     LIBCPP_ASSERT(c.max_size() == max_dist);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
   }
   {
     typedef std::deque<char> C;
     const C::size_type max_dist =
         static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
     C c;
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void resize(size_type n);
 
+#include "asan_testing.h"
 #include <deque>
 #include <algorithm>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);
     int init = 0;
     if (start > 0)
     {
         init = (start+1) / b + ((start+1) % b != 0);
         init *= b;
         --init;
     }
     C c(init, 0);
     for (int i = 0; i < init-start; ++i)
         c.pop_back();
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     for (int i = 0; i < size; ++i)
         c.push_back(i);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     for (int i = 0; i < start; ++i)
         c.pop_front();
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     return c;
 }
 
 template <class C>
 void
 test(C& c1, int size)
 {
     typedef typename C::const_iterator CI;
     typename C::size_type c1_osize = c1.size();
     c1.resize(size);
     assert(c1.size() == static_cast<std::size_t>(size));
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     CI i = c1.begin();
     for (int j = 0; static_cast<std::size_t>(j) < std::min(c1_osize, c1.size()); ++j, ++i)
         assert(*i == j);
     for (std::size_t j = c1_osize; j < c1.size(); ++j, ++i)
         assert(*i == 0);
 }
 
 template <class C>
#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            for (int k = 0; k < N; ++k)
+                testN<std::deque<int, safe_allocator<int>>>(rng[i], rng[j], rng[k]);
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void resize(size_type n, const value_type& v);
 
+#include "asan_testing.h"
 #include <deque>
 #include <algorithm>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);
     int init = 0;
     if (start > 0)
     {
         init = (start+1) / b + ((start+1) % b != 0);
         init *= b;
         --init;
     }
     C c(init, 0);
     for (int i = 0; i < init-start; ++i)
         c.pop_back();
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     for (int i = 0; i < size; ++i)
         c.push_back(i);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     for (int i = 0; i < start; ++i)
         c.pop_front();
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     return c;
 }
 
 template <class C>
 void
 test(C& c1, int size, int x)
 {
     typedef typename C::const_iterator CI;
     typename C::size_type c1_osize = c1.size();
     c1.resize(size, x);
     assert(c1.size() == static_cast<std::size_t>(size));
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     CI i = c1.begin();
     for (int j = 0; static_cast<std::size_t>(j) < std::min(c1_osize, c1.size()); ++j, ++i)
         assert(*i == j);
     for (std::size_t j = c1_osize; j < c1.size(); ++j, ++i)
         assert(*i == x);
 }
 
 template <class C>
#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            for (int k = 0; k < N; ++k)
+                testN<std::deque<int, safe_allocator<int>>>(rng[i], rng[j], rng[k]);
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void shrink_to_fit();
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 C

 
 template <class C>
 void
 test(C& c1)
 {
     C s = c1;
     c1.shrink_to_fit();
     assert(c1 == s);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     C c1 = make<C>(N, start);
     test(c1);

 #if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            testN<std::deque<int, safe_allocator<int>> >(rng[i], rng[j]);
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/size.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // class deque
 
 // size_type size() const noexcept;
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::deque<int> C;
     C c;
     ASSERT_NOEXCEPT(c.size());
     assert(c.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.push_back(C::value_type(2));
     assert(c.size() == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.push_back(C::value_type(1));
     assert(c.size() == 2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.push_back(C::value_type(3));
     assert(c.size() == 3);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.erase(c.begin());
     assert(c.size() == 2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.erase(c.begin());
     assert(c.size() == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.erase(c.begin());
     assert(c.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::deque<int, min_allocator<int>> C;
     C c;
     ASSERT_NOEXCEPT(c.size());
     assert(c.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.push_back(C::value_type(2));
     assert(c.size() == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.push_back(C::value_type(1));
     assert(c.size() == 2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.push_back(C::value_type(3));
     assert(c.size() == 3);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.erase(c.begin());
     assert(c.size() == 2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.erase(c.begin());
     assert(c.size() == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     c.erase(c.begin());
     assert(c.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // explicit deque(const allocator_type& a);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test(const Allocator& a)
 {
     std::deque<T, Allocator> d(a);
     assert(d.size() == 0);
     assert(d.get_allocator() == a);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
 }
 
 int main(int, char**)
 {
     test<int>(std::allocator<int>());
     test<NotConstructible>(test_allocator<NotConstructible>(3));
 #if TEST_STD_VER >= 11
     test<int>(min_allocator<int>());
+    test<int>(safe_allocator<int>());
     test<NotConstructible>(min_allocator<NotConstructible>{});
+    test<NotConstructible>(safe_allocator<NotConstructible>{});
     test<int>(explicit_allocator<int>());
     test<NotConstructible>(explicit_allocator<NotConstructible>{});
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.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
 
 // <deque>
 
 // void assign(initializer_list<value_type> il);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     std::deque<int> d;
     d.assign({3, 4, 5, 6});
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
     {
     std::deque<int, min_allocator<int>> d;
     d.assign({3, 4, 5, 6});
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class InputIterator>
 //   void assign(InputIterator f, InputIterator l);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 #if TEST_STD_VER >= 11

 
 template <class C>
 void
 test(C& c1, const C& c2)
 {
     c1.assign(c2.begin(), c2.end());
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {
     C c1 = make<C>(N, start);
     C c2 = make<C>(M);
     test(c1, c2);
 }
 
 template <class C>
 void
 testI(C& c1, const C& c2)
 {
     typedef typename C::const_iterator CI;
     typedef cpp17_input_iterator<CI> ICI;
     c1.assign(ICI(c2.begin()), ICI(c2.end()));
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
 }
 
 template <class C>
 void
 testNI(int start, int N, int M)
 {
     C c1 = make<C>(N, start);
     C c2 = make<C>(M);
#if TEST_STD_VER >= 11
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     testNI<std::deque<int, min_allocator<int>> >(1500, 2000, 1000);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            for (int k = 0; k < N; ++k)
+                testN<std::deque<int, safe_allocator<int>> >(rng[i], rng[j], rng[k]);
+    testNI<std::deque<int, safe_allocator<int>> >(1500, 2000, 1000);
+    }
 #endif
 }
 
 template <class It>
 void test_emplacable_concept() {
 #if TEST_STD_VER >= 11
   int arr1[] = {42};
   int arr2[] = {1, 101, 42};

libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void assign(size_type n, const value_type& v);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 

 template <class C>
 void
 test(C& c1, int size, int v)
 {
     typedef typename C::const_iterator CI;
     c1.assign(size, v);
     assert(c1.size() == static_cast<std::size_t>(size));
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     for (CI i = c1.begin(); i != c1.end(); ++i)
         assert(*i == v);
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {

libcxx/test/std/containers/sequences/deque/deque.cons/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(const deque&);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 void
 test(const C& x)
 {
     C c(x);
     assert(c == x);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(x));
 }
 
 int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int>(ab, an));
     }
     {
         std::deque<int, test_allocator<int> > v(3, 2, test_allocator<int>(5));
         std::deque<int, test_allocator<int> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v2));
     }
 #if TEST_STD_VER >= 11
     {
         std::deque<int, other_allocator<int> > v(3, 2, other_allocator<int>(5));
         std::deque<int, other_allocator<int> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == other_allocator<int>(-2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v2));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int, min_allocator<int>>(ab, an));
     }
     {
         std::deque<int, min_allocator<int> > v(3, 2, min_allocator<int>());
         std::deque<int, min_allocator<int> > v2 = v;
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v2));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/copy_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(const deque& c, const allocator_type& a);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 void
 test(const C& x, const typename C::allocator_type& a)
 {
     C c(x, a);
     assert(c == x);
     assert(c.get_allocator() == a);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 }
 
 int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int, test_allocator<int> >(ab, an, test_allocator<int>(3)),
                                                            test_allocator<int>(4));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int, other_allocator<int> >(ab, an, other_allocator<int>(3)),
                                                             other_allocator<int>(4));
     }
 #if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int, min_allocator<int> >(ab, an, min_allocator<int>()),
                                                           min_allocator<int>());
     }
+    {
+        int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
+        int* an = ab + sizeof(ab)/sizeof(ab[0]);
+        test(std::deque<int, safe_allocator<int> >(ab, an, safe_allocator<int>()),
+                                                          safe_allocator<int>());
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp

 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    deque(InputIterator, InputIterator, Allocator = Allocator())
 //    -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 // template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
 //   deque(from_range_t, R&&, Allocator = Allocator())
 //     -> deque<ranges::range_value_t<R>, Allocator>; // C++23
 
+#include "asan_testing.h"
 #include <array>
 #include <cassert>
 #include <climits> // INT_MAX
 #include <cstddef>
 #include <deque>
 #include <iterator>
 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 
 struct A {};
 
 int main(int, char**)
 {
 
 //  Test the explicit deduction guides
     {
     const int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     std::deque deq(std::begin(arr), std::end(arr));
 
     static_assert(std::is_same_v<decltype(deq), std::deque<int>>, "");
     assert(std::equal(deq.begin(), deq.end(), std::begin(arr), std::end(arr)));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
     }
 
     {
     const long arr[] = {INT_MAX, 1L, 2L, 3L };
     std::deque deq(std::begin(arr), std::end(arr), std::allocator<long>());
     static_assert(std::is_same_v<decltype(deq)::value_type, long>, "");
     assert(deq.size() == 4);
     assert(deq[0] == INT_MAX);
     assert(deq[1] == 1L);
     assert(deq[2] == 2L);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
     }
 
 //  Test the implicit deduction guides
 
     {
 //  We don't expect this one to work.
 //  std::deque deq(std::allocator<int>()); // deque (allocator &)
     }
 
     {
     std::deque deq(1, A{}); // deque (size_type, T)
     static_assert(std::is_same_v<decltype(deq)::value_type, A>, "");
     static_assert(std::is_same_v<decltype(deq)::allocator_type, std::allocator<A>>, "");
     assert(deq.size() == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
     }
 
     {
     std::deque deq(1, A{}, test_allocator<A>()); // deque (size_type, T, allocator)
     static_assert(std::is_same_v<decltype(deq)::value_type, A>, "");
     static_assert(std::is_same_v<decltype(deq)::allocator_type, test_allocator<A>>, "");
     assert(deq.size() == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
     }
 
     {
     std::deque deq{1U, 2U, 3U, 4U, 5U}; // deque(initializer-list)
     static_assert(std::is_same_v<decltype(deq)::value_type, unsigned>, "");
     assert(deq.size() == 5);
     assert(deq[2] == 3U);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
     }
 
     {
     std::deque deq({1.0, 2.0, 3.0, 4.0}, test_allocator<double>()); // deque(initializer-list, allocator)
     static_assert(std::is_same_v<decltype(deq)::value_type, double>, "");
     static_assert(std::is_same_v<decltype(deq)::allocator_type, test_allocator<double>>, "");
     assert(deq.size() == 4);
     assert(deq[3] == 4.0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
     }
 
     {
     std::deque<long double> source;
     std::deque deq(source); // deque(deque &)
     static_assert(std::is_same_v<decltype(deq)::value_type, long double>, "");
     static_assert(std::is_same_v<decltype(deq)::allocator_type, std::allocator<long double>>, "");
     assert(deq.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
     }
 
     {
         typedef test_allocator<short> Alloc;
         typedef test_allocator<int> ConvertibleToAlloc;
 
         {
         std::deque<short, Alloc> source;
         std::deque deq(source, Alloc(2));
         static_assert(std::is_same_v<decltype(deq), decltype(source)>);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(source));
         }
 
         {
         std::deque<short, Alloc> source;
         std::deque deq(source, ConvertibleToAlloc(2));
         static_assert(std::is_same_v<decltype(deq), decltype(source)>);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(source));
         }
 
         {
         std::deque<short, Alloc> source;
         std::deque deq(std::move(source), Alloc(2));
         static_assert(std::is_same_v<decltype(deq), decltype(source)>);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(source));
         }
 
         {
         std::deque<short, Alloc> source;
         std::deque deq(std::move(source), ConvertibleToAlloc(2));
         static_assert(std::is_same_v<decltype(deq), decltype(source)>);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(deq));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(source));
         }
     }
 
 #if TEST_STD_VER >= 23
     {
       {
         std::deque c(std::from_range, std::array<int, 0>());
         static_assert(std::is_same_v<decltype(c), std::deque<int>>);

libcxx/test/std/containers/sequences/deque/deque.cons/default.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque()
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test()
 {
     std::deque<T, Allocator> d;
     assert(d.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
 #if TEST_STD_VER >= 11
     std::deque<T, Allocator> d1 = {};
     assert(d1.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d1));
 #endif
 }
 
 int main(int, char**)
 {
     test<int, std::allocator<int> >();
     test<NotConstructible, limited_allocator<NotConstructible, 1> >();
 #if TEST_STD_VER >= 11
     test<int, min_allocator<int> >();
     test<NotConstructible, min_allocator<NotConstructible> >();
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/initializer_list.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
 
 // <deque>
 
 // deque(initializer_list<value_type> il);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     std::deque<int> d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
     {
     std::deque<int, min_allocator<int>> d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.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
 
 // <deque>
 
 // deque(initializer_list<value_type> il, const Allocator& a = allocator_type());
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     std::deque<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
     assert(d.get_allocator() == test_allocator<int>(3));
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
     {
     std::deque<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>());
     assert(d.get_allocator() == min_allocator<int>());
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class InputIterator> deque(InputIterator f, InputIterator l);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 #if TEST_STD_VER >= 11
 #include "emplace_constructible.h"
 #endif
 
 template <class InputIterator>
 void
 test(InputIterator f, InputIterator l)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::allocator<T> Allocator;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
     assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 template <class Allocator, class InputIterator>
 void
 test(InputIterator f, InputIterator l)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
     assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 void basic_test()
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class InputIterator>
 //   deque(InputIterator f, InputIterator l, const allocator_type& a);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #if TEST_STD_VER >= 11
 #include "emplace_constructible.h"
 #endif
 
 template <class InputIterator, class Allocator>
 void
 test(InputIterator f, InputIterator l, const Allocator& a)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l, a);
     assert(d.get_allocator() == a);
     assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 void basic_test()
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);
#if TEST_STD_VER >= 11
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructibleAndMoveable<int>;
     using It = random_access_iterator<int*>;
     std::allocator<T> a;
     {
       std::deque<T> v(It(arr1), It(std::end(arr1)), a);
       assert(v[0].value == 42);
+      LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
     }
     {
       std::deque<T> v(It(arr2), It(std::end(arr2)), a);
       assert(v[0].value == 1);
       assert(v[1].value == 101);
       assert(v[2].value == 42);
+      LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
     }
   }
   {
     using T = EmplaceConstructibleAndMoveable<int>;
     using It = cpp17_input_iterator<int*>;
     std::allocator<T> a;
     {
       std::deque<T> v(It(arr1), It(std::end(arr1)), a);
       assert(v[0].copied == 0);
       assert(v[0].value == 42);
+      LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
     }
     {
       std::deque<T> v(It(arr2), It(std::end(arr2)), a);
       //assert(v[0].copied == 0);
       assert(v[0].value == 1);
       //assert(v[1].copied == 0);
       assert(v[1].value == 101);
       assert(v[2].copied == 0);
       assert(v[2].value == 42);
+      LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
     }
   }
 #endif
 }
 
 int main(int, char**) {
   basic_test();
   test_emplacable_concept();
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/move.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
 
 // <deque>
 
 // deque(deque&&);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main(int, char**)
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         A old_a = c1.get_allocator();
         std::deque<MoveOnly, A> c3 = std::move(c1);
         assert(c2 == c3);
         assert(c1.size() == 0);
         assert(c3.get_allocator() == old_a);
         assert(c1.get_allocator() == A(test_alloc_base::moved_value));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef other_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(1));
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A(2));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3 = std::move(c1);
         assert(c2 == c3);
         assert(c1.size() == 0);
         assert(c3.get_allocator() == c1.get_allocator());
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef min_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A{});
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A{});
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3 = std::move(c1);
         assert(c2 == c3);
         assert(c1.size() == 0);
         assert(c3.get_allocator() == c1.get_allocator());
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/move_alloc.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
 
 // <deque>
 
 // deque(deque&& c, const allocator_type& a);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef test_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(1));
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A(1));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(std::move(c1), A(3)); // unequal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A(3));
         LIBCPP_ASSERT(c1.size() != 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef test_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(1));
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A(1));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(std::move(c1), A(1)); // equal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A(1));
         LIBCPP_ASSERT(c1.size() == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef other_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(1));
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A(1));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(std::move(c1), A(3)); // unequal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A(3));
         LIBCPP_ASSERT(c1.size() != 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef min_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A{});
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A{});
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(std::move(c1), A());  // equal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A());
         LIBCPP_ASSERT(c1.size() == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/move_assign.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
 
 // <deque>
 
 // deque& operator=(deque&& c);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main(int, char**)
         std::deque<MoveOnly, A> c2(A(5));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(A(5));
         c3 = std::move(c1);
         assert(c2 == c3);
         assert(c1.size() == 0);
         assert(c3.get_allocator() == A(5));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef test_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(5));
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A(5));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(A(6));
         c3 = std::move(c1);
         assert(c2 == c3);
         assert(c1.size() != 0);
         assert(c3.get_allocator() == A(6));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef other_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(5));
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A(5));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(A(6));
         c3 = std::move(c1);
         assert(c2 == c3);
         assert(c1.size() == 0);
         assert(c3.get_allocator() == A(5));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef min_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A{});
         for (int* p = ab; p < an; ++p)
             c1.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c2(A{});
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
         std::deque<MoveOnly, A> c3(A{});
         c3 = std::move(c1);
         assert(c2 == c3);
         assert(c1.size() == 0);
         assert(c3.get_allocator() == A());
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/op_equal.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque& operator=(const deque& c);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 void
 test(const C& x)
 {
     C c;
     c = x;
     assert(c == x);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(x));
 }
 
 int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int>(ab, an));
     }
     {
         std::deque<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
         std::deque<int, test_allocator<int> > l2(l, test_allocator<int>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == test_allocator<int>(3));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(l));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(l2));
     }
     {
         std::deque<int, other_allocator<int> > l(3, 2, other_allocator<int>(5));
         std::deque<int, other_allocator<int> > l2(l, other_allocator<int>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(l));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(l2));
     }
 #if TEST_STD_VER >= 11
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
         int* an = ab + sizeof(ab)/sizeof(ab[0]);
         test(std::deque<int, min_allocator<int>>(ab, an));
     }
     {
         std::deque<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::deque<int, min_allocator<int> > l2(l, min_allocator<int>());
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(l));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(l2));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.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
 
 // <deque>
 
 // deque& operator=(initializer_list<value_type> il);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     std::deque<int> d;
     d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
     {
     std::deque<int, min_allocator<int>> d;
     d = {3, 4, 5, 6};
     assert(d.size() == 4);
     assert(d[0] == 3);
     assert(d[1] == 4);
     assert(d[2] == 5);
     assert(d[3] == 6);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.cons/size.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // explicit deque(size_type n);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test2(unsigned n)
 {
 #if TEST_STD_VER > 11
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     assert(DefaultOnly::count == 0);
     {
     C d(n, Allocator());
     assert(static_cast<unsigned>(DefaultOnly::count) == n);
     assert(d.size() == n);
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == T());
     }
     assert(DefaultOnly::count == 0);
 #else
     ((void)n);
 #endif
 }
 
 template <class T, class Allocator>
 void
 test1(unsigned n)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     assert(DefaultOnly::count == 0);
     {
     C d(n);
     assert(static_cast<unsigned>(DefaultOnly::count) == n);
     assert(d.size() == n);
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
 #if TEST_STD_VER >= 11
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == T());
 #endif
     }
     assert(DefaultOnly::count == 0);
 }
 
 template <class T, class Allocator>
 void
 test3(unsigned n, Allocator const &alloc = Allocator())
 {
 #if TEST_STD_VER > 11
     typedef std::deque<T, Allocator> C;
     {
     C d(n, alloc);
     assert(d.size() == n);
     assert(d.get_allocator() == alloc);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
 #else
     ((void)n);
     ((void)alloc);
 #endif
 }
 
 template <class T, class Allocator>

libcxx/test/std/containers/sequences/deque/deque.cons/size_value.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(size_type n, const value_type& v);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test(unsigned n, const T& x)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(n, x);
     assert(d.size() == n);
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == x);
 }
 
 int main(int, char**)
 {
     test<int, std::allocator<int> >(0, 5);
     test<int, std::allocator<int> >(1, 10);

libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(size_type n, const value_type& v, const allocator_type& a);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test(unsigned n, const T& x, const Allocator& a)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(n, x, a);
     assert(d.get_allocator() == a);
     assert(d.size() == n);
     assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == x);
 }
 
 int main(int, char**)
 {
     {
     std::allocator<int> a;

libcxx/test/std/containers/sequences/deque/deque.erasure/erase.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, c++11, c++14, c++17
 
 // <deque>
 
 // template <class T, class Allocator, class U>
 //   typename deque<T, Allocator>::size_type
 //   erase(deque<T, Allocator>& c, const U& value);
 
+#include "asan_testing.h"
 #include <deque>
 #include <optional>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class U>
 void test0(S s, U val, S expected, std::size_t expected_erased_count) {
   ASSERT_SAME_TYPE(typename S::size_type, decltype(std::erase(s, val)));
   assert(expected_erased_count == std::erase(s, val));
   assert(s == expected);
+  LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(s));
 }
 
 template <class S>
 void test()
 {
   test0(S(), 1, S(), 0);
 
   test0(S({1}), 1, S(), 1);
void test()
   test0(S({1, 2, 1}), opt(2), S({1, 1}), 1);
   test0(S({1, 2, 1}), opt(3), S({1, 2, 1}), 0);
 }
 
 int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
+    test<std::deque<int, safe_allocator<int>>> ();
     test<std::deque<int, test_allocator<int>>> ();
 
     test<std::deque<long>>();
     test<std::deque<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.erasure/erase_if.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, c++11, c++14, c++17
 
 // <deque>
 
 // template <class T, class Allocator, class Predicate>
 //   typename deque<T, Allocator>::size_type
 //   erase_if(deque<T, Allocator>& c, Predicate pred);
 
+#include "asan_testing.h"
 #include <deque>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
 void test0(S s, Pred p, S expected, std::size_t expected_erased_count) {
   ASSERT_SAME_TYPE(typename S::size_type, decltype(std::erase_if(s, p)));
   assert(expected_erased_count == std::erase_if(s, p));
   assert(s == expected);
+  LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(s));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
void test()
     test0(S({1, 2, 3}), True, S(), 3);
     test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
 int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
+    test<std::deque<int, safe_allocator<int>>> ();
     test<std::deque<int, test_allocator<int>>> ();
 
     test<std::deque<long>>();
     test<std::deque<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/clear.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void clear() noexcept;
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         typedef NotConstructible T;
         typedef std::deque<T> C;
         C c;
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
         assert(std::distance(c.begin(), c.end()) == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
     {
         typedef int T;
         typedef std::deque<T> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
         assert(std::distance(c.begin(), c.end()) == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 
         c.clear();
         assert(std::distance(c.begin(), c.end()) == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #if TEST_STD_VER >= 11
     {
         typedef NotConstructible T;
         typedef std::deque<T, min_allocator<T>> C;
         C c;
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
         assert(std::distance(c.begin(), c.end()) == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
     {
         typedef int T;
         typedef std::deque<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
         assert(std::distance(c.begin(), c.end()) == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 
         c.clear();
         assert(std::distance(c.begin(), c.end()) == 0);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class... Args> iterator emplace(const_iterator p, Args&&... args);
 
 // UNSUPPORTED: c++03
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 

 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.emplace(c1.begin() + P, Emplaceable(1, 2.5));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     assert(*i == Emplaceable(1, 2.5));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     for (int i = 0; i <= 3; ++i)
     {
int main(int, char**)
     }
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable, min_allocator<Emplaceable>> >(rng[i], rng[j]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            testN<std::deque<Emplaceable, safe_allocator<Emplaceable>> >(rng[i], rng[j]);
+    }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace_back.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
 
 // <deque>
 
 // template <class... Args> reference emplace_back(Args&&... args);
 // return type is 'reference' in C++17; 'void' before
 
+#include "asan_testing.h"
 #include <deque>
 #include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 #include "test_allocator.h"

 #else
               c1.emplace_back(Emplaceable(1, 2.5));
 #endif
     assert(c1.size() == c1_osize + 1);
     assert(std::distance(c1.begin(), c1.end())
                == static_cast<std::ptrdiff_t>(c1.size()));
     I i = c1.end();
     assert(*--i == Emplaceable(1, 2.5));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
 #if TEST_STD_VER > 14
     assert(&(*i) == &ref);
 #endif
 }
 
 template <class C>
 void
 testN(int start, int N)
int main(int, char**)
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable, min_allocator<Emplaceable>> >(rng[i], rng[j]);
     }
     {
         std::deque<Tag_X, TaggingAllocator<Tag_X>> c;
         c.emplace_back();
         assert(c.size() == 1);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         c.emplace_back(1, 2, 3);
         assert(c.size() == 2);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         c.emplace_front();
         assert(c.size() == 3);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         c.emplace_front(1, 2, 3);
         assert(c.size() == 4);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace_front.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
 
 // <deque>
 
 // template <class... Args> reference emplace_front(Args&&... args);
 // return type is 'reference' in C++17; 'void' before
 
+#include "asan_testing.h"
 #include <deque>
 #include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 #include "test_allocator.h"

 #else
                   c1.emplace_front(Emplaceable(1, 2.5));
 #endif
     assert(c1.size() == c1_osize + 1);
     assert(std::distance(c1.begin(), c1.end())
                == static_cast<std::ptrdiff_t>(c1.size()));
     I i = c1.begin();
     assert(*i == Emplaceable(1, 2.5));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
 #if TEST_STD_VER > 14
     assert(&res_ref == &(*i));
 #endif
 }
 
 template <class C>
 void
 testN(int start, int N)
int main(int, char**)
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable, min_allocator<Emplaceable>> >(rng[i], rng[j]);
     }
     {
         std::deque<Tag_X, TaggingAllocator<Tag_X>> c;
         c.emplace_front();
         assert(c.size() == 1);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         c.emplace_front(1, 2, 3);
         assert(c.size() == 2);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         c.emplace_front();
         assert(c.size() == 3);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         c.emplace_front(1, 2, 3);
         assert(c.size() == 4);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // iterator erase(const_iterator f)
 
 //  Erasing items from the beginning or the end of a deque shall not invalidate iterators
 //  to items that were not erased.
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename C>
 void del_at_start(C c)
 {
void del_at_end(C c)
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
     assert( *it1 ==  *it3);
     assert(&*it1 == &*it3);
     assert(  it2 ==   it4);
     assert( *it2 ==  *it4);
     assert(&*it2 == &*it4);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 }
 
 int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
         queue.push_back(i);
 

libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // iterator erase(const_iterator p)
 
+#include "asan_testing.h"
 #include <deque>
 #include <algorithm>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "min_allocator.h"
 #include "test_macros.h"
// (which includes move assignment)
     {
     Throws arr[] = {1, 2, 3};
     std::deque<Throws> v(arr, arr+3);
     Throws::sThrows = true;
     v.erase(v.begin());
     v.erase(--v.end());
     v.erase(v.begin());
     assert(v.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // iterator erase(const_iterator f, const_iterator l)
 
 //  Erasing items from the beginning or the end of a deque shall not invalidate iterators
 //  to items that were not erased.
 
 
+#include "asan_testing.h"
 #include <deque>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename C>
 void del_at_start(C c, std::size_t num)
 {
     typename C::iterator first = c.begin();
     typename C::iterator last  = first + num;
     typename C::iterator it1 = last;
     typename C::iterator it2 = c.end() - 1;
 
     c.erase (first, last);
 
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
     assert( *it1 ==  *it3);
     assert(&*it1 == &*it3);
     assert(  it2 ==   it4);
     assert( *it2 ==  *it4);
     assert(&*it2 == &*it4);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 }
 
 template <typename C>
 void del_at_end(C c, std::size_t num)
 {
     typename C::iterator last  = c.end();
     typename C::iterator first = last - num;
     typename C::iterator it1 = c.begin();
     typename C::iterator it2 = first - 1;
 
     c.erase (first, last);
 
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
     assert( *it1 ==  *it3);
     assert(&*it1 == &*it3);
     assert(  it2 ==   it4);
     assert( *it2 ==  *it4);
     assert(&*it2 == &*it4);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 }
 
 
 int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
         queue.push_back(i);

libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.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
 //
 //===----------------------------------------------------------------------===//
 //
 // REQUIRES: long_tests
 
 // <deque>
 
 // iterator erase(const_iterator f, const_iterator l)
 
+#include "asan_testing.h"
 #include <deque>
 #include <algorithm>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "min_allocator.h"
 #include "test_macros.h"

 {
     typedef typename C::iterator I;
     assert(static_cast<std::size_t>(P + size) <= c1.size());
     std::size_t c1_osize = c1.size();
     I i = c1.erase(c1.cbegin() + P, c1.cbegin() + (P + size));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize - size);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     i = c1.begin();
     int j = 0;
     for (; j < P; ++j, ++i)
         assert(*i == j);
     for (j += size; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 

 // Throws: Nothing unless an exception is thrown by the assignment operator of T.
 // (which includes move assignment)
     {
     Throws arr[] = {1, 2, 3};
     std::deque<Throws> v(arr, arr+3);
     Throws::sThrows = true;
     v.erase(v.begin(), --v.end());
     assert(v.size() == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
     v.erase(v.begin(), v.end());
     assert(v.size() == 0);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(v));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.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
 
 // <deque>
 
 // iterator insert(const_iterator p, initializer_list<value_type> il);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
int main(int, char**)
     assert(d[6] == 1);
     assert(d[7] == 1);
     assert(d[8] == 1);
     assert(d[9] == 1);
     assert(d[10] == 1);
     assert(d[11] == 1);
     assert(d[12] == 1);
     assert(d[13] == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
     {
     std::deque<int, min_allocator<int>> d(10, 1);
     std::deque<int, min_allocator<int>>::iterator i = d.insert(d.cbegin() + 2, {3, 4, 5, 6});
     assert(d.size() == 14);
     assert(i == d.begin() + 2);
     assert(d[0] == 1);
     assert(d[1] == 1);
     assert(d[2] == 3);
     assert(d[3] == 4);
     assert(d[4] == 5);
     assert(d[5] == 6);
     assert(d[6] == 1);
     assert(d[7] == 1);
     assert(d[8] == 1);
     assert(d[9] == 1);
     assert(d[10] == 1);
     assert(d[11] == 1);
     assert(d[12] == 1);
     assert(d[13] == 1);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(d));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.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
 //
 //===----------------------------------------------------------------------===//
 //
 // REQUIRES: long_tests
 
 // <deque>
 
 // template <class InputIterator>
 //   iterator insert (const_iterator p, InputIterator f, InputIterator l);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
test(int P, const C& c0, const C& c2)
     typedef typename C::const_iterator CI;
     typedef cpp17_input_iterator<CI> BCI;
     C c1 = c0;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + c2.size());
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
     }

 {
     typedef typename C::const_iterator CI;
     typedef cpp17_input_iterator<CI> ICI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, ICI(c2.begin()), ICI(c2.end()));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + c2.size());
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
#if TEST_STD_VER >= 11
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     testNI<std::deque<int> >(1500, 2000, 1000);
     test_move<std::deque<MoveOnly, min_allocator<MoveOnly> > >();
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            for (int k = 0; k < N; ++k)
+                testN<std::deque<int, safe_allocator<int>> >(rng[i], rng[j], rng[k]);
+    testNI<std::deque<int> >(1500, 2000, 1000);
+    test_move<std::deque<MoveOnly, safe_allocator<MoveOnly> > >();
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // iterator insert (const_iterator p, value_type&& v);
 
 // UNSUPPORTED: c++03
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 

 test(int P, C& c1, int x)
 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, MoveOnly(x));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     i = c1.begin();
     for (int j = 0; j < P; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
     assert(*i == MoveOnly(x));
     ++i;
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
 }
int main(int, char**)
     }
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[i], rng[j]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            testN<std::deque<MoveOnly, safe_allocator<MoveOnly>> >(rng[i], rng[j]);
+    }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.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
 //
 //===----------------------------------------------------------------------===//
 //
 // REQUIRES: long_tests
 
 // <deque>
 
 // iterator insert (const_iterator p, size_type n, const value_type& v);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>

 test(int P, C& c1, int size, int x)
 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, size, x);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + size);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; j < size; ++j, ++i)
         assert(*i == x);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
#if TEST_STD_VER >= 11
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            for (int k = 0; k < N; ++k)
+                testN<std::deque<int, safe_allocator<int>> >(rng[i], rng[j], rng[k]);
+    self_reference_test<std::deque<int, safe_allocator<int>> >();
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // iterator insert (const_iterator p, const value_type& v);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>

 test(int P, C& c1, int x)
 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, x);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     assert(*i == x);
     ++i;
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
#if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            testN<std::deque<int, safe_allocator<int>> >(rng[i], rng[j]);
+    self_reference_test<std::deque<int, safe_allocator<int>> >();
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void pop_back()
 
 //  Erasing items from the beginning or the end of a deque shall not invalidate iterators
 //  to items that were not erased.
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename C>
 void test(C c)
 {
     typename C::iterator it1 = c.begin();
     typename C::iterator it2 = c.end() - 2;
 
     c.pop_back();
 
     typename C::iterator it3 = c.begin();
     typename C::iterator it4 = c.end() - 1;
     assert(  it1 ==   it3);
     assert( *it1 ==  *it3);
     assert(&*it1 == &*it3);
     assert(  it2 ==   it4);
     assert( *it2 ==  *it4);
     assert(&*it2 == &*it4);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
 }
 
 int main(int, char**)
 {
     std::deque<int> queue;
-    for (int i = 0; i < 20; ++i)
+    for (int i = 0; i < 4098; ++i)
         queue.push_back(i);
 
     while (queue.size() > 1)
     {
         test(queue);
         queue.pop_back();
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(queue));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void pop_back()
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>

 void
 test(C& c1)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.pop_back();
     assert(c1.size() == c1_osize - 1);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     I i = c1.begin();
     for (int j = 0; static_cast<std::size_t>(j) < c1.size(); ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)

 #if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            testN<std::deque<int, safe_allocator<int>> >(rng[i], rng[j]);
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void pop_front()
 
 //  Erasing items from the beginning or the end of a deque shall not invalidate iterators
 //  to items that were not erased.
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename C>
 void test(C c)
 {
void test(C c)
     assert(  it2 ==   it4);
     assert( *it2 ==  *it4);
     assert(&*it2 == &*it4);
 }
 
 int main(int, char**)
 {
     std::deque<int> queue;
-    for (int i = 0; i < 20; ++i)
+    for (int i = 0; i < 4098; ++i)
         queue.push_back(i);
 
     while (queue.size() > 1)
     {
         test(queue);
         queue.pop_back();
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(queue));
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void pop_front()
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>

 void
 test(C& c1)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.pop_front();
     assert(c1.size() == c1_osize - 1);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     I i = c1.begin();
     for (int j = 1; static_cast<std::size_t>(j) < c1.size(); ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void push_back(const value_type& v);
 // void pop_back();
 // void pop_front();
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 C

 void test(int size)
 {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int j = 0; j < N; ++j)
     {
         C c = make<C>(size, rng[j]);
         typename C::const_iterator it = c.begin();
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         for (int i = 0; i < size; ++i, ++it)
             assert(*it == i);
     }
 }
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.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
 
 // <deque>
 
 // void push_back(value_type&& v);
 // void pop_back();
 // void pop_front();
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
 

 void test(int size)
 {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int j = 0; j < N; ++j)
     {
         C c = make<C>(size, rng[j]);
         typename C::const_iterator it = c.begin();
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c));
         for (int i = 0; i < size; ++i, (void) ++it)
             assert(*it == MoveOnly(i));
     }
 }
 
 
 int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int j = 0; j < N; ++j)
         test<std::deque<MoveOnly> >(rng[j]);
     }
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int j = 0; j < N; ++j)
         test<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[j]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int j = 0; j < N; ++j)
+        test<std::deque<MoveOnly, safe_allocator<MoveOnly>> >(rng[j]);
+    }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void push_front(const value_type& v);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>

 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.push_front(x);
     assert(c1.size() == c1_osize + 1);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     assert(*i == x);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     ++i;
     for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)

 #if TEST_STD_VER >= 11
    {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
+    {
+    int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+    const int N = sizeof(rng)/sizeof(rng[0]);
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j)
+            testN<std::deque<int, safe_allocator<int>> >(rng[i], rng[j]);
+    }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.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
 
 // <deque>
 
 // void push_front(value_type&& v);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 

 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.push_front(MoveOnly(x));
     assert(c1.size() == c1_osize + 1);
     assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     assert(*i == MoveOnly(x));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
     ++i;
     for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
 }
 
 template <class C>
 void
 testN(int start, int N)
for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             testN<std::deque<MoveOnly> >(rng[i], rng[j]);
     }
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
-            testN<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[i], rng[j]);
+            testN<std::deque<MoveOnly, safe_allocator<MoveOnly>> >(rng[i], rng[j]);
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.special/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // Optimization for deque::iterators
 
 // template <class InputIterator, class OutputIterator>
 //   OutputIterator
 //   copy(InputIterator first, InputIterator last, OutputIterator result);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C>
void testN(int start, int N)
     typedef typename C::const_iterator CI;
     typedef random_access_iterator<I> RAI;
     typedef random_access_iterator<CI> RACI;
     typedef cpp17_input_iterator<CI> ICI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::copy(c1.cbegin(), c1.cend(), c2.begin()) == c2.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy(c2.cbegin(), c2.cend(), c1.begin()) == c1.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy(c1.cbegin(), c1.cend(), RAI(c2.begin())) == RAI(c2.end()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy(c2.cbegin(), c2.cend(), RAI(c1.begin())) == RAI(c1.end()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy(RACI(c1.cbegin()), RACI(c1.cend()), c2.begin()) == c2.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy(ICI(c2.cbegin()), ICI(c2.cend()), c1.begin()) == c1.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
 }
 
 int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)

libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // Optimization for deque::iterators
 
 // template <class InputIterator, class OutputIterator>
 //   OutputIterator
 //   copy_backward(InputIterator first, InputIterator last, OutputIterator result);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C>
void testN(int start, int N)
     typedef typename C::iterator I;
     typedef typename C::const_iterator CI;
     typedef random_access_iterator<I> RAI;
     typedef random_access_iterator<CI> RACI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::copy_backward(c1.cbegin(), c1.cend(), c2.end()) == c2.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy_backward(c2.cbegin(), c2.cend(), c1.end()) == c1.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy_backward(c1.cbegin(), c1.cend(), RAI(c2.end())) == RAI(c2.begin()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy_backward(c2.cbegin(), c2.cend(), RAI(c1.end())) == RAI(c1.begin()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy_backward(RACI(c1.cbegin()), RACI(c1.cend()), c2.end()) == c2.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::copy_backward(RACI(c2.cbegin()), RACI(c2.cend()), c1.end()) == c1.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
 }
 
 int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)

libcxx/test/std/containers/sequences/deque/deque.special/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // Optimization for deque::iterators
 
 // template <class InputIterator, class OutputIterator>
 //   OutputIterator
 //   move(InputIterator first, InputIterator last, OutputIterator result);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C>
void testN(int start, int N)
     typedef typename C::iterator I;
     typedef typename C::const_iterator CI;
     typedef random_access_iterator<I> RAI;
     typedef random_access_iterator<CI> RACI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::move(c1.cbegin(), c1.cend(), c2.begin()) == c2.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move(c2.cbegin(), c2.cend(), c1.begin()) == c1.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move(c1.cbegin(), c1.cend(), RAI(c2.begin())) == RAI(c2.end()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move(c2.cbegin(), c2.cend(), RAI(c1.begin())) == RAI(c1.end()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move(RACI(c1.cbegin()), RACI(c1.cend()), c2.begin()) == c2.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move(RACI(c2.cbegin()), RACI(c2.cend()), c1.begin()) == c1.end());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
 }
 
 int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)

libcxx/test/std/containers/sequences/deque/deque.special/move_backward.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // Optimization for deque::iterators
 
 // template <class InputIterator, class OutputIterator>
 //   OutputIterator
 //   move_backward(InputIterator first, InputIterator last, OutputIterator result);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C>
void testN(int start, int N)
     typedef typename C::iterator I;
     typedef typename C::const_iterator CI;
     typedef random_access_iterator<I> RAI;
     typedef random_access_iterator<CI> RACI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::move_backward(c1.cbegin(), c1.cend(), c2.end()) == c2.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move_backward(c2.cbegin(), c2.cend(), c1.end()) == c1.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move_backward(c1.cbegin(), c1.cend(), RAI(c2.end())) == RAI(c2.begin()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move_backward(c2.cbegin(), c2.cend(), RAI(c1.end())) == RAI(c1.begin()));
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move_backward(RACI(c1.cbegin()), RACI(c1.cend()), c2.end()) == c2.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     assert(std::move_backward(RACI(c2.cbegin()), RACI(c2.cend()), c1.end()) == c1.begin());
     assert(c1 == c2);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
 }
 
 int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)

libcxx/test/std/containers/sequences/deque/deque.special/swap.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class T, class A>
 //   void swap(deque<T, A>& x, deque<T, A>& y);
 
+#include "asan_testing.h"
 #include <deque>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 C

 {
     C c1 = make<C>(N, start);
     C c2 = make<C>(M);
     C c1_save = c1;
     C c2_save = c2;
     swap(c1, c2);
     assert(c1 == c2_save);
     assert(c2 == c1_save);
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1_save));
+    LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2_save));
 }
 
 int main(int, char**)
 {
     {
         int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
         const int N = sizeof(rng)/sizeof(rng[0]);
         for (int i = 0; i < N; ++i)
             for (int j = 0; j < N; ++j)
                 for (int k = 0; k < N; ++k)
                     testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef test_allocator<int> A;
         std::deque<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1, 1));
         std::deque<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(1, 2));
         swap(c1, c2);
         assert((c1 == std::deque<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c1.get_allocator().get_id() == 1);
         assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator().get_id() == 2);
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef other_allocator<int> A;
         std::deque<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1));
         std::deque<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2));
         swap(c1, c2);
         assert((c1 == std::deque<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c1.get_allocator() == A(2));
         assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A(1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     }
 #if TEST_STD_VER >= 11
     {
         int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
         const int N = sizeof(rng)/sizeof(rng[0]);
         for (int i = 0; i < N; ++i)
             for (int j = 0; j < N; ++j)
                 for (int k = 0; k < N; ++k)
                     testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef min_allocator<int> A;
         std::deque<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());
         std::deque<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A());
         swap(c1, c2);
         assert((c1 == std::deque<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c1.get_allocator() == A());
         assert((c2 == std::deque<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(c2.get_allocator() == A());
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
+        LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
     }
 #endif
 
   return 0;
 }

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"
+#include <vector>
 
 #if TEST_HAS_FEATURE(address_sanitizer)
 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;
 }
-
 #else
 template <typename T, typename Alloc>
 TEST_CONSTEXPR bool is_contiguous_container_asan_correct ( const std::vector<T, Alloc> &)
 {
     return true;
 }
-#endif
+#endif // TEST_HAS_FEATURE(address_sanitizer)
 
+#if TEST_HAS_FEATURE(address_sanitizer) && _LIBCPP_CLANG_VER >= 1600
+extern "C" int __sanitizer_verify_double_ended_contiguous_container(
+    const void* beg, const void* con_beg, const void* con_end, const void* end);
+extern "C" bool __sanitizer_is_annotable(const void* address, const unsigned long size);
+#include <deque>
+
+template <class T, class Alloc>
+TEST_CONSTEXPR bool is_double_ended_contiguous_container_asan_correct(const std::deque<T, Alloc>& c) {
+  if (TEST_IS_CONSTANT_EVALUATED)
+    return true;
+  if (std::is_same<Alloc, std::allocator<T> >::value)
+    return c.__verify_asan_annotations();
+  return true;
+}
+#else
+#  include <deque>
+template <class T, class Alloc>
+TEST_CONSTEXPR bool is_double_ended_contiguous_container_asan_correct(const std::deque<T, Alloc>&) {
+  return true;
+}
+#endif
 
 #endif // ASAN_TESTING_H