[libc++] Remove _LIBCPP_ALIGNOF

[philnik]

Summary

We already define a lot of C++11 keywords in C++03, so we can also do that for alignof instead of having an internal macro for that.

[ldionne]

As much as I don't like having ugly macros like _LIBCPP_ALIGNOF, I dislike even more defining a keyword as a macro, especially in the library:

• If the compiler ever wants to support alignof as an extension in C++03, we'll need coordination between the library and the compiler.
• This is technically a breaking change for C++03 users because they are allowed to use alignof as a name, and we're not allowed to define identifiers outside of our namespace. Concretely, I do suspect this may break some C-first codebases that try to be clever.
• This breaks the symmetry between _LIBCPP_PREFERRED_ALIGNOF and _LIBCPP_ALIGNOF.
• We have experience that defining compiler stuff in the library isn't a great idea -- for example, we've yet to figure out a way to get rid of our char16_t typedef, and it's not even a macro.

All in all, I feel that this change doesn't pull its weight, even though I am supportive of the intent. Thoughts?

[philnik]

• If the compiler ever wants to support alignof as an extension in C++03, we'll need coordination between the library and the compiler.

That could be avoided by checking for #if defined(_LIBCPP_CXX03_LANG) && !__has_keyword(alignof) instead of just #ifdef _LIBCPP_CXX03_LANG.

• This is technically a breaking change for C++03 users because they are allowed to use alignof as a name, and we're not allowed to define identifiers outside of our namespace. Concretely, I do suspect this may break some C-first codebases that try to be clever.

C++03 in libc++ is more a crutch than anything else at this point. Users are also allowed to #define a lot of names in C++03 that we use in the library and are only part of C++11.

These are the keywords introduced in C++11 (according to https://en.cppreference.com/w/cpp/keyword):

Keyword	Provided?/How?
alignas	not provided
alignof	not provided
char16_t	typedef in libc++
char32_t	typedef in libc++
constexpr	not provided
decltype	macro in libc++
noexcept	not provided
nullptr	macro in libc++
static_assert	macro in libc++
thread_local	not provided

So we already define quite a few C++11 keywords. Functionality wise most of them are indistinguishable from their C++11 keyword versions. We can't provide constexpr and noexcept because we don't have a way to emulate them. We don't use thread_local anywhere so I don't particularly care. So effectively the only ones left are alignas and alignof.

I think the C-first codebase that this change would break are very few and are arguably broken already. We would also break these codebases if we included stdalign.h and they are definitely broken by C23 (https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2654.pdf).

• This breaks the symmetry between _LIBCPP_PREFERRED_ALIGNOF and _LIBCPP_ALIGNOF.

There are exactly 3 uses of _LIBCPP_PREFERRED_ALIGNOF, all of which are in <type_traits>. I think removing the macro and adding a comment on these places is the better alternative.

• We have experience that defining compiler stuff in the library isn't a great idea -- for example, we've yet to figure out a way to get rid of our char16_t typedef, and it's not even a macro.

I think getting rid of a macro that emulates a keyword is easier than a typedef. The typedef has ABI implications which simply don't exist with these macros.

All in all, I feel that this change doesn't pull its weight, even though I am supportive of the intent. Thoughts?

I know we don't want to break users, but I think we should treat C++03 as what it is: A relic of a bygone era and a burden nobody wants to keep.
It seems like a thing almost nobody uses but nobody knows how many users there are, so we don't want to risk just throwing it away. It's not like it makes sense to have a standard library from 2022 and using it with a language standard from 2003 (or more like 1998). People had over a decade of time to upgrade by now and people who haven't won't use any even nearly up-to date toolchain. Let them deal with it in 20 years when they finally decide to upgrade.

[ldionne]

In D126249#3543962, @philnik wrote:

• If the compiler ever wants to support alignof as an extension in C++03, we'll need coordination between the library and the compiler.

That could be avoided by checking for #if defined(_LIBCPP_CXX03_LANG) && !__has_keyword(alignof) instead of just #ifdef _LIBCPP_CXX03_LANG.

Fair point.

• This breaks the symmetry between _LIBCPP_PREFERRED_ALIGNOF and _LIBCPP_ALIGNOF.

There are exactly 3 uses of _LIBCPP_PREFERRED_ALIGNOF, all of which are in <type_traits>. I think removing the macro and adding a comment on these places is the better alternative.

Can you upload a patch that does this before we decide whether to move forward with this patch?

I know we don't want to break users, but I think we should treat C++03 as what it is: A relic of a bygone era and a burden nobody wants to keep.

I agree that C++03 is a relic, and I agree that we want to get rid of it. However, I think you are underestimating how many users of it there are. For example, AppleClang still uses C++03 by default today because we've run into issues when flipping the default -- LLVM Clang uses C++14 AFAICT. It doesn't change much w.r.t. this patch, but I think it's important to be aware that a lot of users unfortunately still compile as C++03.

[philnik]

• This breaks the symmetry between _LIBCPP_PREFERRED_ALIGNOF and _LIBCPP_ALIGNOF.

There are exactly 3 uses of _LIBCPP_PREFERRED_ALIGNOF, all of which are in <type_traits>. I think removing the macro and adding a comment on these places is the better alternative.

Can you upload a patch that does this before we decide whether to move forward with this patch?

This is D127132 now.

I know we don't want to break users, but I think we should treat C++03 as what it is: A relic of a bygone era and a burden nobody wants to keep.

I agree that C++03 is a relic, and I agree that we want to get rid of it. However, I think you are underestimating how many users of it there are. For example, AppleClang still uses C++03 by default today because we've run into issues when flipping the default -- LLVM Clang uses C++14 AFAICT. It doesn't change much w.r.t. this patch, but I think it's important to be aware that a lot of users unfortunately still compile as C++03.

Can you tell me/do you know what problems there were changing the default to something newer than C++03 and when you tried it? I wasn't aware AppleClang still defaults to C++03.
It's absolutely possible that I'm underestimating how many people still compile in C++03 mode. Do you know of any statistics which language mode get used? How many people are just using it because it's the default on AppleClang and how many people would even notice the change? How many people are there that compile in C++03 mode for a good reason (i.e. would have to set -std=c++03 if it weren't the default)? GCC defaults to C++17 and clang to C++14, so it's obviously not impossible to change the default language standard. Is the main reason we still support C++03 that AppleClang still defaults to it?

[Mordante]

No real opinion on the patch.

In D126249#3561099, @philnik wrote:

I know we don't want to break users, but I think we should treat C++03 as what it is: A relic of a bygone era and a burden nobody wants to keep.

I agree that C++03 is a relic, and I agree that we want to get rid of it. However, I think you are underestimating how many users of it there are. For example, AppleClang still uses C++03 by default today because we've run into issues when flipping the default -- LLVM Clang uses C++14 AFAICT. It doesn't change much w.r.t. this patch, but I think it's important to be aware that a lot of users unfortunately still compile as C++03.

Can you tell me/do you know what problems there were changing the default to something newer than C++03 and when you tried it? I wasn't aware AppleClang still defaults to C++03.
It's absolutely possible that I'm underestimating how many people still compile in C++03 mode. Do you know of any statistics which language mode get used? How many people are just using it because it's the default on AppleClang and how many people would even notice the change? How many people are there that compile in C++03 mode for a good reason (i.e. would have to set -std=c++03 if it weren't the default)? GCC defaults to C++17 and clang to C++14, so it's obviously not impossible to change the default language standard. Is the main reason we still support C++03 that AppleClang still defaults to it?

There's still code being actively developed in older language Standards, even C++98. Upgrading the newer Standards can be quite a bit of effort. This is even worse when code bases use using namespace std; in headers. (I've seen this in multiple code bases.)

So I fear we'll need to support C++03 for a long time (probably forever).

In last years Jetbrains developer Infographic 12% was still using C++98/03
https://www.jetbrains.com/lp/devecosystem-2021/cpp

[ldionne]

In D126249#3561099, @philnik wrote:

Can you tell me/do you know what problems there were changing the default to something newer than C++03 and when you tried it? I wasn't aware AppleClang still defaults to C++03.

I don't know the details because it was before my time, unfortunately.

It's absolutely possible that I'm underestimating how many people still compile in C++03 mode. Do you know of any statistics which language mode get used?

We unfortunately don't have great data around that, but it would be useful for the LLVM community as a whole.

Is the main reason we still support C++03 that AppleClang still defaults to it?

Even if AppleClang switched to C++14 by default, I don't think we'd remove C++03 support unless Clang (so the LLVM community as a whole) decided to also remove support for -std=c++03.

The more I think about this change, the less certain I am about it. If we want to do this, why not pursue providing alignof as an extension in C++03 mode in Clang itself? It seems to me that the better place to bridge language gaps is in the compiler itself.

libcxx/include/__config

 #endif // !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
 
 #if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC)
 #  define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
 #else
 #  define _LIBCPP_NO_CFI
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
-# define _LIBCPP_ALIGNOF(_Tp) alignof(_Tp)
-#elif defined(_LIBCPP_COMPILER_CLANG_BASED)
-# define _LIBCPP_ALIGNOF(_Tp) _Alignof(_Tp)
-#else
-# error "We don't know a correct way to implement alignof(T) in C++03 outside of Clang"
-#endif
+#  ifdef _LIBCPP_CXX03_LANG
+#    ifdef _LIBCPP_COMPILER_CLANG_BASED
+#      define alignof(_Tp) _Alignof(_Tp)
+#    else
+#      error "We don't know a correct way to implement alignof(T) in C++03 outside of Clang"
+#    endif
+#  endif
 
 #define _LIBCPP_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
 
 #if defined(_LIBCPP_COMPILER_CLANG_BASED)
 
 #if defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) &&       \
     (!defined(__arm__) || __ARM_ARCH_7K__ >= 2)
 #  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__(_LIBCPP_ALIGNOF(x))))
+#  define _ALIGNAS_TYPE(x) __attribute__((__aligned__(alignof(x))))
 #  define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #endif
 
 #if __cplusplus < 201103L
 typedef __char16_t char16_t;
 typedef __char32_t char32_t;
 #endif
 

 
 #define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
 
 #define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
 
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
-#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
+#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(alignof(x))))
 
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
 #if !defined(__EXCEPTIONS)
 #  define _LIBCPP_NO_EXCEPTIONS
 #endif
 
 #if !defined(__SANITIZE_ADDRESS__)

 
 #define _LIBCPP_HAS_NO_VECTOR_EXTENSION
 
 #define _LIBCPP_DISABLE_EXTENSION_WARNING
 
 #elif defined(_LIBCPP_COMPILER_IBM)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
-#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
+#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(alignof(x))))
 #define _ATTRIBUTE(x) __attribute__((x))
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 
 #if defined(_AIX)
 #define __MULTILOCALE_API
 #endif

libcxx/include/__functional/function.h

union __policy_storage
     void* __large;
 };
 
 // True if _Fun can safely be held in __policy_storage.__small.
 template <typename _Fun>
 struct __use_small_storage
     : public integral_constant<
           bool, sizeof(_Fun) <= sizeof(__policy_storage) &&
-                    _LIBCPP_ALIGNOF(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage) &&
+                    alignof(_Fun) <= alignof(__policy_storage) &&
                     is_trivially_copy_constructible<_Fun>::value &&
                     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.

libcxx/include/__memory/allocator.h

public:
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     _Tp* allocate(size_t __n) {
         if (__n > allocator_traits<allocator>::max_size(*this))
             __throw_bad_array_new_length();
         if (__libcpp_is_constant_evaluated()) {
             return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
         } else {
-            return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
+            return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), alignof(_Tp)));
         }
     }
 
 #if _LIBCPP_STD_VER > 20
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
     allocation_result<_Tp*> allocate_at_least(size_t __n) {
         return {allocate(__n), __n};
     }
 #endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void deallocate(_Tp* __p, size_t __n) _NOEXCEPT {
         if (__libcpp_is_constant_evaluated()) {
             ::operator delete(__p);
         } else {
-            _VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+            _VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), alignof(_Tp));
         }
     }
 
     // C++20 Removed members
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
     _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp*       pointer;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp&       reference;
public:
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const _Tp* allocate(size_t __n) {
         if (__n > allocator_traits<allocator>::max_size(*this))
             __throw_bad_array_new_length();
         if (__libcpp_is_constant_evaluated()) {
             return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
         } else {
-            return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
+            return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), alignof(_Tp)));
         }
     }
 
 #if _LIBCPP_STD_VER > 20
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
     allocation_result<const _Tp*> allocate_at_least(size_t __n) {
         return {allocate(__n), __n};
     }
 #endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void deallocate(const _Tp* __p, size_t __n) {
         if (__libcpp_is_constant_evaluated()) {
             ::operator delete(const_cast<_Tp*>(__p));
         } else {
-            _VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+            _VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), alignof(_Tp));
         }
     }
 
     // C++20 Removed members
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
     _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* pointer;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& reference;

libcxx/include/__memory/shared_ptr.h

struct _ALIGNAS_TYPE(_CompressedPair) _Storage {
         _LIBCPP_NO_CFI _Tp* __get_elem() _NOEXCEPT {
             _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
             typename _CompressedPair::_Base2* __second = _CompressedPair::__get_second_base(__as_pair);
             _Tp *__elem = reinterpret_cast<_Tp*>(__second);
             return __elem;
         }
     };
 
-    static_assert(_LIBCPP_ALIGNOF(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair), "");
+    static_assert(alignof(_Storage) == alignof(_CompressedPair), "");
     static_assert(sizeof(_Storage) == sizeof(_CompressedPair), "");
     _Storage __storage_;
 };
 
 struct __shared_ptr_dummy_rebind_allocator_type;
 template <>
 class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type>
 {

libcxx/include/__memory/temporary_buffer.h

get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
     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(_LIBCPP_ALIGNOF(_Tp)))
+    if (__is_overaligned_for_new(alignof(_Tp)))
         {
             align_val_t __al =
                 align_val_t(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(_LIBCPP_ALIGNOF(_Tp)))
+    if (__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
 
         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, _LIBCPP_ALIGNOF(_Tp));
+  _VSTD::__libcpp_deallocate_unsized((void*)__p, alignof(_Tp));
 }
 
 struct __return_temporary_buffer
 {
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);}
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_TEMPORARY_BUFFER_H

libcxx/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_, _LIBCPP_ALIGNOF(_Promise), false));
+            __builtin_coro_promise(this->__handle_, 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)),
-             _LIBCPP_ALIGNOF(_Promise), true);
+             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_, _LIBCPP_ALIGNOF(_Promise), false));
+      __builtin_coro_promise(this->__handle_, 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 {}

libcxx/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 = _LIBCPP_ALIGNOF(max_align_t);
+    static const size_t __max_align = 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:
     operator=(polymorphic_allocator const &) = delete;
 
     // 8.6.3, memory.polymorphic.allocator.mem
     _LIBCPP_INLINE_VISIBILITY
     _ValueType* allocate(size_t __n) {
         if (__n > __max_size())
             __throw_bad_array_new_length();
         return static_cast<_ValueType*>(
-            __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType))
+            __res_->allocate(__n * sizeof(_ValueType), 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), _LIBCPP_ALIGNOF(_ValueType));
+        __res_->deallocate(__p, __n * sizeof(_ValueType), 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 = _LIBCPP_ALIGNOF(max_align_t);
+    static const size_t _MaxAlign = 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_;

libcxx/include/memory

 #endif
     > {};
 
 
 template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
 
-    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
+    typename aligned_storage<sizeof(_Tp), 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) {
struct __builtin_new_allocator {
   static void __deallocate_bytes(void* __p, size_t __s,
                                  size_t __align) _NOEXCEPT {
       _VSTD::__libcpp_deallocate(__p, __s, __align);
   }
 
   template <class _Tp>
   _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
   static __holder_t __allocate_type(size_t __n) {
-      return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+      return __allocate_bytes(__n * sizeof(_Tp), alignof(_Tp));
   }
 
   template <class _Tp>
   _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
   static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
-      __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+      __deallocate_bytes(__p, __n * sizeof(_Tp), alignof(_Tp));
   }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/include/type_traits

 template <class _Tp>
 inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value;
 
 #endif
 
 // alignment_of
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
-    : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
+    : public integral_constant<size_t, alignof(_Tp)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
 #endif
 
 // aligned_storage
 

libcxx/test/libcxx/libcpp_alignof.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// 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(int, char**) {
-  test<int>();
-  test<long long>();
-  test<double>();
-  test<long double>();
-  return 0;
-}