[libc++] Use _Alignas instead of __attribute__((__aligned__()))

[philnik]

• Fix CI

libcxx/.clang-format

 AllowShortLambdasOnASingleLine: All
 AttributeMacros: ['_LIBCPP_HIDE_FROM_ABI',
                   '_LIBCPP_CONSTEXPR',
                   '_LIBCPP_CONSTEXPR_AFTER_CXX11',
                   '_LIBCPP_CONSTEXPR_AFTER_CXX14',
                   '_LIBCPP_CONSTEXPR_AFTER_CXX17',
                   '_LIBCPP_CONSTEXPR_AFTER_CXX20',
                   '_LIBCPP_ALIGNOF',
-                  '_ALIGNAS_TYPE',
                   '_ALIGNAS',
                   '_LIBCPP_NORETURN',
                   '_LIBCPP_ALWAYS_INLINE',
                   '_LIBCPP_DISABLE_EXTENTSION_WARNING',
                   '_LIBCPP_HIDDEN',
                   '_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS',
                   '_LIBCPP_FUNC_VIS',
                   '_LIBCPP_TYPE_VIS',

libcxx/include/__config

 #    define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
 #  else
 #    define _LIBCPP_NO_CFI
 #  endif
 
 #  ifndef _LIBCPP_CXX03_LANG
 
 #    define _LIBCPP_ALIGNOF(_Tp) alignof(_Tp)
-#    define _ALIGNAS_TYPE(x) alignas(x)
-#    define _ALIGNAS(x) alignas(x)
+#    define _ALIGNAS(...) alignas(__VA_ARGS__)
 #    define _LIBCPP_NORETURN [[noreturn]]
 #    define _NOEXCEPT noexcept
 #    define _NOEXCEPT_(x) noexcept(x)
 
 #  else
 
 #    define _LIBCPP_ALIGNOF(_Tp) _Alignof(_Tp)
-#    define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
-#    define _ALIGNAS(x) __attribute__((__aligned__(x)))
+#    define _ALIGNAS(...) _Alignas(__VA_ARGS__)
 #    define _LIBCPP_NORETURN __attribute__((noreturn))
 #    define _LIBCPP_HAS_NO_NOEXCEPT
 #    define nullptr __nullptr
 #    define _NOEXCEPT throw()
 #    define _NOEXCEPT_(x)
 
 typedef __char16_t char16_t;
 typedef __char32_t char32_t;

libcxx/include/__memory/shared_ptr.h

#endif
     // through `std::allocate_shared` and `std::make_shared`.
     //
     // In previous versions of the library, we used a compressed pair to store
     // both the _Alloc and the _Tp. This implies using EBO, which is incompatible
     // with Allocator construction for _Tp. To allow implementing P0674 in C++20,
     // we now use a properly aligned char buffer while making sure that we maintain
     // the same layout that we had when we used a compressed pair.
     using _CompressedPair = __compressed_pair<_Alloc, _Tp>;
-    struct _ALIGNAS_TYPE(_CompressedPair) _Storage {
+    struct _ALIGNAS(_CompressedPair) _Storage {
         char __blob_[sizeof(_CompressedPair)];
 
         _LIBCPP_HIDE_FROM_ABI explicit _Storage(_Alloc&& __a) {
             ::new ((void*)__get_alloc()) _Alloc(_VSTD::move(__a));
         }
         _LIBCPP_HIDE_FROM_ABI ~_Storage() {
             __get_alloc()->~_Alloc();
         }

libcxx/include/array

struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
     typedef ptrdiff_t                             difference_type;
     typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
 
     typedef typename conditional<is_const<_Tp>::value, const char,
                                 char>::type _CharType;
 
     struct  _ArrayInStructT { _Tp __data_[1]; };
-    _ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
+    _ALIGNAS(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     value_type* data() _NOEXCEPT {return nullptr;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const value_type* data() const _NOEXCEPT {return nullptr;}
 
     // No explicit construct/copy/destroy for aggregate type
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

libcxx/src/iostream.cpp

 #include <string>
 
 #define _str(s) #s
 #define str(s) _str(s)
 #define _LIBCPP_ABI_NAMESPACE_STR str(_LIBCPP_ABI_NAMESPACE)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-_ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)]
+_ALIGNAS (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?cin@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_istream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
-_ALIGNAS_TYPE (__stdinbuf<char> ) static char __cin[sizeof(__stdinbuf <char>)];
+_ALIGNAS (__stdinbuf<char> ) static char __cin[sizeof(__stdinbuf <char>)];
 static mbstate_t mb_cin;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin[sizeof(wistream)]
+_ALIGNAS (wistream) _LIBCPP_FUNC_VIS char wcin[sizeof(wistream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?wcin@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_istream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
-_ALIGNAS_TYPE (__stdinbuf<wchar_t> ) static char __wcin[sizeof(__stdinbuf <wchar_t>)];
+_ALIGNAS (__stdinbuf<wchar_t> ) static char __wcin[sizeof(__stdinbuf <wchar_t>)];
 static mbstate_t mb_wcin;
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)]
+_ALIGNAS (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?cout@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
-_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)];
+_ALIGNAS (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)];
 static mbstate_t mb_cout;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)]
+_ALIGNAS (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?wcout@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
-_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
+_ALIGNAS (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
 static mbstate_t mb_wcout;
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]
+_ALIGNAS (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?cerr@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
-_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)];
+_ALIGNAS (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)];
 static mbstate_t mb_cerr;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)]
+_ALIGNAS (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?wcerr@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
-_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
+_ALIGNAS (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
 static mbstate_t mb_wcerr;
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]
+_ALIGNAS (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?clog@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)]
+_ALIGNAS (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?wclog@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 // Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
 // attribute with a value that's reserved for the implementation (we're the implementation).

libcxx/test/std/atomics/atomics.flag/default.pass.cpp

 
 int main(int, char**)
 {
     std::atomic_flag f;
     f.clear();
     assert(f.test_and_set() == 0);
     {
         typedef std::atomic_flag A;
-        TEST_ALIGNAS_TYPE(A) char storage[sizeof(A)] = {1};
+        TEST_ALIGNAS(A) char storage[sizeof(A)] = {1};
         A& zero = *new (storage) A();
         assert(!zero.test_and_set());
         zero.~A();
     }
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.generic/address.pass.cpp

do_test()
     assert(obj == T(0));
     obj = T(2*sizeof(X));
     assert((obj += std::ptrdiff_t(3)) == T(5*sizeof(X)));
     assert(obj == T(5*sizeof(X)));
     assert((obj -= std::ptrdiff_t(3)) == T(2*sizeof(X)));
     assert(obj == T(2*sizeof(X)));
 
     {
-        TEST_ALIGNAS_TYPE(A) char storage[sizeof(A)] = {23};
+        TEST_ALIGNAS(A) char storage[sizeof(A)] = {23};
         A& zero = *new (storage) A();
         assert(zero == T(0));
         zero.~A();
     }
 }
 
 template <class A, class T>
 void test()

libcxx/test/std/atomics/atomics.types.generic/bool.pass.cpp

int main(int, char**)
         assert(x == true);
         assert((obj = false) == false);
         assert(obj == false);
         assert((obj = true) == true);
         assert(obj == true);
     }
     {
         typedef std::atomic<bool> A;
-        TEST_ALIGNAS_TYPE(A) char storage[sizeof(A)] = {1};
+        TEST_ALIGNAS(A) char storage[sizeof(A)] = {1};
         A& zero = *new (storage) A();
         assert(zero == false);
         zero.~A();
     }
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

do_test()
     assert((obj |= T(5)) == T(7));
     assert(obj == T(7));
     assert((obj &= T(0xF)) == T(7));
     assert(obj == T(7));
     assert((obj ^= T(0xF)) == T(8));
     assert(obj == T(8));
 
     {
-        TEST_ALIGNAS_TYPE(A) char storage[sizeof(A)] = {23};
+        TEST_ALIGNAS(A) char storage[sizeof(A)] = {23};
         A& zero = *new (storage) A();
         assert(zero == 0);
         zero.~A();
     }
 }
 
 template <class A, class T>
 void test()

libcxx/test/support/test_macros.h

 # define TEST_NOEXCEPT_FALSE noexcept(false)
 # define TEST_NOEXCEPT_COND(...) noexcept(__VA_ARGS__)
 #else
 #   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_ALIGNAS(...) _Alignas(__VA_ARGS__)
 # define TEST_CONSTEXPR
 # define TEST_NOEXCEPT throw()
 # define TEST_NOEXCEPT_FALSE
 # define TEST_NOEXCEPT_COND(...)
 #endif
 
 #if TEST_STD_VER >= 11
 # define TEST_THROW_SPEC(...)

 #endif
 
 #if TEST_STD_VER >= 20
 # define TEST_CONSTEXPR_CXX20 constexpr
 #else
 # define TEST_CONSTEXPR_CXX20
 #endif
 
-#define TEST_ALIGNAS_TYPE(...) TEST_ALIGNAS(TEST_ALIGNOF(__VA_ARGS__))
-
 #if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cpp_rtti) \
     && !defined(__GXX_RTTI)
 #define TEST_HAS_NO_RTTI
 #endif
 
 #if !defined(TEST_HAS_NO_RTTI)
 # define RTTI_ASSERT(X) assert(X)
 #else