[libc++] Destroy elements when exceptions are thrown in __construct_at_end

Author: kisuhorikka

libcxx/include/__memory/uninitialized_algorithms.h

@@ -124,6 +124,18 @@ uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp&
 
 // uninitialized_fill_n
 
+template <class _Alloc, class _ForwardIterator, class _Size, class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+__uninitialized_allocator_fill_n(_Alloc& __alloc, _ForwardIterator __first, _Size __n, const _Tp& __x) {
+  _ForwardIterator __idx = __first;
+  auto __guard           = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
+  for (; __n > 0; ++__idx, (void)--__n)
+    allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__idx), __x);
+  __guard.__complete();
+
+  return __idx;
+}
+
 template <class _ValueType, class _ForwardIterator, class _Size, class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
 __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) {
@@ -143,6 +155,20 @@ uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) {
   return std::__uninitialized_fill_n<_ValueType>(__first, __n, __x);
 }
 
+// __uninitialized_allocator_value_construct_n
+
+template <class _Alloc, class _ForwardIterator, class _Size>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+__uninitialized_allocator_value_construct_n(_Alloc& __alloc, _ForwardIterator __first, _Size __n) {
+  auto __idx   = __first;
+  auto __guard = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
+  for (; __n > 0; ++__idx, (void)--__n)
+    allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__idx));
+  __guard.__complete();
+
+  return __idx;
+}
+
 #if _LIBCPP_STD_VER >= 17
 
 // uninitialized_default_construct

libcxx/include/__vector/vector.h

@@ -941,10 +941,7 @@ vector<_Tp, _Allocator>::__recommend(size_type __new_size) const {
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__construct_at_end(size_type __n) {
   _ConstructTransaction __tx(*this, __n);
-  const_pointer __new_end = __tx.__new_end_;
-  for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
-    __alloc_traits::construct(this->__alloc_, std::__to_address(__pos));
-  }
+  __tx.__pos_ = std::__uninitialized_allocator_value_construct_n(this->__alloc_, this->__end_, __n);
 }
 
 //  Copy constructs __n objects starting at __end_ from __x
@@ -957,10 +954,7 @@ template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) {
   _ConstructTransaction __tx(*this, __n);
-  const_pointer __new_end = __tx.__new_end_;
-  for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
-    __alloc_traits::construct(this->__alloc_, std::__to_address(__pos), __x);
-  }
+  __tx.__pos_ = std::__uninitialized_allocator_fill_n(this->__alloc_, this->__end_, __n, __x);
 }
 
 template <class _Tp, class _Allocator>

libcxx/test/std/containers/sequences/vector/common.h

@@ -260,4 +260,70 @@ inline std::vector<std::string> getStringInputsWithLength(std::size_t n, std::si
   return v;
 }
 
+struct leak_throw_context {
+  leak_throw_context(int lim = 2) {
+    num()   = 0;
+    limit() = lim;
+  }
+
+  static int& num() {
+    static int n = 0;
+    return n;
+  }
+
+  static int& limit() {
+    static int lim = 0;
+    return lim;
+  }
+
+  static void inc() {
+    ++num();
+    if (num() >= limit()) {
+      --num();
+      throw 1;
+    }
+  }
+
+  static void dec() { --num(); }
+};
+
+class leak_throw_t {
+public:
+  leak_throw_t() : data(new int(1)) {
+    try {
+      leak_throw_context::inc();
+    } catch (int) {
+      delete data;
+      throw;
+    }
+  }
+
+  leak_throw_t(leak_throw_t const&) : data(new int(1)) {
+    try {
+      leak_throw_context::inc();
+    } catch (int) {
+      delete data;
+      throw;
+    }
+  }
+
+  ~leak_throw_t() {
+    if (data) {
+      delete data;
+      leak_throw_context::dec();
+    }
+  }
+
+  leak_throw_t& operator=(leak_throw_t const&) { return *this; }
+
+private:
+  int* data;
+};
+
+#ifdef DISABLE_NEW_COUNT
+#  define CHECK_NEW_DELETE_DIFF(...)
+#else
+#  define CHECK_NEW_DELETE_DIFF(__n) assert(globalMemCounter.new_called == globalMemCounter.delete_called + __n)
+#endif
+
 #endif // TEST_STD_CONTAINERS_SEQUENCES_VECTOR_COMMON_H

libcxx/test/std/containers/sequences/vector/vector.capacity/resize_size_exceptions.pass.cpp

@@ -384,11 +384,47 @@ void test_move_ctor_exceptions() {
 
 #endif
 
+void test_resize_exception_leak() {
+  // Test whether __construct_at_end leaks when exception
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#  if TEST_STD_VER >= 11
+  {
+    // cap < size
+    leak_throw_context ctx;
+    std::vector<leak_throw_t> v;
+    v.reserve(5);
+    try {
+      v.resize(4);
+    } catch (int) {
+    }
+    CHECK_NEW_DELETE_DIFF(1);
+  }
+  check_new_delete_called();
+
+  // void resize(size_type __sz, const_reference __x)
+  {
+    // cap < size
+    leak_throw_context ctx(3);
+    std::vector<leak_throw_t> v;
+    v.reserve(5);
+    try {
+      leak_throw_t e;
+      v.resize(4, e);
+    } catch (int) {
+    }
+    CHECK_NEW_DELETE_DIFF(1);
+  }
+  check_new_delete_called();
+#  endif
+#endif
+}
+
 int main(int, char**) {
   test_allocation_exceptions();
   test_default_ctor_exceptions();
   test_copy_ctor_exceptions();
 #if TEST_STD_VER >= 11
   test_move_ctor_exceptions();
 #endif
+  test_resize_exception_leak();
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

@@ -16,6 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "allocators.h"
+#include "../common.h"
 
 TEST_CONSTEXPR_CXX20 bool tests() {
   {
@@ -90,10 +91,31 @@ TEST_CONSTEXPR_CXX20 bool tests() {
   return true;
 }
 
+void test_assign_initializer_exception_leak() {
+  // Test whether __construct_at_end leaks when exception
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#  if TEST_STD_VER >= 11
+  {
+    leak_throw_context ctx(5);
+    std::vector<leak_throw_t> v;
+    try {
+      leak_throw_t e;
+      v = {e, e};
+    } catch (int) {
+    }
+    CHECK_NEW_DELETE_DIFF(1);
+  }
+  check_new_delete_called();
+#  endif
+#endif
+}
+
 int main(int, char**) {
   tests();
 #if TEST_STD_VER > 17
   static_assert(tests());
 #endif
+  test_assign_initializer_exception_leak();
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp

@@ -18,6 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
+#include "../common.h"
 
 template <typename Vec>
 TEST_CONSTEXPR_CXX20 void test(Vec& v) {
@@ -51,10 +52,30 @@ TEST_CONSTEXPR_CXX20 bool tests() {
   return true;
 }
 
+void test_assign_initializer_exception_leak() {
+  // Test whether __construct_at_end leaks when exception
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#  if TEST_STD_VER >= 11
+  {
+    leak_throw_context ctx(5);
+    std::vector<leak_throw_t> v;
+    try {
+      leak_throw_t e;
+      v = {e, e};
+    } catch (int) {
+    }
+    CHECK_NEW_DELETE_DIFF(1);
+  }
+  check_new_delete_called();
+#  endif
+#endif
+}
+
 int main(int, char**) {
   tests();
 #if TEST_STD_VER > 17
   static_assert(tests());
 #endif
+  test_assign_initializer_exception_leak();
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp

@@ -22,6 +22,7 @@
 #  include "emplace_constructible.h"
 #  include "container_test_types.h"
 #endif
+#include "../common.h"
 
 TEST_CONSTEXPR_CXX20 bool test() {
 #if TEST_STD_VER >= 11
@@ -175,10 +176,45 @@ TEST_CONSTEXPR_CXX20 bool test() {
   return true;
 }
 
+void test_assign_exception_leak() {
+  // Test whether __construct_at_end leaks when exception
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#  if TEST_STD_VER >= 11
+  {
+    // new size <= cap && new size > size
+    leak_throw_context ctx(4);
+    std::vector<leak_throw_t> v;
+    v.reserve(3);
+    try {
+      std::vector<leak_throw_t> data(2);
+      v.assign(data.begin(), data.end());
+    } catch (int) {
+    }
+    CHECK_NEW_DELETE_DIFF(1);
+  }
+  check_new_delete_called();
+
+  {
+    // new size > cap
+    leak_throw_context ctx(4);
+    std::vector<leak_throw_t> v;
+    try {
+      std::vector<leak_throw_t> data(2);
+      v.assign(data.begin(), data.end());
+    } catch (int) {
+    }
+    CHECK_NEW_DELETE_DIFF(1);
+  }
+  check_new_delete_called();
+#  endif
+#endif
+}
+
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
+  test_assign_exception_leak();
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_from_range.pass.cpp

@@ -17,6 +17,7 @@
 #include "../../from_range_sequence_containers.h"
 #include "asan_testing.h"
 #include "test_macros.h"
+#include "../common.h"
 
 constexpr bool test() {
   for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
@@ -46,6 +47,21 @@ void test_counted_istream_view() {
 }
 #endif
 
+TEST_CONSTEXPR_CXX20 void test_cons_leak() {
+  // Test whether __construct_at_end leaks when exception
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#  if TEST_STD_VER >= 11
+  leak_throw_context ctx(4);
+  try {
+    std::vector<leak_throw_t> r(2);
+    std::vector<leak_throw_t> v(std::from_range, std::views::counted(r.begin(), 2));
+  } catch (int) {
+  }
+  check_new_delete_called();
+#  endif
+#endif
+}
+
 int main(int, char**) {
   static_assert(test_constraints<std::vector, int, double>());
   test();
@@ -59,5 +75,7 @@ int main(int, char**) {
   test_counted_istream_view();
 #endif
 
+  test_cons_leak();
+
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

@@ -23,6 +23,7 @@
 #  include "emplace_constructible.h"
 #  include "container_test_types.h"
 #endif
+#include "../common.h"
 
 template <class C, class Iterator>
 TEST_CONSTEXPR_CXX20 void test(Iterator first, Iterator last) {
@@ -235,11 +236,28 @@ TEST_CONSTEXPR_CXX20 bool tests() {
   return true;
 }
 
+TEST_CONSTEXPR_CXX20 void test_cons_leak() {
+  // Test whether __construct_at_end leaks when exception
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#  if TEST_STD_VER >= 11
+  leak_throw_context ctx(4);
+  try {
+    std::vector<leak_throw_t> v1(2);
+    std::vector<leak_throw_t> v2(v1.begin(), v1.end());
+  } catch (int) {
+  }
+  check_new_delete_called();
+#  endif
+#endif
+}
+
 int main(int, char**) {
   tests();
   test_ctor_under_alloc();
 #if TEST_STD_VER > 17
   static_assert(tests());
 #endif
+
+  test_cons_leak();
   return 0;
 }