From 9d25ada420feea3a3ffafbb3eeee3679da774042 Mon Sep 17 00:00:00 2001 From: Eric Fiselier Date: Wed, 28 Nov 2018 22:24:19 +0000 Subject: [PATCH] Revert "Move internal usages of `alignof`/`__alignof` to use `_LIBCPP_ALIGNOF`. " This reverts commit 087f065cb0c7463f521a62599884493aaee2ea12. The tests were failing on 32 bit builds, and I don't have time to clean them up right now. I'll recommit tomorrow with fixed tests. llvm-svn: 347816 --- libcxx/include/__config | 10 ------ libcxx/include/__sso_allocator | 4 +-- libcxx/include/experimental/coroutine | 6 ++-- libcxx/include/memory | 14 ++++---- libcxx/include/type_traits | 6 ++-- libcxx/include/valarray | 40 +++++++++++----------- libcxx/test/libcxx/libcpp_alignof.pass.cpp | 37 -------------------- .../sequences/array/size_and_alignment.pass.cpp | 2 ++ .../meta.trans.other/aligned_storage.pass.cpp | 9 +++-- libcxx/test/support/test_macros.h | 6 +--- 10 files changed, 44 insertions(+), 90 deletions(-) delete mode 100644 libcxx/test/libcxx/libcpp_alignof.pass.cpp diff --git a/libcxx/include/__config b/libcxx/include/__config index d4b82dd..e343ad5 100644 --- a/libcxx/include/__config +++ b/libcxx/include/__config @@ -1281,16 +1281,6 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container( #define _LIBCPP_HAS_NO_COROUTINES #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 - // FIXME: Correct this macro when either (A) a feature test macro for the // spaceship operator is provided, or (B) a compiler provides a complete // implementation. diff --git a/libcxx/include/__sso_allocator b/libcxx/include/__sso_allocator index 8aca049..e16b680 100644 --- a/libcxx/include/__sso_allocator +++ b/libcxx/include/__sso_allocator @@ -55,14 +55,14 @@ public: __allocated_ = true; return (pointer)&buf_; } - return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); + return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __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), _LIBCPP_ALIGNOF(_Tp)); + _VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), __alignof(_Tp)); } _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);} diff --git a/libcxx/include/experimental/coroutine b/libcxx/include/experimental/coroutine index 7cb39b8..1eb224a 100644 --- a/libcxx/include/experimental/coroutine +++ b/libcxx/include/experimental/coroutine @@ -214,7 +214,7 @@ 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)); } public: @@ -254,7 +254,7 @@ public: coroutine_handle __tmp; __tmp.__handle_ = __builtin_coro_promise( _VSTD::addressof(const_cast<_RawPromise&>(__promise)), - _LIBCPP_ALIGNOF(_Promise), true); + __alignof(_Promise), true); return __tmp; } }; @@ -272,7 +272,7 @@ 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; } diff --git a/libcxx/include/memory b/libcxx/include/memory index 68fc8cd..9fca9fe 100644 --- a/libcxx/include/memory +++ b/libcxx/include/memory @@ -1797,10 +1797,10 @@ public: if (__n > max_size()) __throw_length_error("allocator::allocate(size_t n)" " 'n' exceeds maximum supported size"); - return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); + return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); } _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT - {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));} + {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), __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) @@ -1898,10 +1898,10 @@ public: if (__n > max_size()) __throw_length_error("allocator::allocate(size_t n)" " 'n' exceeds maximum supported size"); - return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); + return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); } _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT - {_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));} _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) @@ -2017,7 +2017,7 @@ get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT 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))) { std::align_val_t __al = std::align_val_t(std::alignment_of<_Tp>::value); @@ -2028,7 +2028,7 @@ get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT __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. @@ -2052,7 +2052,7 @@ template 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)); } #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits index 61c9582..aadb97b 100644 --- a/libcxx/include/type_traits +++ b/libcxx/include/type_traits @@ -1649,7 +1649,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool has_unique_object_representations_v // alignment_of template struct _LIBCPP_TEMPLATE_VIS alignment_of - : public integral_constant {}; + : public integral_constant {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) template @@ -1812,8 +1812,8 @@ struct __static_max<_I0, _I1, _In...> template struct aligned_union { - static const size_t alignment_value = __static_max<_LIBCPP_ALIGNOF(_Type0), - _LIBCPP_ALIGNOF(_Types)...>::value; + static const size_t alignment_value = __static_max<__alignof__(_Type0), + __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; diff --git a/libcxx/include/valarray b/libcxx/include/valarray index 07f38c8..3188b6a 100644 --- a/libcxx/include/valarray +++ b/libcxx/include/valarray @@ -2740,7 +2740,7 @@ __val_expr<_ValExpr>::operator valarray<__val_expr::result_type>() const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(result_type), _LIBCPP_ALIGNOF(result_type))); + _VSTD::__libcpp_allocate(__n * sizeof(result_type), __alignof(result_type))); for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) ::new (__r.__end_) result_type(__expr_[__i]); } @@ -2758,7 +2758,7 @@ valarray<_Tp>::valarray(size_t __n) if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2793,7 +2793,7 @@ valarray<_Tp>::valarray(const value_type* __p, size_t __n) if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2819,7 +2819,7 @@ valarray<_Tp>::valarray(const valarray& __v) if (__v.size()) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2857,7 +2857,7 @@ valarray<_Tp>::valarray(initializer_list __il) if (__n) { __begin_ = __end_ = static_cast( -_VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); +_VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2887,7 +2887,7 @@ valarray<_Tp>::valarray(const slice_array& __sa) if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2915,7 +2915,7 @@ valarray<_Tp>::valarray(const gslice_array& __ga) if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2945,7 +2945,7 @@ valarray<_Tp>::valarray(const mask_array& __ma) if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2975,7 +2975,7 @@ valarray<_Tp>::valarray(const indirect_array& __ia) if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -3012,7 +3012,7 @@ valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) { __clear(size()); __begin_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); __end_ = __begin_ + __n; _VSTD::uninitialized_copy(__f, __l, __begin_); } else { @@ -3268,7 +3268,7 @@ valarray<_Tp>::operator+() const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(+*__p); } @@ -3286,7 +3286,7 @@ valarray<_Tp>::operator-() const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(-*__p); } @@ -3304,7 +3304,7 @@ valarray<_Tp>::operator~() const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(~*__p); } @@ -3321,7 +3321,7 @@ valarray<_Tp>::operator!() const { __r.__begin_ = __r.__end_ = - static_cast(_VSTD::__libcpp_allocate(__n * sizeof(bool), _LIBCPP_ALIGNOF(bool))); + static_cast(_VSTD::__libcpp_allocate(__n * sizeof(bool), __alignof(bool))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) bool(!*__p); } @@ -3642,7 +3642,7 @@ valarray<_Tp>::shift(int __i) const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); const value_type* __sb; value_type* __tb; value_type* __te; @@ -3681,7 +3681,7 @@ valarray<_Tp>::cshift(int __i) const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); __i %= static_cast(__n); const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) @@ -3703,7 +3703,7 @@ valarray<_Tp>::apply(value_type __f(value_type)) const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(__f(*__p)); } @@ -3721,7 +3721,7 @@ valarray<_Tp>::apply(value_type __f(const value_type&)) const __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(__f(*__p)); } @@ -3736,7 +3736,7 @@ void valarray<_Tp>::__clear(size_t __capacity) { while (__end_ != __begin_) (--__end_)->~value_type(); - _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)); + _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), __alignof(value_type)); __begin_ = __end_ = nullptr; } } @@ -3749,7 +3749,7 @@ valarray<_Tp>::resize(size_t __n, value_type __x) if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type))); + _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { diff --git a/libcxx/test/libcxx/libcpp_alignof.pass.cpp b/libcxx/test/libcxx/libcpp_alignof.pass.cpp deleted file mode 100644 index ba0df80..0000000 --- a/libcxx/test/libcxx/libcpp_alignof.pass.cpp +++ /dev/null @@ -1,37 +0,0 @@ -// -*- 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 -#include "test_macros.h" - -template -void test() { - static_assert(_LIBCPP_ALIGNOF(T) == std::alignment_of::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(); - test(); - test(); - test(); -} diff --git a/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp b/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp index d73182b..966d063 100644 --- a/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp +++ b/libcxx/test/std/containers/sequences/array/size_and_alignment.pass.cpp @@ -58,6 +58,8 @@ struct TEST_ALIGNAS(TEST_ALIGNOF(std::max_align_t) * 2) TestType2 { char data[1000]; }; +//static_assert(sizeof(void*) == 4, ""); + int main() { test_type(); test_type(); diff --git a/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp b/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp index 012741f..d7e35a6 100644 --- a/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp +++ b/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp @@ -254,6 +254,9 @@ int main() // 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 @@ -261,7 +264,7 @@ int main() #endif static_assert(std::is_trivial::value, ""); static_assert(std::is_standard_layout::value, ""); - static_assert(std::alignment_of::value == TEST_ALIGNOF(std::max_align_t), + static_assert(std::alignment_of::value == alignof(std::max_align_t), ""); static_assert(sizeof(T1) == 16, ""); } @@ -272,9 +275,9 @@ int main() #endif static_assert(std::is_trivial::value, ""); static_assert(std::is_standard_layout::value, ""); - static_assert(std::alignment_of::value == TEST_ALIGNOF(std::max_align_t), + static_assert(std::alignment_of::value == alignof(std::max_align_t), ""); - static_assert(sizeof(T1) == 16 + TEST_ALIGNOF(std::max_align_t), ""); + static_assert(sizeof(T1) == 16 + alignof(std::max_align_t), ""); } { typedef std::aligned_storage<10>::type T1; diff --git a/libcxx/test/support/test_macros.h b/libcxx/test/support/test_macros.h index cee8a38..88cc4d5 100644 --- a/libcxx/test/support/test_macros.h +++ b/libcxx/test/support/test_macros.h @@ -115,11 +115,7 @@ # define TEST_THROW_SPEC(...) throw(__VA_ARGS__) # endif #else -#if defined(TEST_COMPILER_CLANG) -# define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__) -#else -# define TEST_ALIGNOF(...) __alignof(__VA_ARGS__) -#endif +#define TEST_ALIGNOF(...) __alignof(__VA_ARGS__) #define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__))) #define TEST_CONSTEXPR #define TEST_CONSTEXPR_CXX14 -- 2.7.4