Generate warning when over-aligned new call is required but not supported.

[EricWF]

Summary

Currently libc++ silently ignores over-aligned allocation requests
made through __libcpp_allocate when aligned new/delete is not available.

This patch uses the diagnose_if attribute to generate a warning in that
case instead of being silent.

The change required converting __is_overaligned_for_new to a macro
so that the diagnose_if condition is still a potential constant expression in C++03.

[vsapsai]

Does it make sense to have a warning for __libcpp_deallocate and get_temporary_buffer too? Not sure about deallocate as you have allocated memory already and allocation has a warning. So for deallocation a warning can be too noisy. But for get_temporary_buffer the warning seems reasonable, unless I'm missing something.

[EricWF]

In D45013#1052600, @vsapsai wrote:

Does it make sense to have a warning for __libcpp_deallocate and get_temporary_buffer too? Not sure about deallocate as you have allocated memory already and allocation has a warning. So for deallocation a warning can be too noisy. But for get_temporary_buffer the warning seems reasonable, unless I'm missing something.

get_temporary_buffer shouldn't return a temporary buffer when the request is over-aligned and aligned allocation isn't available; so I don't think we should warn on it.

[vsapsai]

In D45013#1053998, @EricWF wrote:

In D45013#1052600, @vsapsai wrote:

Does it make sense to have a warning for __libcpp_deallocate and get_temporary_buffer too? Not sure about deallocate as you have allocated memory already and allocation has a warning. So for deallocation a warning can be too noisy. But for get_temporary_buffer the warning seems reasonable, unless I'm missing something.

get_temporary_buffer shouldn't return a temporary buffer when the request is over-aligned and aligned allocation isn't available; so I don't think we should warn on it.

OK. Makes sense. We don't have data indicating it is a widespread issue that developers forget to address, so no need for the warning. Also get_temporary_buffer is deprecated in C++17, so there is not much value in investing into it.

Overall the change looks good to me, just a few minor NFC tweaks.

include/memory

2030

Is the indentation for these 2 ifs correct? They seem to be aligned with #if and not with while. Don't know if that is intentional.

include/new

235–239

Seems non-critical, maybe put __align in parentheses like (__align) > ...? But I don't know what is libc++ style regarding macro arguments.

include/memory

     const ptrdiff_t __m = (~ptrdiff_t(0) ^
                            ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1)))
                            / sizeof(_Tp);
     if (__n > __m)
         __n = __m;
     while (__n > 0)
     {
 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-    if (__is_overaligned_for_new(__alignof(_Tp)))
+    if (_LIBCPP_IS_OVERALIGNED_FOR_NEW(__alignof(_Tp)))
         {
             std::align_val_t __al =
                 std::align_val_t(std::alignment_of<_Tp>::value);
             __r.first = static_cast<_Tp*>(::operator new(
                 __n * sizeof(_Tp), __al, nothrow));
         } else {
             __r.first = static_cast<_Tp*>(::operator new(
                 __n * sizeof(_Tp), nothrow));
         }
 #else
-    if (__is_overaligned_for_new(__alignof(_Tp)))
+    if (_LIBCPP_IS_OVERALIGNED_FOR_NEW(__alignof(_Tp)))
         {
             // Since aligned operator new is unavailable, return an empty
             // buffer rather than one with invalid alignment.
             return __r;
         }
 
         __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow));
 #endif

include/new

 _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
 inline _LIBCPP_INLINE_VISIBILITY void  operator delete  (void*, void*) _NOEXCEPT {}
 inline _LIBCPP_INLINE_VISIBILITY void  operator delete[](void*, void*) _NOEXCEPT {}
 
 #endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-_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__;
+#define _LIBCPP_IS_OVERALIGNED_FOR_NEW(__align) __align > __STDCPP_DEFAULT_NEW_ALIGNMENT__
 #else
-  return __align > alignment_of<max_align_t>::value;
+#define _LIBCPP_ISOVERALIGNED_FOR_NEW(__align) __align > _VSTD::alignment_of<_VSTD::max_align_t>::value
 #endif
-}
 
-inline _LIBCPP_INLINE_VISIBILITY void *__libcpp_allocate(size_t __size, size_t __align) {
+inline _LIBCPP_INLINE_VISIBILITY void *__libcpp_allocate(size_t __size, size_t __align)
+#if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
+_LIBCPP_DIAGNOSE_WARNING(_LIBCPP_IS_OVERALIGNED_FOR_NEW(__align),
+  "over-aligned allocation using 'operator new' is not supported")
+#endif
+{
 #ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-  if (__is_overaligned_for_new(__align)) {
+  if (_LIBCPP_IS_OVERALIGNED_FOR_NEW(__align)) {
     const align_val_t __align_val = static_cast<align_val_t>(__align);
 # ifdef _LIBCPP_HAS_NO_BUILTIN_ALIGNED_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);
 #endif
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate(void* __ptr, size_t __align) {
 #ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-  if (__is_overaligned_for_new(__align)) {
+  if (_LIBCPP_IS_OVERALIGNED_FOR_NEW(__align)) {
     const align_val_t __align_val = static_cast<align_val_t>(__align);
 # ifdef _LIBCPP_HAS_NO_BUILTIN_ALIGNED_OPERATOR_NEW_DELETE
     return ::operator delete(__ptr, __align_val);
 # else
     return __builtin_operator_delete(__ptr, __align_val);
 # endif
   }
 #else

test/libcxx/utilities/memory/default.allocation/allocator.members/overaligned_new_not_supported.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: diagnose-if-support, verify-support
+
+// <memory>
+
+// allocator:
+// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+
+// Test that a warning is generated when aligned allocation is not supported
+// but an over-aligned allocation is requested.
+
+#include <memory>
+
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_ALIGNED_ALLOCATION
+// expected-no-diagnostics
+#endif
+
+
+#ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
+static const size_t MaxAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__;
+#else
+static const size_t MaxAligned = std::alignment_of<std::max_align_t>::value;
+#endif
+
+static const size_t OverAligned = MaxAligned * 2;
+
+
+template <size_t Align>
+struct TEST_ALIGNAS(Align) AlignedType {
+  char data;
+  AlignedType() { }
+  AlignedType(AlignedType const&) { }
+  ~AlignedType() {}
+};
+
+
+void test_builtin_new() {
+  {
+    typedef AlignedType<MaxAligned> T;
+    void* ptr = std::__libcpp_allocate(sizeof(T), __alignof(T));
+    std::__libcpp_deallocate(ptr, __alignof(T));
+  }
+  {
+#if defined(TEST_HAS_NO_ALIGNED_ALLOCATION)
+    // expected-warning@+3 1 {{over-aligned allocation using 'operator new' is not supported}}
+#endif
+    typedef AlignedType<OverAligned> T;
+    void* ptr = std::__libcpp_allocate(sizeof(T), __alignof(T));
+    std::__libcpp_deallocate(ptr, __alignof(T));
+  }
+}
+
+void test_std_allocator() {
+  {
+    typedef AlignedType<MaxAligned> T;
+    std::allocator<T> a;
+    T* ptr = a.allocate(1); // OK
+    a.deallocate(ptr, 1);
+  }
+  {
+#if defined(TEST_HAS_NO_ALIGNED_ALLOCATION)
+    // expected-warning@memory:* 1 {{over-aligned allocation using 'operator new' is not supported}}
+    // expected-note@+4  {{requested here}}
+#endif
+    typedef AlignedType<OverAligned> T;
+    std::allocator<T> a;
+    T* ptr = a.allocate(1);
+    a.deallocate(ptr, 1);
+  }
+}
+
+int main() {
+  test_std_allocator();
+  test_builtin_new();
+}