[libc++] Implement P1007R3: std::assume_aligned

[ldionne]

Summary

This supersedes and incoroporates content from both D108906 and D54966,
and also some original content.

Co-Authored-by: Marshall Clow <[e-mail]>
Co-Authored-by: Gonzalo Brito Gadeschi

[ldionne]

Add the feature-test macro.

[philnik]

Have the issues described in D54966 been resolved? If yes, this LGTM.

libcxx/test/std/utilities/memory/ptr.align/assume_aligned.nodiscard.verify.cpp

21

Why is this [[maybe_unused]]?

[ldionne]

In D118938#3294779, @philnik wrote:

Have the issues described in D54966 been resolved? If yes, this LGTM.

I believe so, because we don't use __builtin_assume_aligned during constant evaluation anymore, and that was the main holdup IIUC.

libcxx/test/std/utilities/memory/ptr.align/assume_aligned.nodiscard.verify.cpp

21

Not sure, removed.

[ldionne]

Rebase onto main and address a few comments. I'll ship this once CI passes.

[ldionne]

Address CI issue.

[philnik]

LGTM % nit

libcxx/include/__memory/assume_aligned.h

38

I think I'd like a reinterpret_cast here a bit more. At least say that you're an evil person.

[ldionne]

Applied @philnik's comment locally. The test failure is a fluke, so I'll ignore it. Shipping this!

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_variant``                             ``202102L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_void_t``                              ``201411L``
     ------------------------------------------------- -----------------
     **C++ 20**
     -------------------------------------------------------------------
     ``__cpp_lib_array_constexpr``                     ``201811L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_assume_aligned``                      *unimplemented*
+    ``__cpp_lib_assume_aligned``                      ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_flag_test``                    ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_float``                        *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_lock_free_type_aliases``       ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_ref``                          *unimplemented*

libcxx/docs/Status/Cxx20Papers.csv

 "`P0608R3 <https://wg21.link/P0608R3>`__","LWG","A sane variant converting constructor","San Diego","|Complete|","9.0"
 "`P0655R1 <https://wg21.link/P0655R1>`__","LWG","visit<R>: Explicit Return Type for visit","San Diego","|Complete|","12.0"
 "`P0771R1 <https://wg21.link/P0771R1>`__","LWG","std::function move constructor should be noexcept","San Diego","|Complete|","6.0"
 "`P0896R4 <https://wg21.link/P0896R4>`__","LWG","The One Ranges Proposal","San Diego","|In Progress|",""
 "`P0899R1 <https://wg21.link/P0899R1>`__","LWG","P0899R1 - LWG 3016 is not a defect","San Diego","|Nothing To Do|",""
 "`P0919R3 <https://wg21.link/P0919R3>`__","LWG","Heterogeneous lookup for unordered containers","San Diego","|Complete|","12.0"
 "`P0972R0 <https://wg21.link/P0972R0>`__","LWG","<chrono> ``zero()``\ , ``min()``\ , and ``max()``\  should be noexcept","San Diego","|Complete|","8.0"
 "`P1006R1 <https://wg21.link/P1006R1>`__","LWG","Constexpr in std::pointer_traits","San Diego","|Complete|","8.0"
-"`P1007R3 <https://wg21.link/P1007R3>`__","LWG","``std::assume_aligned``\ ","San Diego","* *",""
+"`P1007R3 <https://wg21.link/P1007R3>`__","LWG","``std::assume_aligned``\ ","San Diego","|Complete|","15.0"
 "`P1020R1 <https://wg21.link/P1020R1>`__","LWG","Smart pointer creation with default initialization","San Diego","* *",""
 "`P1032R1 <https://wg21.link/P1032R1>`__","LWG","Misc constexpr bits","San Diego","|Complete|","13.0"
 "`P1085R2 <https://wg21.link/P1085R2>`__","LWG","Should Span be Regular?","San Diego","|Complete|","8.0"
 "`P1123R0 <https://wg21.link/P1123R0>`__","LWG","Editorial Guidance for merging P0019r8 and P0528r3","San Diego","* *",""
 "`P1148R0 <https://wg21.link/P1148R0>`__","LWG","Cleaning up Clause 20","San Diego","* *",""
 "`P1165R1 <https://wg21.link/P1165R1>`__","LWG","Make stateful allocator propagation more consistent for ``operator+(basic_string)``\ ","San Diego","|Complete|","15.0"
 "`P1209R0 <https://wg21.link/P1209R0>`__","LWG","Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20","San Diego","|Complete|","8.0"
 "`P1210R0 <https://wg21.link/P1210R0>`__","LWG","Completing the Rebase of Library Fundamentals, Version 3, Working Draft","San Diego","* *",""

libcxx/include/CMakeLists.txt

set(files
   __locale
   __mbstate_t.h
   __memory/addressof.h
   __memory/allocate_at_least.h
   __memory/allocation_guard.h
   __memory/allocator.h
   __memory/allocator_arg_t.h
   __memory/allocator_traits.h
+  __memory/assume_aligned.h
   __memory/auto_ptr.h
   __memory/compressed_pair.h
   __memory/concepts.h
   __memory/construct_at.h
   __memory/pointer_traits.h
   __memory/ranges_construct_at.h
   __memory/ranges_uninitialized_algorithms.h
   __memory/raw_storage_iterator.h

libcxx/include/__memory/assume_aligned.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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_ASSUME_ALIGNED_H
+#define _LIBCPP___MEMORY_ASSUME_ALIGNED_H
+
+#include <__assert>
+#include <__config>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits> // for is_constant_evaluated()
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template <size_t _Np, class _Tp>
+[[nodiscard]]
+_LIBCPP_HIDE_FROM_ABI
+constexpr _Tp* assume_aligned(_Tp* __ptr) {
+  static_assert(_Np != 0 && (_Np & (_Np - 1)) == 0,
+    "std::assume_aligned<N>(p) requires N to be a power of two");
+
+  if (is_constant_evaluated()) {
+    return __ptr;
+  } else {
+    _LIBCPP_ASSERT(reinterpret_cast<uintptr_t>(__ptr) % _Np == 0, "Alignment assumption is violated");
+    return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Np));
+  }
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_ASSUME_ALIGNED_H

libcxx/include/memory

 // Hash support
 template <class T> struct hash;
 template <class T, class D> struct hash<unique_ptr<T, D> >;
 template <class T> struct hash<shared_ptr<T> >;
 
 template <class T, class Alloc>
   inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 
+// [ptr.align]
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
+template<size_t N, class T>
+[[nodiscard]] constexpr T* assume_aligned(T* ptr); // since C++20
+
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
+#include <__memory/assume_aligned.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/ranges_construct_at.h>
 #include <__memory/ranges_uninitialized_algorithms.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>
struct __builtin_new_allocator {
 
   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));
   }
 };
 
-
 _LIBCPP_END_NAMESPACE_STD
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/include/module.modulemap

module memory {
 
     module __memory {
       module addressof                       { private header "__memory/addressof.h" }
       module allocate_at_least               { private header "__memory/allocate_at_least.h" }
       module allocation_guard                { private header "__memory/allocation_guard.h" }
       module allocator                       { private header "__memory/allocator.h" }
       module allocator_arg_t                 { private header "__memory/allocator_arg_t.h" }
       module allocator_traits                { private header "__memory/allocator_traits.h" }
+      module assume_aligned                  { private header "__memory/assume_aligned.h" }
       module auto_ptr                        { private header "__memory/auto_ptr.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
       module concepts                        { private header "__memory/concepts.h" }
       module construct_at                    { private header "__memory/construct_at.h" }
       module pointer_traits                  { private header "__memory/pointer_traits.h" }
       module ranges_construct_at             { private header "__memory/ranges_construct_at.h" }
       module ranges_uninitialized_algorithms { private header "__memory/ranges_uninitialized_algorithms.h" }
       module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }

libcxx/include/version

 # define __cpp_lib_unordered_map_try_emplace            201411L
 # define __cpp_lib_variant                              202102L
 # define __cpp_lib_void_t                               201411L
 #endif
 
 #if _LIBCPP_STD_VER > 17
 # undef  __cpp_lib_array_constexpr
 # define __cpp_lib_array_constexpr                      201811L
-// # define __cpp_lib_assume_aligned                       201811L
+# define __cpp_lib_assume_aligned                       201811L
 # define __cpp_lib_atomic_flag_test                     201907L
 // # define __cpp_lib_atomic_float                         201711L
 # define __cpp_lib_atomic_lock_free_type_aliases        201907L
 // # define __cpp_lib_atomic_ref                           201806L
 // # define __cpp_lib_atomic_shared_ptr                    201711L
 # define __cpp_lib_atomic_value_initialization          201911L
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   define __cpp_lib_atomic_wait                        201907L

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__locale> // expected-error@*:* {{use of private header from outside its module: '__locale'}}
 #include <__mbstate_t.h> // expected-error@*:* {{use of private header from outside its module: '__mbstate_t.h'}}
 #include <__memory/addressof.h> // expected-error@*:* {{use of private header from outside its module: '__memory/addressof.h'}}
 #include <__memory/allocate_at_least.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocate_at_least.h'}}
 #include <__memory/allocation_guard.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocation_guard.h'}}
 #include <__memory/allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator.h'}}
 #include <__memory/allocator_arg_t.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_arg_t.h'}}
 #include <__memory/allocator_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_traits.h'}}
+#include <__memory/assume_aligned.h> // expected-error@*:* {{use of private header from outside its module: '__memory/assume_aligned.h'}}
 #include <__memory/auto_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/auto_ptr.h'}}
 #include <__memory/compressed_pair.h> // expected-error@*:* {{use of private header from outside its module: '__memory/compressed_pair.h'}}
 #include <__memory/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__memory/concepts.h'}}
 #include <__memory/construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/construct_at.h'}}
 #include <__memory/pointer_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/pointer_traits.h'}}
 #include <__memory/ranges_construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/ranges_construct_at.h'}}
 #include <__memory/ranges_uninitialized_algorithms.h> // expected-error@*:* {{use of private header from outside its module: '__memory/ranges_uninitialized_algorithms.h'}}
 #include <__memory/raw_storage_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/raw_storage_iterator.h'}}

libcxx/test/libcxx/utilities/memory/ptr.align/assume_aligned.power2.verify.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// #include <memory>
+
+// template<size_t N, class T>
+// [[nodiscard]] constexpr T* assume_aligned(T* ptr);
+
+// This test checks that we static_assert inside std::assume_aligned<N>(p)
+// when N is not a power of two. However, Clang will already emit an error
+// in its own __builtin_assume_aligned, so we ignore that additional error
+// for the purpose of this test. We also ignore the additional warning about
+// remainder by 0 being undefined.
+// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error -Xclang -verify-ignore-unexpected=warning
+
+#include <memory>
+
+void f() {
+  int *p = nullptr;
+  (void)std::assume_aligned<0>(p);  // expected-error@*:* {{std::assume_aligned<N>(p) requires N to be a power of two}}
+  (void)std::assume_aligned<3>(p);  // expected-error@*:* {{std::assume_aligned<N>(p) requires N to be a power of two}}
+  (void)std::assume_aligned<5>(p);  // expected-error@*:* {{std::assume_aligned<N>(p) requires N to be a power of two}}
+  (void)std::assume_aligned<33>(p); // expected-error@*:* {{std::assume_aligned<N>(p) requires N to be a power of two}}
+}

libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.compile.pass.cpp

 
 # ifndef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++20"
 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should be defined in c++20"
-#   endif
-#   if __cpp_lib_assume_aligned != 201811L
-#     error "__cpp_lib_assume_aligned should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_assume_aligned
+#   error "__cpp_lib_assume_aligned should be defined in c++20"
+# endif
+# if __cpp_lib_assume_aligned != 201811L
+#   error "__cpp_lib_assume_aligned should have the value 201811L in c++20"
+# endif
 
 # ifndef __cpp_lib_atomic_value_initialization
 #   error "__cpp_lib_atomic_value_initialization should be defined in c++20"
 # endif
 # if __cpp_lib_atomic_value_initialization != 201911L
 #   error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++20"
 # endif
 

 
 # ifndef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2b"
 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should be defined in c++2b"
-#   endif
-#   if __cpp_lib_assume_aligned != 201811L
-#     error "__cpp_lib_assume_aligned should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_assume_aligned
+#   error "__cpp_lib_assume_aligned should be defined in c++2b"
+# endif
+# if __cpp_lib_assume_aligned != 201811L
+#   error "__cpp_lib_assume_aligned should have the value 201811L in c++2b"
+# endif
 
 # ifndef __cpp_lib_atomic_value_initialization
 #   error "__cpp_lib_atomic_value_initialization should be defined in c++2b"
 # endif
 # if __cpp_lib_atomic_value_initialization != 201911L
 #   error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2b"
 # endif
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

 # if __cpp_lib_as_const != 201510L
 #   error "__cpp_lib_as_const should have the value 201510L in c++20"
 # endif
 
 # ifdef __cpp_lib_associative_heterogeneous_erasure
 #   error "__cpp_lib_associative_heterogeneous_erasure should not be defined before c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should be defined in c++20"
-#   endif
-#   if __cpp_lib_assume_aligned != 201811L
-#     error "__cpp_lib_assume_aligned should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_assume_aligned
+#   error "__cpp_lib_assume_aligned should be defined in c++20"
+# endif
+# if __cpp_lib_assume_aligned != 201811L
+#   error "__cpp_lib_assume_aligned should have the value 201811L in c++20"
+# endif
 
 # ifndef __cpp_lib_atomic_flag_test
 #   error "__cpp_lib_atomic_flag_test should be defined in c++20"
 # endif
 # if __cpp_lib_atomic_flag_test != 201907L
 #   error "__cpp_lib_atomic_flag_test should have the value 201907L in c++20"
 # endif
 

 #     error "__cpp_lib_associative_heterogeneous_erasure should have the value 202110L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_associative_heterogeneous_erasure
 #     error "__cpp_lib_associative_heterogeneous_erasure should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should be defined in c++2b"
-#   endif
-#   if __cpp_lib_assume_aligned != 201811L
-#     error "__cpp_lib_assume_aligned should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_assume_aligned
-#     error "__cpp_lib_assume_aligned should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_assume_aligned
+#   error "__cpp_lib_assume_aligned should be defined in c++2b"
+# endif
+# if __cpp_lib_assume_aligned != 201811L
+#   error "__cpp_lib_assume_aligned should have the value 201811L in c++2b"
+# endif
 
 # ifndef __cpp_lib_atomic_flag_test
 #   error "__cpp_lib_atomic_flag_test should be defined in c++2b"
 # endif
 # if __cpp_lib_atomic_flag_test != 201907L
 #   error "__cpp_lib_atomic_flag_test should have the value 201907L in c++2b"
 # endif
 

libcxx/test/std/utilities/memory/ptr.align/assume_aligned.nodiscard.verify.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// #include <memory>
+
+// template<size_t N, class T>
+// [[nodiscard]] constexpr T* assume_aligned(T* ptr);
+
+#include <memory>
+
+void f() {
+  int *p = nullptr;
+  std::assume_aligned<4>(p); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}

libcxx/test/std/utilities/memory/ptr.align/assume_aligned.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// #include <memory>
+
+// template<size_t N, class T>
+// [[nodiscard]] constexpr T* assume_aligned(T* ptr);
+
+#include <memory>
+#include <cassert>
+#include <cstddef>
+
+#include "test_macros.h"
+
+template <typename T>
+constexpr void check(T* p) {
+  ASSERT_SAME_TYPE(T*, decltype(std::assume_aligned<1>(p)));
+  constexpr std::size_t alignment = alignof(T);
+
+  if constexpr (alignment >= 1)
+    assert(p == std::assume_aligned<1>(p));
+  if constexpr (alignment >= 2)
+    assert(p == std::assume_aligned<2>(p));
+  if constexpr (alignment >= 4)
+    assert(p == std::assume_aligned<4>(p));
+  if constexpr (alignment >= 8)
+    assert(p == std::assume_aligned<8>(p));
+  if constexpr (alignment >= 16)
+    assert(p == std::assume_aligned<16>(p));
+  if constexpr (alignment >= 32)
+    assert(p == std::assume_aligned<32>(p));
+  if constexpr (alignment >= 64)
+    assert(p == std::assume_aligned<64>(p));
+  if constexpr (alignment >= 128)
+    assert(p == std::assume_aligned<128>(p));
+}
+
+struct              S    { };
+struct alignas(  4) S4   { };
+struct alignas(  8) S8   { };
+struct alignas( 16) S16  { };
+struct alignas( 32) S32  { };
+struct alignas( 64) S64  { };
+struct alignas(128) S128 { };
+
+constexpr bool tests() {
+  char        c;
+  int         i;
+  long        l;
+  double      d;
+  long double ld;
+  check( &c);
+  check( &i);
+  check( &l);
+  check( &d);
+  check(&ld);
+
+  S    s;
+  S4   s4;
+  S8   s8;
+  S16  s16;
+  S32  s32;
+  S64  s64;
+  S128 s128;
+  check(&s);
+  check(&s4);
+  check(&s8);
+  check(&s16);
+  check(&s32);
+  check(&s64);
+  check(&s128);
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_associative_heterogeneous_erasure",
     "values": { "c++2b": 202110 },
     "headers": ["map", "set", "unordered_map", "unordered_set"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_assume_aligned",
     "values": { "c++20": 201811 },
     "headers": ["memory"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_flag_test",
     "values": { "c++20": 201907 },
     "headers": ["atomic"],
   }, {
     "name": "__cpp_lib_atomic_float",
     "values": { "c++20": 201711 },
     "headers": ["atomic"],