Cleanup __uninitialized_temporary_buffer internals.

[EricWF]

Summary

There are a few improvements this patch makes. First, it only
uses aligned allocation when the type actually requires it. This
addresses a sizable user-reported performance regression in some of the
algorithms.

Second, it removes a significant amount unused template & function parameters,
which improves code size and makes the type less error prone and more readable.

And finally, it fixes a bug where operator new/delete were being called
directly, rather than as a builtin -- preventing the compiler from
eliding the allocation.

[EricWF]

Sorry, I'm trying to upload to the existing review.

libcxx/include/__algorithm/inplace_merge.h

 __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
               _Compare&& __comp)
 {
     typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
     typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
     difference_type __len1 = _IterOps<_AlgPolicy>::distance(__first, __middle);
     difference_type __len2 = _IterOps<_AlgPolicy>::distance(__middle, __last);
     difference_type __buf_size = _VSTD::min(__len1, __len2);
-    auto __buf = std::__make_uninitialized_buffer<value_type[]>(nothrow, __buf_size);
+    auto __buf = std::__maybe_allocate_uninitialized_buffer<value_type>(__buf_size);
     return std::__inplace_merge<_AlgPolicy>(
         std::move(__first),
         std::move(__middle),
         std::move(__last),
         __comp,
         __len1,
         __len2,
         __buf.get(),

libcxx/include/__algorithm/stable_partition.h

while (true)
         if (!__pred(*__first))
             break;
         ++__first;
     }
     // We now have a reduced range [__first, __last)
     // *__first is known to be false
     difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last);
 
-    __uninitialized_buffer_t<value_type[]> __buf;
+    __uninitialized_buffer_t<value_type> __buf;
     if (__len >= __alloc_limit)
-        __buf = std::__make_uninitialized_buffer<value_type[]>(nothrow, __len);
+        __buf = std::__maybe_allocate_uninitialized_buffer<value_type>(__len);
 
     return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
         std::move(__first),
         std::move(__last),
         __pred,
         __len,
         std::make_pair(__buf.get(), __buf ? __len : 0),
         forward_iterator_tag());
do
         if (__first == --__last)
             return __first;
     } while (!__pred(*__last));
     // We now have a reduced range [__first, __last]
     // *__first is known to be false
     // *__last is known to be true
     // __len >= 2
     difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last) + 1;
-    __uninitialized_buffer_t<value_type[]> __buf;
+    __uninitialized_buffer_t<value_type> __buf;
     if (__len >= __alloc_limit)
-        __buf = std::__make_uninitialized_buffer<value_type[]>(nothrow, __len);
+        __buf = std::__maybe_allocate_uninitialized_buffer<value_type>(__len);
 
     return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
         std::move(__first),
         std::move(__last),
         __pred,
         __len,
         std::make_pair(__buf.get(), __buf ? __len : 0),
         bidirectional_iterator_tag());

libcxx/include/__algorithm/stable_sort.h

 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
 inline _LIBCPP_HIDE_FROM_ABI
 void __stable_sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) {
   using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
   using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
 
   difference_type __len = __last - __first;
-  __uninitialized_buffer_t<value_type[]> __buf;
+
+  __uninitialized_buffer_t<value_type> __buf;
   if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value))
-        __buf = std::__make_uninitialized_buffer<value_type[]>(nothrow, __len);
+        __buf = std::__maybe_allocate_uninitialized_buffer<value_type>(__len);
 
   std::__stable_sort<_AlgPolicy, __comp_ref_type<_Compare> >(
       __first, __last, __comp, __len, __buf.get(), __buf ? __len : 0);
   std::__check_strict_weak_ordering_sorted(__first, __last, __comp);
 }
 
 template <class _RandomAccessIterator, class _Compare>
 inline _LIBCPP_HIDE_FROM_ABI

libcxx/include/__memory/uninitialized_buffer.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 _LIBCPP___MEMORY_UNINITIALIZED_BUFFER_H
 #define _LIBCPP___MEMORY_UNINITIALIZED_BUFFER_H
 
 #include <__config>
-#include <__memory/construct_at.h>
 #include <__memory/unique_ptr.h>
-#include <__type_traits/is_array.h>
-#include <__type_traits/is_default_constructible.h>
-#include <__type_traits/remove_extent.h>
 #include <__utility/move.h>
 #include <cstddef>
 #include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-// __make_uninitialized_buffer is a utility function to allocate some memory for scratch storage. The __destructor is
-// called before deleting the memory, making it possible to destroy any leftover elements. The __destructor is called
-// with the pointer to the first element and the total number of elements.
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Destructor>
 class __uninitialized_buffer_deleter {
   size_t __count_;
-  _Destructor __destructor_;
 
 public:
-  template <class _Dummy = int, __enable_if_t<is_default_constructible<_Destructor>::value, _Dummy> = 0>
-  _LIBCPP_HIDE_FROM_ABI __uninitialized_buffer_deleter() : __count_(0) {}
-
-  _LIBCPP_HIDE_FROM_ABI __uninitialized_buffer_deleter(size_t __count, _Destructor __destructor)
-      : __count_(__count), __destructor_(std::move(__destructor)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR __uninitialized_buffer_deleter(size_t __count = 0) _NOEXCEPT
+      : __count_(__count) {}
 
   template <class _Tp>
-  _LIBCPP_HIDE_FROM_ABI void operator()(_Tp* __ptr) {
-    __destructor_(__ptr, __count_);
-#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-    ::operator delete(__ptr);
-#else
-    ::operator delete(__ptr, __count_ * sizeof(_Tp), align_val_t(_LIBCPP_ALIGNOF(_Tp)));
-#endif
+  _LIBCPP_HIDE_FROM_ABI void operator()(_Tp* __ptr) const _NOEXCEPT {
+    std::__libcpp_deallocate(__ptr, __count_ * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 };
 
-struct __noop {
-  template <class... _Args>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void operator()(_Args&&...) const {}
-};
-
-template <class _Array, class _Destructor = __noop>
-using __uninitialized_buffer_t = unique_ptr<_Array, __uninitialized_buffer_deleter<_Destructor> >;
+template <class _Tp>
+using __uninitialized_buffer_t = unique_ptr<_Tp, __uninitialized_buffer_deleter>;
 
-template <class _Array, class _Destructor = __noop>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI __uninitialized_buffer_t<_Array, _Destructor>
-__make_uninitialized_buffer(nothrow_t, size_t __count, _Destructor __destructor = __noop()) {
-  static_assert(is_array<_Array>::value, "");
-  using _Tp = __remove_extent_t<_Array>;
-
-#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-  _Tp* __ptr = static_cast<_Tp*>(::operator new(sizeof(_Tp) * __count, nothrow));
-#else
-  _Tp* __ptr = static_cast<_Tp*>(::operator new(sizeof(_Tp) * __count, align_val_t(_LIBCPP_ALIGNOF(_Tp)), nothrow));
-#endif
+/**
+ * __maybe_allocate_uninitialized_buffer
+ *
+ * Attempt to allocate an uninitialized buffer of `__count` elements of type `_Tp`..
+ * In case of allocation failure, the returned object will contain a nullptr and count 0.
+ *
+ * Attention points:
+ *
+ * 1. No initialization or destruction of elements:
+ *    It is the callers responsibility to manage both construction and destruction of the elements created
+ *    in the buffer.
+ *
+ * 2. No exception on allocation failure:
+ *    Instead it returns nullptr when an allocation failure occurs. It is the callers responsibility
+ *    to check for and handle this case.
+ */
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI __uninitialized_buffer_t<_Tp>
+__maybe_allocate_uninitialized_buffer(size_t __count) {
+  _Tp* __ptr = static_cast<_Tp*>(std::__libcpp_allocate(sizeof(_Tp) * __count, _LIBCPP_ALIGNOF(_Tp), nothrow));
 
-  using _Deleter = __uninitialized_buffer_deleter<_Destructor>;
-  return unique_ptr<_Array, _Deleter>(__ptr, _Deleter(__count, std::move(__destructor)));
+  using _Deleter = __uninitialized_buffer_deleter;
+  return __uninitialized_buffer_t<_Tp>(__ptr, _Deleter(__ptr ? __count : 0));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_UNINITIALIZED_BUFFER_H

libcxx/include/new

if (__is_overaligned_for_new(__align)) {
     return __libcpp_operator_new(__size, __align_val);
   }
 #endif
 
   (void)__align;
   return __libcpp_operator_new(__size);
 }
 
+inline _LIBCPP_HIDE_FROM_ABI
+void *__libcpp_allocate(size_t __size, size_t __align, nothrow_t) {
+#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+  if (__is_overaligned_for_new(__align)) {
+    const align_val_t __align_val = static_cast<align_val_t>(__align);
+    return __libcpp_operator_new(__size, __align_val, nothrow);
+  }
+#endif
+
+  (void)__align;
+  return __libcpp_operator_new(__size, nothrow);
+}
+
 template <class ..._Args>
 _LIBCPP_INLINE_VISIBILITY
 void __do_deallocate_handle_size(void *__ptr, size_t __size, _Args ...__args) {
 #ifdef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
   (void)__size;
   return std::__libcpp_operator_delete(__ptr, __args...);
 #else
   return std::__libcpp_operator_delete(__ptr, __size, __args...);