[libc++] Clean up logic around aligned/sized allocation and deallocation

[ldionne]

Summary

Due to the need to support compilers that implement builtin operator
new/delete but not their align_val_t overloaded versions, there was a
lot of complexity. By assuming that a compiler that supports the builtin
new/delete operators also supports their align_val_t overloads, the code
can be simplified quite a bit.

[ldionne]

This should be NFC (except it means that Clangs older than 201802L are not supported anymore). @EricWF I would love if you could take a look.

[ldionne]

Rebase onto master to try to get pre-commit testing

[hubert.reinterpretcast]

I don't think this patch makes sense given D87611. @Kai, @fanbo-meng, @abhina.sreeskantharajan, @zibi, fya.

<stdin>:6:3: error: aligned allocation function of type 'void *(unsigned long, enum std::align_val_t)' is not available on z/OS
  __builtin_operator_new(sizeof(int), static_cast<std::align_val_t>(16));
  ^

[ldionne]

In D88301#2295416, @hubert.reinterpretcast wrote:

I don't think this patch makes sense given D87611. @Kai, @fanbo-meng, @abhina.sreeskantharajan, @zibi, fya.

<stdin>:6:3: error: aligned allocation function of type 'void *(unsigned long, enum std::align_val_t)' is not available on z/OS
  __builtin_operator_new(sizeof(int), static_cast<std::align_val_t>(16));
  ^

I think it does. The issue is that we're not detecting _LIBCPP_HAS_NO_ALIGNED_ALLOCATION properly.

That macro is defined as:

#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) && \
    (defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) || \
    (!defined(__cpp_aligned_new) || __cpp_aligned_new < 201606))
#  define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
#endif

What is __cpp_aligned_new set to on z/OS?

[hubert.reinterpretcast]

In D88301#2295423, @ldionne wrote:

I think it does. The issue is that we're not detecting _LIBCPP_HAS_NO_ALIGNED_ALLOCATION properly.

Thanks for the quick response. I was checking whether or not Clang reliably has the aligned builtin operator new based on my reading of the patch description:

excerpt:

By assuming that a compiler that supports the builtin new/delete operators also supports their align_val_t overloads, the code can be simplified quite a bit.

If libc++ still checks __cpp_aligned_new, then the patch should be okay.

What is __cpp_aligned_new set to on z/OS?

It's not defined. The detection for _LIBCPP_HAS_NO_ALIGNED_ALLOCATION should work okay.

[zibi]

What is __cpp_aligned_new set to on z/OS?

It's not defined. The detection for _LIBCPP_HAS_NO_ALIGNED_ALLOCATION should work okay.

Yes its not defined however, with -std=c++17 _LIBCPP_HAS_NO_ALIGNED_ALLOCATION is defined on z/OS.

[zibi]

In D88301#2295423, @ldionne wrote:

That macro is defined as:

#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) && \
    (defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) || \
    (!defined(__cpp_aligned_new) || __cpp_aligned_new < 201606))
#  define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
#endif

What is __cpp_aligned_new set to on z/OS?

The __cpp_aligned_new is defined as 201616 on z/OS. However, z/OS will define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION explicitly and both macros '_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION and _LIBCPP_HAS_NO_ALIGNED_ALLOCATION will be defined. That is one of the upcoming change or you can do it here as I suggested on line 948 in __config.

libcxx/include/__config

951

`# define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
#elif defined(MVS)

1. define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION`

[ldionne]

Rebase onto master

libcxx/include/__config

 
 #if __has_feature(cxx_explicit_conversions) || defined(__IBMCPP__) || \
     (!defined(_LIBCPP_CXX03_LANG) && defined(__GNUC__)) // All supported GCC versions
 #  define _LIBCPP_EXPLICIT explicit
 #else
 #  define _LIBCPP_EXPLICIT
 #endif
 
-#if !__has_builtin(__builtin_operator_new) || !__has_builtin(__builtin_operator_delete)
-#define _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
-#endif
-
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 #  define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx
 #  define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
      __lx __v_; \
      _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \
      _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
      _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} \
      };
#  if !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
       defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
 #    define __MAC_OS_X_VERSION_MIN_REQUIRED __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
 #  endif
 #endif // defined(__APPLE__)
 
 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) && \
     (defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) || \
     (!defined(__cpp_aligned_new) || __cpp_aligned_new < 201606))
 #  define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
 #endif
 
 #if defined(__APPLE__) || defined(__FreeBSD__)
 #define _LIBCPP_HAS_DEFAULTRUNELOCALE
 #endif
 
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)
 #define _LIBCPP_WCTYPE_IS_MASK

libcxx/include/new

 # define _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
 #endif
 
 #if defined(_LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION) || \
     defined(_LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION)
 # define _LIBCPP_HAS_NO_SIZED_DEALLOCATION
 #endif
 
-#if !__has_builtin(__builtin_operator_new) || \
-   __has_builtin(__builtin_operator_new) < 201802L
-#define _LIBCPP_HAS_NO_BUILTIN_OVERLOADED_OPERATOR_NEW_DELETE
-#endif
-
 namespace std  // purposefully not using versioning namespace
 {
 
 #if !defined(_LIBCPP_ABI_VCRUNTIME)
 struct _LIBCPP_TYPE_VIS nothrow_t { explicit nothrow_t() = default; };
 extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
 
 class _LIBCPP_EXCEPTION_ABI bad_alloc

 _LIBCPP_CONSTEXPR inline _LIBCPP_INLINE_VISIBILITY bool __is_overaligned_for_new(size_t __align) _NOEXCEPT {
 #ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
   return __align > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
 #else
   return __align > alignment_of<max_align_t>::value;
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-void *__libcpp_allocate(size_t __size, size_t __align) {
-#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-  if (__is_overaligned_for_new(__align)) {
-    const align_val_t __align_val = static_cast<align_val_t>(__align);
-# ifdef _LIBCPP_HAS_NO_BUILTIN_OVERLOADED_OPERATOR_NEW_DELETE
-    return ::operator new(__size, __align_val);
-# else
-    return __builtin_operator_new(__size, __align_val);
-# endif
-  }
-#else
-  ((void)__align);
-#endif
-#ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
-  return ::operator new(__size);
-#else
-  return __builtin_operator_new(__size);
+template <class ..._Args>
+_LIBCPP_INLINE_VISIBILITY
+void* __libcpp_operator_new(_Args ...__args) {
+#if __has_builtin(__builtin_operator_new) && __has_builtin(__builtin_operator_delete)
+  return __builtin_operator_new(__args...);
+#else
+  return ::operator new(__args...);
 #endif
 }
 
-struct _DeallocateCaller {
-  template <class _A1, class _A2>
-  static inline void __do_call(void *__ptr, _A1 __a1, _A2 __a2) {
-#if defined(_LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE) || \
-    defined(_LIBCPP_HAS_NO_BUILTIN_OVERLOADED_OPERATOR_NEW_DELETE)
-    return ::operator delete(__ptr, __a1, __a2);
+template <class ..._Args>
+_LIBCPP_INLINE_VISIBILITY
+void __libcpp_operator_delete(_Args ...__args) {
+#if __has_builtin(__builtin_operator_new) && __has_builtin(__builtin_operator_delete)
+  __builtin_operator_delete(__args...);
 #else
-    return __builtin_operator_delete(__ptr, __a1, __a2);
+  ::operator delete(__args...);
 #endif
-  }
 
-  template <class _A1>
-  static inline void __do_call(void *__ptr, _A1 __a1) {
-#if defined(_LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE) || \
-    defined(_LIBCPP_HAS_NO_BUILTIN_OVERLOADED_OPERATOR_NEW_DELETE)
-    return ::operator delete(__ptr, __a1);
-#else
-    return __builtin_operator_delete(__ptr, __a1);
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
+void *__libcpp_allocate(size_t __size, size_t __align) {
+#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);
   }
-
-  static inline void __do_call(void *__ptr) {
-#ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
-    return ::operator delete(__ptr);
-#else
-    return __builtin_operator_delete(__ptr);
 #endif
-  }
 
-  static inline void __do_deallocate_handle_size(void *__ptr, size_t __size) {
-#ifdef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
-    ((void)__size);
-    return __do_call(__ptr);
-#else
-    return __do_call(__ptr, __size);
-#endif
-  }
+  (void)__align;
+  return __libcpp_operator_new(__size);
 
-#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-  static inline void __do_deallocate_handle_size(void *__ptr, size_t __size, align_val_t __align) {
+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 __do_call(__ptr, __align);
+  (void)__size;
+  return __libcpp_operator_delete(__ptr, __args...);
 #else
-    return __do_call(__ptr, __size, __align);
+  return __libcpp_operator_delete(__ptr, __size, __args...);
 #endif
-  }
-#endif
 
-  static inline _LIBCPP_INLINE_VISIBILITY
-  void __do_deallocate_handle_size_align(void *__ptr, size_t __size, size_t __align) {
+inline _LIBCPP_INLINE_VISIBILITY
+void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) {
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-    ((void)__align);
+    (void)__align;
     return __do_deallocate_handle_size(__ptr, __size);
 #else
     if (__is_overaligned_for_new(__align)) {
       const align_val_t __align_val = static_cast<align_val_t>(__align);
       return __do_deallocate_handle_size(__ptr, __size, __align_val);
     } else {
       return __do_deallocate_handle_size(__ptr, __size);
     }
 #endif
-  }
 
-  static inline _LIBCPP_INLINE_VISIBILITY
-  void __do_deallocate_handle_align(void *__ptr, size_t __align) {
+inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate_unsized(void* __ptr, size_t __align) {
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-    ((void)__align);
-    return __do_call(__ptr);
+    (void)__align;
+    return __libcpp_operator_delete(__ptr);
 #else
     if (__is_overaligned_for_new(__align)) {
       const align_val_t __align_val = static_cast<align_val_t>(__align);
-      return __do_call(__ptr, __align_val);
+      return __libcpp_operator_delete(__ptr, __align_val);
     } else {
-      return __do_call(__ptr);
+      return __libcpp_operator_delete(__ptr);
     }
 #endif
-  }
-};
-
-inline _LIBCPP_INLINE_VISIBILITY
-void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) {
-  _DeallocateCaller::__do_deallocate_handle_size_align(__ptr, __size, __align);
-}
-
-inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate_unsized(void* __ptr, size_t __align) {
-  _DeallocateCaller::__do_deallocate_handle_align(__ptr, __align);
-}
 
 template <class _Tp>
 _LIBCPP_NODISCARD_AFTER_CXX17 inline
 _LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT
 {
     static_assert (!(is_function<_Tp>::value), "can't launder functions" );
     static_assert (!(is_same<void, typename remove_cv<_Tp>::type>::value), "can't launder cv-void" );
 #ifdef _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER