Move internal usages of `alignof`/`__alignof` to use `_LIBCPP_ALIGNOF`.

[EricWF]

Summary

Starting in Clang 8.0 and GCC 8.0, alignof and __alignof return different values in same cases. Specifically alignof and _Alignof return the minimum alignment for a type, where as __alignof returns the preferred alignment. libc++ currently uses __alignof but means to use alignof. See llvm.org/PR39713

This patch introduces the macro _LIBCPP_ALIGNOF so we can control which spelling gets used.

This patch does not introduce any ABI guard to provide the old behavior with newer compilers. However, if we decide that is needed, this patch makes it trivial to implement.

I think we should commit this change immediately, and decide what we want to do about the ABI afterwards.

[ldionne]

Please hold off with committing this until we've agreed on the ABI part. That'll take at least until next week when people are back from Thanksgiving.

include/__config

1285

Can you indent nested #defines? I find it very difficult to read our PP code because it often lacks indentation.

test/libcxx/libcpp_alignof.pass.cpp

30

Why is this test useful? Isn't the previous one (for C++11) sufficient?

test/support/test_macros.h

118–122

Why not always just alignof? Shouldn't we only use that macro in C++11 and above anyway?

[ldionne]

I like this, though. It's a nice cleanup.

[EricWF]

Please hold off with committing this until we've agreed on the ABI part. That'll take at least until next week when people are back from Thanksgiving.

I don't know if there is an ABI part to agree on. Libc++ should have always been using alignof. The fact we were using __alignof was unobservable until Clang 8. If we release this in libc++ 8, it will continue to appear as if we have always been using alignof.
If users want the old behavior, the use the Clang flag.

Accepting. Further review can be post-commit review.

include/__config

1285

OK, but generally I'm pretty hostile to manually formatting anything. If clang-format doesn't do it, then I don't normally care.

test/libcxx/libcpp_alignof.pass.cpp

30

It checks that _Alignof acts like alignof which acts like _LIBCPP_ALIGNOF. The test is useful in that it would have caught the Clang bug related to this change.

And additional tests never hurt. This was certainly doesn't.

test/support/test_macros.h

118–122

We provide almost all of the C++11 library in C++03, C++03 is really just a thing we tolerate. For example, we provide alignment_of in C++03. Our allocators pass around the alignment in case we can use aligned new, etc.

[ldionne]

In D54814#1311642, @EricWF wrote:

Please hold off with committing this until we've agreed on the ABI part. That'll take at least until next week when people are back from Thanksgiving.

I don't know if there is an ABI part to agree on. Libc++ should have always been using alignof. The fact we were using __alignof was unobservable until Clang 8. If we release this in libc++ 8, it will continue to appear as if we have always been using alignof.
If users want the old behavior, the use the Clang flag.

Accepting. Further review can be post-commit review.

FWIW, I agree with the argument that people should use Clang's ABI compat flag if they want to retain ABI compatibility, and that the libc++ change (this one) is largely orthogonal to ABI implications (but the Clang change is a different story). I would have given you a ship-it with that comment even though I'm still considering the ABI implications of the Clang change.

However, I would have appreciated that you held off until I gave you a thumbs up since I did mention explicitly this was a sticky issue. I understand LLVM has a revert-friendly culture, but I feel like discussing reviewers' concerns is a better way of building trust. I just want to make sure we collaborate effectively.

I'm fine with this change, and thanks for the cleanup!

[jyknight]

I'd note that most of this diff was not actually required to fix the issue. E.g, in the locations where an alignment is passed to allocation/deallocation functions directly, it is perfectly fine to use the __alignof value instead of the alignof value.

We could also ameliorate some ABI breakage by continuing to use alignof within libc++, where changing to alignof would break the ABI of a standard library type. E.g., we could switch the use of std::alignment_of in any_imp to instead call __alignof, preserving behavior.

That appears to be the strategy GCC went with -- making the minimal ABI change necessary to be compliant.

[ldionne]

In D54814#1322110, @jyknight wrote:

I'd note that most of this diff was not actually required to fix the issue. E.g, in the locations where an alignment is passed to allocation/deallocation functions directly, it is perfectly fine to use the __alignof value instead of the alignof value.

We could also ameliorate some ABI breakage by continuing to use alignof within libc++, where changing to alignof would break the ABI of a standard library type. E.g., we could switch the use of std::alignment_of in any_imp to instead call __alignof, preserving behavior.

That appears to be the strategy GCC went with -- making the minimal ABI change necessary to be compliant.

I think it's better to fix it everywhere. If they want to truly be safe, people who actually care about ABI (and not breaking their customer's ABIs) will have to use -fclang-abi-compat=7.

[EricWF]

After further thought I don't think this approach is strictly correct.

In D54814#1322110, @jyknight wrote:

I'd note that most of this diff was not actually required to fix the issue. E.g, in the locations where an alignment is passed to allocation/deallocation functions directly, it is perfectly fine to use the __alignof value instead of the alignof value.

We could also ameliorate some ABI breakage by continuing to use alignof within libc++, where changing to alignof would break the ABI of a standard library type. E.g., we could switch the use of std::alignment_of in any_imp to instead call __alignof, preserving behavior.

I see a couple different classes of use cases:

1. std::alignment_of which should obviously use alignof.
2. Allocation functions and friends (such as __libcpp_allocate and __is_over_aligned_for_new). These should use alignof so they dispatch to aligned operator new in the same cases where Clang would implicitly call it.
3. aligned_storage and aligned_union: I think it's better to keep these using the preferred alignment, especially considering that aligned_storage_t<sizeof(max_align_t)> would be under aligned if we didn't (Thanks to how GCC and Clang define max_align_t).
4. Manually aligned STL internals (such as in std::array or std::any). These should switch to use alignof (as if we had been using it all along). If this breaks users ABI's, they should use the Clang flag.

I think I'll iterate by introducing _LIBCPP_PREFERRED_ALIGNOF to service instances of (3) while using _LIBCPP_ALIGNOF for cases (1), (2), and (4).

[EricWF]

Reopening with new approach.

This is all awful, but it seems to work.

[EricWF]

Introduce _LIBCPP_PREFERRED_ALIGNOF for cases where preferred alignment is needed.

include/__config

 #    else // defined(_LIBCPP_HAS_MUSL_LIBC)
 #      define _LIBCPP_HAS_QUICK_EXIT
 #      define _LIBCPP_HAS_TIMESPEC_GET
 #      define _LIBCPP_HAS_C11_FEATURES
 #    endif
 #  endif // __linux__
 #endif
 
+#ifndef _LIBCPP_CXX03_LANG
+# define _LIBCPP_ALIGNOF(_Tp) alignof(_Tp)
+#elif defined(_LIBCPP_COMPILER_CLANG)
+# define _LIBCPP_ALIGNOF(_Tp) _Alignof(_Tp)
+#else
+// This definition is potentially buggy, but it's only taken with GCC in C++03,
+// which we barely support anyway. See llvm.org/PR39713
+# define _LIBCPP_ALIGNOF(_Tp) __alignof(_Tp)
+#endif
+
+#define _LIBCPP_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
+
 #if defined(_LIBCPP_COMPILER_CLANG)
 
 // _LIBCPP_ALTERNATE_STRING_LAYOUT is an old name for
 // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT left here for backward compatibility.
 #if (defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) &&       \
      (!defined(__arm__) || __ARM_ARCH_7K__ >= 2)) ||                           \
     defined(_LIBCPP_ALTERNATE_STRING_LAYOUT)
 #define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 #endif
 
 #if __has_feature(cxx_alignas)
 #  define _ALIGNAS_TYPE(x) alignas(x)
 #  define _ALIGNAS(x) alignas(x)
 #else
-#  define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
+#  define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
 #  define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #endif
 
 #if __cplusplus < 201103L
 typedef __char16_t char16_t;
 typedef __char32_t char32_t;
 #endif
 

 // No apple compilers support ""d and ""y at this time.
 #if _LIBCPP_CLANG_VER < 800 || defined(__apple_build_version__)
 #define _LIBCPP_HAS_NO_CXX20_CHRONO_LITERALS
 #endif
 
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
-#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
+#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
 
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
 #if _GNUC_VER >= 407
 #define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T)
 #define _LIBCPP_IS_LITERAL(T) __is_literal_type(T)
 #define _LIBCPP_HAS_IS_FINAL
 #endif

 
 #define _LIBCPP_ALWAYS_INLINE __forceinline
 
 #define _LIBCPP_HAS_NO_VECTOR_EXTENSION
 
 #elif defined(_LIBCPP_COMPILER_IBM)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
-#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
+#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
 #define _ATTRIBUTE(x) __attribute__((x))
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
 #define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define _LIBCPP_HAS_NO_NULLPTR
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_IS_BASE_OF

 #endif
 
 #if defined(_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES)
 #define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
 #define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 #endif // _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
 
 #if !defined(__cpp_deduction_guides) || __cpp_deduction_guides < 201611
 #define _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 #endif
 
 #if !__has_keyword(__is_aggregate) && (_GNUC_VER_NEW < 7001)
 #define _LIBCPP_HAS_NO_IS_AGGREGATE
 #endif
 

include/__sso_allocator

 public:
     _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, typename __sso_allocator<void, _Np>::const_pointer = 0)
     {
         if (!__allocated_ && __n <= _Np)
         {
             __allocated_ = true;
             return (pointer)&buf_;
         }
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
+        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n)
     {
         if (__p == (pointer)&buf_)
             __allocated_ = false;
         else
-            _VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), __alignof(_Tp));
+            _VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
     }
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(__sso_allocator& __a) const {return &buf_ == &__a.buf_;}
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(__sso_allocator& __a) const {return &buf_ != &__a.buf_;}
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP___SSO_ALLOCATOR

include/experimental/coroutine

#endif
     coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
         _Base::operator=(nullptr);
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     _Promise& promise() const {
         return *static_cast<_Promise*>(
-            __builtin_coro_promise(this->__handle_, __alignof(_Promise), false));
+            __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
     }
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     static coroutine_handle from_address(void* __addr) _NOEXCEPT {
         coroutine_handle __tmp;
         __tmp.__handle_ = __addr;
         return __tmp;
public:
     }
 
     _LIBCPP_INLINE_VISIBILITY
     static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT {
         typedef typename remove_cv<_Promise>::type _RawPromise;
         coroutine_handle __tmp;
         __tmp.__handle_ = __builtin_coro_promise(
             _VSTD::addressof(const_cast<_RawPromise&>(__promise)),
-             __alignof(_Promise), true);
+             _LIBCPP_ALIGNOF(_Promise), true);
         return __tmp;
     }
 };
 
 #if __has_builtin(__builtin_coro_noop)
 struct noop_coroutine_promise {};
 
 template <>
 class _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise>
     : public coroutine_handle<> {
   using _Base = coroutine_handle<>;
   using _Promise = noop_coroutine_promise;
 public:
 
   _LIBCPP_INLINE_VISIBILITY
   _Promise& promise() const {
     return *static_cast<_Promise*>(
-      __builtin_coro_promise(this->__handle_, __alignof(_Promise), false));
+      __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
   }
 
   _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; }
   _LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; }
 
   _LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {}
   _LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {}
   _LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {}

include/experimental/memory_resource

 {
     _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows");
     return (__s + __a - 1) & ~(__a - 1);
 }
 
 // 8.5, memory.resource
 class _LIBCPP_TYPE_VIS memory_resource
 {
-    static const size_t __max_align = alignof(max_align_t);
+    static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t);
 
 // 8.5.2, memory.resource.public
 public:
     virtual ~memory_resource() = default;
 
     _LIBCPP_INLINE_VISIBILITY
     void* allocate(size_t __bytes, size_t __align = __max_align)
         { return do_allocate(__bytes, __align); }
public:
     _LIBCPP_INLINE_VISIBILITY
     _ValueType* allocate(size_t __n) {
         if (__n > __max_size()) {
             __throw_length_error(
                 "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)"
                 " 'n' exceeds maximum supported size");
         }
         return static_cast<_ValueType*>(
-            __res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
+            __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType))
         );
     }
 
     _LIBCPP_INLINE_VISIBILITY
     void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
         _LIBCPP_ASSERT(__n <= __max_size(),
                        "deallocate called for size which exceeds max_size()");
-        __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
+        __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType));
     }
 
     template <class _Tp, class ..._Ts>
     _LIBCPP_INLINE_VISIBILITY
     void construct(_Tp* __p, _Ts &&... __args)
     {
         _VSTD_LFTS::__lfts_user_alloc_construct(
             __p, *this, _VSTD::forward<_Ts>(__args)...

 class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
   : public memory_resource
 {
     using _CTraits = allocator_traits<_CharAlloc>;
     static_assert(is_same<typename _CTraits::value_type, char>::value
                && is_same<typename _CTraits::pointer, char*>::value
                && is_same<typename _CTraits::void_pointer, void*>::value, "");
 
-    static const size_t _MaxAlign = alignof(max_align_t);
+    static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t);
 
     using _Alloc = typename _CTraits::template rebind_alloc<
             typename aligned_storage<_MaxAlign, _MaxAlign>::type
         >;
 
     using _ValueType = typename _Alloc::value_type;
 
     _Alloc __alloc_;

include/functional

     void* __large;
 };
 
 // True if _Fun can safely be held in __policy_storage.__small.
 template <typename _Fun>
 struct __use_small_storage
     : public _VSTD::integral_constant<
           bool, sizeof(_Fun) <= sizeof(__policy_storage) &&
-                    alignof(_Fun) <= alignof(__policy_storage) &&
+                    _LIBCPP_ALIGNOF(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage) &&
                     _VSTD::is_trivially_copy_constructible<_Fun>::value &&
                     _VSTD::is_trivially_destructible<_Fun>::value> {};
 
 // Policy contains information about how to copy, destroy, and move the
 // underlying functor. You can think of it as a vtable of sorts.
 struct __policy
 {
     // Used to copy or destroy __large values. null for trivial objects.

include/memory

     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
         {
         if (__n > max_size())
             __throw_length_error("allocator<T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
+        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
         }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
-        {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), __alignof(_Tp));}
+        {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class _Up, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(_Up* __p, _Args&&... __args)
         {

 
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
     {
         if (__n > max_size())
             __throw_length_error("allocator<const T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
+        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
-        {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), __alignof(_Tp));}
+        {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class _Up, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(_Up* __p, _Args&&... __args)
         {

     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 (__is_overaligned_for_new(_LIBCPP_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 (__is_overaligned_for_new(_LIBCPP_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
 
         if (__r.first)
         {
             __r.second = __n;
             break;
         }
         __n /= 2;
     }
     return __r;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void return_temporary_buffer(_Tp* __p) _NOEXCEPT
 {
-  _VSTD::__libcpp_deallocate_unsized((void*)__p, __alignof(_Tp));
+  _VSTD::__libcpp_deallocate_unsized((void*)__p, _LIBCPP_ALIGNOF(_Tp));
 }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 template <class _Tp>
 struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref
 {
     _Tp* __ptr_;
 };

     > {};
 
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
 
-    typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __v;
+    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
     _Alloc &__a;
 
     _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
     _Tp &   get() { return *__addr(); }
 
     template<class... _Args>
     _LIBCPP_NO_CFI
     __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {

include/type_traits

     = has_unique_object_representations<_Tp>::value;
 #endif
 
 #endif
 
 // alignment_of
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
-    : public integral_constant<size_t, __alignof__(_Tp)> {};
+    : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t alignment_of_v
     = alignment_of<_Tp>::value;
 #endif
 
 // aligned_storage

     __nat& operator=(const __nat&) = delete;
     ~__nat() = delete;
 #endif
 };
 
 template <class _Tp>
 struct __align_type
 {
-    static const size_t value = alignment_of<_Tp>::value;
+    static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);
     typedef _Tp type;
 };
 
 struct __struct_double {long double __lx;};
 struct __struct_double4 {double __lx[4];};
 
 typedef
     __type_list<__align_type<unsigned char>,

 {
     static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
                                              __static_max<_I1, _In...>::value;
 };
 
 template <size_t _Len, class _Type0, class ..._Types>
 struct aligned_union
 {
-    static const size_t alignment_value = __static_max<__alignof__(_Type0),
-                                                       __alignof__(_Types)...>::value;
+    static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0),
+                                                       _LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value;
     static const size_t __len = __static_max<_Len, sizeof(_Type0),
                                              sizeof(_Types)...>::value;
     typedef typename aligned_storage<__len, alignment_value>::type type;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
 #endif

include/valarray

 {
     valarray<result_type> __r;
     size_t __n = __expr_.size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<result_type*>(
-                    _VSTD::__libcpp_allocate(__n * sizeof(result_type), __alignof(result_type)));
+                    _VSTD::__libcpp_allocate(__n * sizeof(result_type), _LIBCPP_ALIGNOF(result_type)));
         for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
             ::new (__r.__end_) result_type(__expr_[__i]);
     }
     return __r;
 }
 
 // valarray
 
 template <class _Tp>
 inline
 valarray<_Tp>::valarray(size_t __n)
     : __begin_(0),
       __end_(0)
 {
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-            _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+            _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
                 ::new (__end_) value_type();
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }

 template <class _Tp>
 valarray<_Tp>::valarray(const value_type* __p, size_t __n)
     : __begin_(0),
       __end_(0)
 {
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-            _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+            _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }

 template <class _Tp>
 valarray<_Tp>::valarray(const valarray& __v)
     : __begin_(0),
       __end_(0)
 {
     if (__v.size())
     {
         __begin_ = __end_ = static_cast<value_type*>(
-            _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), __alignof(value_type)));
+            _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }

 valarray<_Tp>::valarray(initializer_list<value_type> __il)
     : __begin_(0),
       __end_(0)
 {
     const size_t __n = __il.size();
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-_VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+_VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             size_t __n_left = __n;
             for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS

 valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
     : __begin_(0),
       __end_(0)
 {
     const size_t __n = __sa.__size_;
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-          _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+          _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             size_t __n_left = __n;
             for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS

 valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
     : __begin_(0),
       __end_(0)
 {
     const size_t __n = __ga.__1d_.size();
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             typedef const size_t* _Ip;
             const value_type* __s = __ga.__vp_;
             for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
                     __i != __e; ++__i, ++__end_)

 valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
     : __begin_(0),
       __end_(0)
 {
     const size_t __n = __ma.__1d_.size();
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             typedef const size_t* _Ip;
             const value_type* __s = __ma.__vp_;
             for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
                     __i != __e; ++__i, ++__end_)

 valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
     : __begin_(0),
       __end_(0)
 {
     const size_t __n = __ia.__1d_.size();
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             typedef const size_t* _Ip;
             const value_type* __s = __ia.__vp_;
             for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
                     __i != __e; ++__i, ++__end_)

 valarray<_Tp>&
 valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l)
 {
     size_t __n = __l - __f;
     if (size() != __n)
     {
         __clear(size());
         __begin_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         __end_ = __begin_ + __n;
         _VSTD::uninitialized_copy(__f, __l, __begin_);
     } else {
         _VSTD::copy(__f, __l, __begin_);
     }
     return *this;
 }
 

 {
     valarray<value_type> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(+*__p);
     }
     return __r;
 }
 
 template <class _Tp>
 valarray<_Tp>
 valarray<_Tp>::operator-() const
 {
     valarray<value_type> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(-*__p);
     }
     return __r;
 }
 
 template <class _Tp>
 valarray<_Tp>
 valarray<_Tp>::operator~() const
 {
     valarray<value_type> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(~*__p);
     }
     return __r;
 }
 
 template <class _Tp>
 valarray<bool>
 valarray<_Tp>::operator!() const
 {
     valarray<bool> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
-                static_cast<bool*>(_VSTD::__libcpp_allocate(__n * sizeof(bool), __alignof(bool)));
+                static_cast<bool*>(_VSTD::__libcpp_allocate(__n * sizeof(bool), _LIBCPP_ALIGNOF(bool)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) bool(!*__p);
     }
     return __r;
 }
 
 template <class _Tp>
 inline

 {
     valarray<value_type> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         const value_type* __sb;
         value_type* __tb;
         value_type* __te;
         if (__i >= 0)
         {
             __i = _VSTD::min(__i, static_cast<int>(__n));
             __sb = __begin_ + __i;
             __tb = __r.__begin_;

 {
     valarray<value_type> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         __i %= static_cast<int>(__n);
         const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
         for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
             ::new (__r.__end_) value_type(*__s);
         for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
             ::new (__r.__end_) value_type(*__s);
     }
     return __r;
 }
 
 template <class _Tp>
 valarray<_Tp>
 valarray<_Tp>::apply(value_type __f(value_type)) const
 {
     valarray<value_type> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(__f(*__p));
     }
     return __r;
 }
 
 template <class _Tp>
 valarray<_Tp>
 valarray<_Tp>::apply(value_type __f(const value_type&)) const
 {
     valarray<value_type> __r;
     size_t __n = size();
     if (__n)
     {
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(__f(*__p));
     }
     return __r;
 }
 
 template <class _Tp>
 inline
 void valarray<_Tp>::__clear(size_t __capacity)
 {
   if (__begin_ != nullptr)
   {
     while (__end_ != __begin_)
       (--__end_)->~value_type();
-    _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), __alignof(value_type));
+    _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), _LIBCPP_ALIGNOF(value_type));
     __begin_ = __end_ = nullptr;
   }
 }
 
 template <class _Tp>
 void
 valarray<_Tp>::resize(size_t __n, value_type __x)
 {
     __clear(size());
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
                 ::new (__end_) value_type(__x);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }

test/libcxx/libcpp_alignof.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// Test that _LIBCPP_ALIGNOF acts the same as the C++11 keyword `alignof`, and
+// not as the GNU extension `__alignof`. The former returns the minimal required
+// alignment for a type, whereas the latter returns the preferred alignment.
+//
+// See llvm.org/PR39713
+
+#include <type_traits>
+#include "test_macros.h"
+
+template <class T>
+void test() {
+  static_assert(_LIBCPP_ALIGNOF(T) == std::alignment_of<T>::value, "");
+  static_assert(_LIBCPP_ALIGNOF(T) == TEST_ALIGNOF(T), "");
+#if TEST_STD_VER >= 11
+  static_assert(_LIBCPP_ALIGNOF(T) == alignof(T), "");
+#endif
+#ifdef TEST_COMPILER_CLANG
+  static_assert(_LIBCPP_ALIGNOF(T) == _Alignof(T), "");
+#endif
+}
+
+int main() {
+  test<int>();
+  test<long long>();
+  test<double>();
+  test<long double>();
+}

test/std/containers/sequences/array/size_and_alignment.pass.cpp

 struct TEST_ALIGNAS(TEST_ALIGNOF(std::max_align_t) * 2) TestType1 {
 
 };
 
 struct TEST_ALIGNAS(TEST_ALIGNOF(std::max_align_t) * 2) TestType2 {
   char data[1000];
 };
 
-//static_assert(sizeof(void*) == 4, "");
-
 int main() {
   test_type<char>();
   test_type<int>();
   test_type<double>();
   test_type<long double>();
   test_type<std::max_align_t>();
   test_type<TestType1>();
   test_type<TestType2>();
 }

test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp

#endif
     static_assert(std::is_trivial<T1>::value, "");
     static_assert(std::is_standard_layout<T1>::value, "");
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
     // Use alignof(std::max_align_t) below to find the max alignment instead of
     // hardcoding it, because it's different on different platforms.
     // (For example 8 on arm and 16 on x86.)
-#if TEST_STD_VER < 11
-#define alignof __alignof__
-#endif
     {
     typedef std::aligned_storage<16>::type T1;
 #if TEST_STD_VER > 11
     static_assert(std::is_same<std::aligned_storage_t<16>, T1>::value, "");
 #endif
     static_assert(std::is_trivial<T1>::value, "");
     static_assert(std::is_standard_layout<T1>::value, "");
-    static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
+    static_assert(std::alignment_of<T1>::value == TEST_ALIGNOF(std::max_align_t),
                   "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_storage<17>::type T1;
 #if TEST_STD_VER > 11
     static_assert(std::is_same<std::aligned_storage_t<17>, T1>::value, "");
 #endif
     static_assert(std::is_trivial<T1>::value, "");
     static_assert(std::is_standard_layout<T1>::value, "");
-    static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
+    static_assert(std::alignment_of<T1>::value == TEST_ALIGNOF(std::max_align_t),
                   "");
-    static_assert(sizeof(T1) == 16 + alignof(std::max_align_t), "");
+    static_assert(sizeof(T1) == 16 + TEST_ALIGNOF(std::max_align_t), "");
     }
     {
     typedef std::aligned_storage<10>::type T1;
 #if TEST_STD_VER > 11
     static_assert(std::is_same<std::aligned_storage_t<10>, T1>::value, "");
 #endif
     static_assert(std::is_trivial<T1>::value, "");
     static_assert(std::is_standard_layout<T1>::value, "");
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
 }

test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp

 #include <type_traits>
 #include <cstdint>
 
 #include "test_macros.h"
 
 template <class T, unsigned A>
 void test_alignment_of()
 {
+    const unsigned AlignofResult = TEST_ALIGNOF(T);
+    static_assert( AlignofResult == A, "Golden value does not match result of alignof keyword");
+    static_assert( std::alignment_of<T>::value == AlignofResult, "");
     static_assert( std::alignment_of<T>::value == A, "");
     static_assert( std::alignment_of<const T>::value == A, "");
     static_assert( std::alignment_of<volatile T>::value == A, "");
     static_assert( std::alignment_of<const volatile T>::value == A, "");
 #if TEST_STD_VER > 14
     static_assert( std::alignment_of_v<T> == A, "");
     static_assert( std::alignment_of_v<const T> == A, "");
     static_assert( std::alignment_of_v<volatile T> == A, "");

 int main()
 {
     test_alignment_of<int&, 4>();
     test_alignment_of<Class, 1>();
     test_alignment_of<int*, sizeof(intptr_t)>();
     test_alignment_of<const int*, sizeof(intptr_t)>();
     test_alignment_of<char[3], 1>();
     test_alignment_of<int, 4>();
-    test_alignment_of<double, 8>();
+    // The test case below is a hack. It's hard to detect what golden value
+    // we should expect. In most cases it should be 8. But in i386 builds
+    // with Clang >= 8 or GCC >= 8 the value is '4'.
+    test_alignment_of<double, TEST_ALIGNOF(double)>();
 #if (defined(__ppc__) && !defined(__ppc64__))
     test_alignment_of<bool, 4>();   // 32-bit PPC has four byte bool
 #else
     test_alignment_of<bool, 1>();
 #endif
     test_alignment_of<unsigned, 4>();
 }

test/support/test_macros.h

 #   define TEST_CONSTEXPR_CXX14
 # endif
 # if TEST_STD_VER > 14
 #   define TEST_THROW_SPEC(...)
 # else
 #   define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 # endif
 #else
-#define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
+#if defined(TEST_COMPILER_CLANG)
+# define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__)
+#else
+# define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
+#endif
 #define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
 #define TEST_CONSTEXPR
 #define TEST_CONSTEXPR_CXX14
 #define TEST_NOEXCEPT throw()
 #define TEST_NOEXCEPT_FALSE
 #define TEST_NOEXCEPT_COND(...)
 #define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif