Re-enable ASAN string annotations

stl/inc/vector

@@ -539,29 +539,6 @@ private:
         _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Mylast, _My_data._Mylast + _Count);
     }
 
-    _NODISCARD static const void* _Get_aligned_first(const void* _First, const void* _End) noexcept {
-        const auto _CFirst     = reinterpret_cast<const char*>(_First);
-        const auto _CEnd       = reinterpret_cast<const char*>(_End);
-        const size_t _Capacity = static_cast<size_t>(_CEnd - _CFirst);
-
-        if (_Capacity >= _Asan_granularity) {
-            // We are guaranteed to have sufficient space to find an aligned address.
-            return reinterpret_cast<const void*>(
-                (reinterpret_cast<uintptr_t>(_CFirst) + (_Asan_granularity - 1)) & ~(_Asan_granularity - 1));
-        }
-
-        uintptr_t _Alignment_offset = reinterpret_cast<uintptr_t>(_CFirst) & (_Asan_granularity - 1);
-        if (_Alignment_offset != 0) {
-            _Alignment_offset = _Asan_granularity - _Alignment_offset;
-        }
-
-        if (_Capacity > _Alignment_offset) {
-            return _CFirst + _Alignment_offset;
-        }
-
-        return nullptr;
-    }
-
     static _CONSTEXPR20 void _Apply_annotation(
         pointer _First_, pointer _End_, pointer _Old_last_, pointer _New_last_) noexcept {
         _STL_INTERNAL_CHECK(_First_ != nullptr);
@@ -579,24 +556,22 @@ private:
             return;
         }
 
-        const auto _First    = reinterpret_cast<const char*>(_Unfancy(_First_));
-        const auto _End      = reinterpret_cast<const char*>(_Unfancy(_End_));
-        const auto _Old_last = reinterpret_cast<const char*>(_Unfancy(_Old_last_));
-        const auto _New_last = reinterpret_cast<const char*>(_Unfancy(_New_last_));
-        if constexpr (_Has_minimum_allocation_alignment<vector>) {
+        const void* const _First    = _STD _Unfancy(_First_);
+        const void* const _End      = _STD _Unfancy(_End_);
+        const void* const _Old_last = _STD _Unfancy(_Old_last_);
+        const void* const _New_last = _STD _Unfancy(_New_last_);
+        if constexpr ((_Container_allocation_minimum_alignment<vector>) > _Asan_granularity) {
             __sanitizer_annotate_contiguous_container(_First, _End, _Old_last, _New_last);
         } else {
-            const void* const _Aligned_first = _Get_aligned_first(_First, _End);
-            if (!_Aligned_first) {
-                // There is no aligned address within the underlying buffer; nothing to do.
+            const auto _Aligned = _STD _Get_asan_aligned_first_last(_First, _End);
+            if (!_Aligned._First) {
+                // The buffer does not cover at least a full shadow memory section; nothing to do.
                 return;
             }
 
-            const void* const _Aligned_old_last = _Old_last < _Aligned_first ? _Aligned_first : _Old_last;
-            const void* const _Aligned_new_last = _New_last < _Aligned_first ? _Aligned_first : _New_last;
-            const void* const _Aligned_end      = _End < _Aligned_first ? _Aligned_first : _End;
-            __sanitizer_annotate_contiguous_container(
-                _Aligned_first, _Aligned_end, _Aligned_old_last, _Aligned_new_last);
+            const void* const _Old_fixed = _Aligned._Clamp(_Old_last);
+            const void* const _New_fixed = _Aligned._Clamp(_New_last);
+            __sanitizer_annotate_contiguous_container(_Aligned._First, _Aligned._End, _Old_fixed, _New_fixed);
         }
     }
 

stl/inc/xmemory

@@ -776,6 +776,63 @@ _NODISCARD constexpr allocation_result<typename allocator_traits<_Alloc>::pointe
 // The number of user bytes a single byte of ASAN shadow memory can track.
 _INLINE_VAR constexpr size_t _Asan_granularity = 8;
 
+struct _AsanAlignedPointers {
+    const void* _First;
+    const void* _End;
+
+    constexpr const void* _Clamp(const void* _Mid) const noexcept {
+        if (_Mid < _First) {
+            return _First;
+        } else if (_Mid > _End) {
+            return _End;
+        } else {
+            return _Mid;
+        }
+    }
+};
+// Returns {nullptr, nullptr} if [_First, _Last) does not cover a full ASAN shadow memory section.
+// `__sanitizer_annotate_contiguous_container` _requires_
+// its first pointer to be aligned to the beginning of an ASAN shadow memory section (a single 8-byte).
+// When the `end` pointer is not on a boundary, it will also mark the remainder of the section.
+// This means that if you have, for example:
+// struct alignas(8) cat {
+//    int meow; // bytes [0, 4)
+//    char buffer[16]; // bytes [4, 20)
+//    int purr; // bytes [20, 24)
+// };
+// you cannot mark `buffer + [0, 4)`, since `buffer + 0` doesn't start a shadow memory section
+// (i.e., it's not on an 8-byte boundary).
+// Additionally, if you attempt to mark up to `buffer + 16` (the real end of buffer), it'll also mark `purr`.
+// Thus, the only part you can _actually_ mark is the complete shadow memory section of `buffer + [4, 12)`
+// (i.e., bytes [8, 16)).
+_NODISCARD inline _AsanAlignedPointers _Get_asan_aligned_first_last(
+    const void* const _First, const void* const _Last) noexcept {
+    constexpr static uintptr_t _Mask = ~(_Asan_granularity - 1);
+
+    const auto _First_address = reinterpret_cast<uintptr_t>(_First);
+    const auto _Last_address  = reinterpret_cast<uintptr_t>(_Last);
+
+    const uintptr_t _Aligned_first_address = (_First_address + _Asan_granularity - 1) & _Mask;
+    const uintptr_t _Aligned_last_address  = _Last_address & _Mask;
+
+    if (_Aligned_first_address == _Aligned_last_address) {
+        return {nullptr, nullptr};
+    } else {
+        return {
+            reinterpret_cast<const void*>(_Aligned_first_address),
+            reinterpret_cast<const void*>(_Aligned_last_address),
+        };
+    }
+}
+
+template <class _Container, class = void>
+_INLINE_VAR constexpr size_t _Container_allocation_minimum_alignment = alignof(typename _Container::value_type);
+
+template <class _Container>
+_INLINE_VAR constexpr size_t _Container_allocation_minimum_alignment<_Container,
+    void_t<decltype(_Container::allocator_type::_Minimum_allocation_alignment)>> =
+    (_STD max)(alignof(typename _Container::value_type), _Container::allocator_type::_Minimum_allocation_alignment);
+
 _EXPORT_STD template <class _Ty>
 class allocator {
 public: