From 9bbee38db3b12c47a898e2723b69342355cdfe4f Mon Sep 17 00:00:00 2001 From: Eric Christopher Date: Thu, 25 Oct 2018 06:20:12 +0000 Subject: [PATCH] Temporarily Revert "Implement sized deallocation for std::allocator and friends." This is breaking the bots here (and related): http://lab.llvm.org:8011/builders/libcxx-libcxxabi-x86_64-linux-ubuntu-asan/builds/1428 This reverts commit r345214. llvm-svn: 345239 --- libcxx/include/__sso_allocator | 4 +- libcxx/include/memory | 10 +- libcxx/include/new | 101 ++------- libcxx/include/valarray | 68 +++--- libcxx/src/experimental/memory_resource.cpp | 4 +- .../support.dynamic/libcpp_deallocate.sh.cpp | 245 --------------------- 6 files changed, 55 insertions(+), 377 deletions(-) delete mode 100644 libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp diff --git a/libcxx/include/__sso_allocator b/libcxx/include/__sso_allocator index e16b680..4002736 100644 --- a/libcxx/include/__sso_allocator +++ b/libcxx/include/__sso_allocator @@ -57,12 +57,12 @@ public: } return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); } - _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) + _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) { if (__p == (pointer)&buf_) __allocated_ = false; else - _VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), __alignof(_Tp)); + _VSTD::__libcpp_deallocate(__p, __alignof(_Tp)); } _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);} diff --git a/libcxx/include/memory b/libcxx/include/memory index ef35cc2..1d28a52 100644 --- a/libcxx/include/memory +++ b/libcxx/include/memory @@ -1799,8 +1799,8 @@ public: " 'n' exceeds maximum supported size"); 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), __alignof(_Tp));} + _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT + {_VSTD::__libcpp_deallocate((void*)__p, __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) @@ -1900,8 +1900,8 @@ public: " 'n' exceeds maximum supported size"); 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), __alignof(_Tp));} + _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT + {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __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) @@ -2052,7 +2052,7 @@ template inline _LIBCPP_INLINE_VISIBILITY void return_temporary_buffer(_Tp* __p) _NOEXCEPT { - _VSTD::__libcpp_deallocate_unsized((void*)__p, __alignof(_Tp)); + _VSTD::__libcpp_deallocate((void*)__p, __alignof(_Tp)); } #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) diff --git a/libcxx/include/new b/libcxx/include/new index 412d51b..09d5162 100644 --- a/libcxx/include/new +++ b/libcxx/include/new @@ -104,17 +104,12 @@ void operator delete[](void* ptr, void*) noexcept; #pragma GCC system_header #endif -#if !defined(__cpp_sized_deallocation) || __cpp_sized_deallocation < 201309L -#define _LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION -#endif - -#if !defined(_LIBCPP_BUILDING_LIBRARY) && _LIBCPP_STD_VER < 14 && \ - defined(_LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION) +#if !defined(_LIBCPP_BUILDING_LIBRARY) && _LIBCPP_STD_VER < 14 # define _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION #endif #if defined(_LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION) || \ - defined(_LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION) + !defined(__cpp_sized_deallocation) || __cpp_sized_deallocation < 201309 # define _LIBCPP_HAS_NO_SIZED_DEALLOCATION #endif @@ -260,94 +255,24 @@ inline _LIBCPP_INLINE_VISIBILITY void *__libcpp_allocate(size_t __size, size_t _ #endif } -struct _DeallocateCaller { - static inline _LIBCPP_INLINE_VISIBILITY - void __do_deallocate_handle_size_align(void *__ptr, size_t __size, size_t __align) { -#if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) - ((void)__align); - return __do_deallocate_handle_size(__ptr, __size); -#else - if (__is_overaligned_for_new(__align)) { - const align_val_t __align_val = static_cast(__align); - return __do_deallocate_handle_size(__ptr, __size, __align_val); - } else { - return __do_deallocate_handle_size(__ptr, __size); - } -#endif - } - - static inline _LIBCPP_INLINE_VISIBILITY - void __do_deallocate_handle_align(void *__ptr, size_t __align) { -#if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) - ((void)__align); - return __do_call(__ptr); -#else - if (__is_overaligned_for_new(__align)) { - const align_val_t __align_val = static_cast(__align); - return __do_call(__ptr, __align_val); - } else { - return __do_call(__ptr); - } -#endif - } - - private: - static inline void __do_deallocate_handle_size(void *__ptr, size_t __size) { -#ifdef _LIBCPP_HAS_NO_SIZED_DEALLOCATION - ((void)__size); - return __do_call(__ptr); -#else - return __do_call(__ptr, __size); -#endif - } - +inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate(void* __ptr, size_t __align) { #ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION - static inline void __do_deallocate_handle_size(void *__ptr, size_t __size, align_val_t __align) { -#ifdef _LIBCPP_HAS_NO_SIZED_DEALLOCATION - ((void)__size); - return __do_call(__ptr, __align); -#else - return __do_call(__ptr, __size, __align); -#endif - } -#endif - -private: - template - static inline void __do_call(void *__ptr, _A1 __a1, _A2 __a2) { -#if defined(_LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE) || \ - defined(_LIBCPP_HAS_NO_BUILTIN_OVERLOADED_OPERATOR_NEW_DELETE) - return ::operator delete(__ptr, __a1, __a2); -#else - return __builtin_operator_delete(__ptr, __a1, __a2); -#endif + if (__is_overaligned_for_new(__align)) { + const align_val_t __align_val = static_cast(__align); +# ifdef _LIBCPP_HAS_NO_BUILTIN_OVERLOADED_OPERATOR_NEW_DELETE + return ::operator delete(__ptr, __align_val); +# else + return __builtin_operator_delete(__ptr, __align_val); +# endif } - - template - static inline void __do_call(void *__ptr, _A1 __a1) { -#if defined(_LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE) || \ - defined(_LIBCPP_HAS_NO_BUILTIN_OVERLOADED_OPERATOR_NEW_DELETE) - return ::operator delete(__ptr, __a1); #else - return __builtin_operator_delete(__ptr, __a1); + ((void)__align); #endif - } - - static inline void __do_call(void *__ptr) { #ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE - return ::operator delete(__ptr); + return ::operator delete(__ptr); #else - return __builtin_operator_delete(__ptr); + return __builtin_operator_delete(__ptr); #endif - } -}; - -inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) { - _DeallocateCaller::__do_deallocate_handle_size_align(__ptr, __size, __align); -} - -inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate_unsized(void* __ptr, size_t __align) { - _DeallocateCaller::__do_deallocate_handle_align(__ptr, __align); } #ifdef _LIBCPP_BAD_ARRAY_LENGTH_DEFINED diff --git a/libcxx/include/valarray b/libcxx/include/valarray index 027436d..a941e3e 100644 --- a/libcxx/include/valarray +++ b/libcxx/include/valarray @@ -1054,7 +1054,7 @@ private: const _Up* end(const valarray<_Up>& __v); - void __clear(size_t __capacity); + void __clear(); valarray& __assign_range(const value_type* __f, const value_type* __l); }; @@ -2762,13 +2762,13 @@ valarray<_Tp>::valarray(size_t __n) try { #endif // _LIBCPP_NO_EXCEPTIONS - for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) + for (; __n; --__n, ++__end_) ::new (__end_) value_type(); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2797,13 +2797,13 @@ valarray<_Tp>::valarray(const value_type* __p, size_t __n) try { #endif // _LIBCPP_NO_EXCEPTIONS - for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left) + for (; __n; ++__end_, ++__p, --__n) ::new (__end_) value_type(*__p); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2829,7 +2829,7 @@ valarray<_Tp>::valarray(const valarray& __v) } catch (...) { - __clear(__v.size()); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2852,7 +2852,7 @@ valarray<_Tp>::valarray(initializer_list __il) : __begin_(0), __end_(0) { - const size_t __n = __il.size(); + size_t __n = __il.size(); if (__n) { __begin_ = __end_ = static_cast( @@ -2861,14 +2861,13 @@ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); try { #endif // _LIBCPP_NO_EXCEPTIONS - size_t __n_left = __n; - for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left) + for (const value_type* __p = __il.begin(); __n; ++__end_, ++__p, --__n) ::new (__end_) value_type(*__p); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2882,7 +2881,7 @@ valarray<_Tp>::valarray(const slice_array& __sa) : __begin_(0), __end_(0) { - const size_t __n = __sa.__size_; + size_t __n = __sa.__size_; if (__n) { __begin_ = __end_ = static_cast( @@ -2891,14 +2890,13 @@ valarray<_Tp>::valarray(const slice_array& __sa) 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) + for (const value_type* __p = __sa.__vp_; __n; ++__end_, __p += __sa.__stride_, --__n) ::new (__end_) value_type(*__p); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2910,7 +2908,7 @@ valarray<_Tp>::valarray(const gslice_array& __ga) : __begin_(0), __end_(0) { - const size_t __n = __ga.__1d_.size(); + size_t __n = __ga.__1d_.size(); if (__n) { __begin_ = __end_ = static_cast( @@ -2928,7 +2926,7 @@ valarray<_Tp>::valarray(const gslice_array& __ga) } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2940,7 +2938,7 @@ valarray<_Tp>::valarray(const mask_array& __ma) : __begin_(0), __end_(0) { - const size_t __n = __ma.__1d_.size(); + size_t __n = __ma.__1d_.size(); if (__n) { __begin_ = __end_ = static_cast( @@ -2958,7 +2956,7 @@ valarray<_Tp>::valarray(const mask_array& __ma) } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2970,7 +2968,7 @@ valarray<_Tp>::valarray(const indirect_array& __ia) : __begin_(0), __end_(0) { - const size_t __n = __ia.__1d_.size(); + size_t __n = __ia.__1d_.size(); if (__n) { __begin_ = __end_ = static_cast( @@ -2988,7 +2986,7 @@ valarray<_Tp>::valarray(const indirect_array& __ia) } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS @@ -2999,7 +2997,7 @@ template inline valarray<_Tp>::~valarray() { - __clear(size()); + __clear(); } template @@ -3009,7 +3007,7 @@ valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) size_t __n = __l - __f; if (size() != __n) { - __clear(size()); + __clear(); __begin_ = static_cast( _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); __end_ = __begin_ + __n; @@ -3036,7 +3034,7 @@ inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT { - __clear(size()); + __clear(); __begin_ = __v.__begin_; __end_ = __v.__end_; __v.__begin_ = nullptr; @@ -3728,23 +3726,23 @@ valarray<_Tp>::apply(value_type __f(const value_type&)) const } template -inline _LIBCPP_INLINE_VISIBILITY -void valarray<_Tp>::__clear(size_t __capacity) +void +valarray<_Tp>::__clear() { - if (__begin_ != nullptr) - { - while (__end_ != __begin_) - (--__end_)->~value_type(); - _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), __alignof(value_type)); - __begin_ = __end_ = nullptr; - } + if (__begin_ != nullptr) + { + while (__end_ != __begin_) + (--__end_)->~value_type(); + _VSTD::__libcpp_deallocate(__begin_, __alignof(value_type)); + __begin_ = __end_ = nullptr; + } } template void valarray<_Tp>::resize(size_t __n, value_type __x) { - __clear(size()); + __clear(); if (__n) { __begin_ = __end_ = static_cast( @@ -3753,13 +3751,13 @@ valarray<_Tp>::resize(size_t __n, value_type __x) try { #endif // _LIBCPP_NO_EXCEPTIONS - for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) + for (; __n; --__n, ++__end_) ::new (__end_) value_type(__x); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - __clear(__n); + __clear(); throw; } #endif // _LIBCPP_NO_EXCEPTIONS diff --git a/libcxx/src/experimental/memory_resource.cpp b/libcxx/src/experimental/memory_resource.cpp index 1f31f88..a3b64cc8 100644 --- a/libcxx/src/experimental/memory_resource.cpp +++ b/libcxx/src/experimental/memory_resource.cpp @@ -33,8 +33,8 @@ protected: virtual void* do_allocate(size_t __size, size_t __align) { return _VSTD::__libcpp_allocate(__size, __align); /* FIXME */} - virtual void do_deallocate(void * __p, size_t __n, size_t __align) - { _VSTD::__libcpp_deallocate(__p, __n, __align); /* FIXME */ } + virtual void do_deallocate(void * __p, size_t, size_t __align) + { _VSTD::__libcpp_deallocate(__p, __align); /* FIXME */ } virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT { return &__other == this; } diff --git a/libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp b/libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp deleted file mode 100644 index 8ffba79..0000000 --- a/libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp +++ /dev/null @@ -1,245 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 libc++'s implementation of align_val_t, and the relevent new/delete -// overloads in all dialects when -faligned-allocation is present. - -// Libc++ defers to the underlying MSVC library to provide the new/delete -// definitions, which does not yet provide aligned allocation -// XFAIL: LIBCXX-WINDOWS-FIXME - -// XFAIL: with_system_cxx_lib=macosx10.12 -// XFAIL: with_system_cxx_lib=macosx10.11 -// XFAIL: with_system_cxx_lib=macosx10.10 -// XFAIL: with_system_cxx_lib=macosx10.9 -// XFAIL: with_system_cxx_lib=macosx10.7 -// XFAIL: with_system_cxx_lib=macosx10.8 - -// RUN: %build -faligned-allocation -fsized-deallocation -// RUN: %run -// RUN: %build -faligned-allocation -fno-sized-deallocation -DNO_SIZE -// RUN: %run -// RUN: %build -fno-aligned-allocation -fsized-deallocation -DNO_ALIGN -// RUN: %run -// RUN: %build -fno-aligned-allocation -fno-sized-deallocation -DNO_ALIGN -DNO_SIZE -// RUN: %run - - -#include -#include -#include -#include - -#include "test_macros.h" - -struct alloc_stats { - alloc_stats() { reset(); } - - int aligned_sized_called; - int aligned_called; - int sized_called; - int plain_called; - int last_size; - int last_align; - - void reset() { - aligned_sized_called = aligned_called = sized_called = plain_called = 0; - last_align = last_size = -1; - } - - bool expect_plain() const { - assert(aligned_sized_called == 0); - assert(aligned_called == 0); - assert(sized_called == 0); - assert(last_size == -1); - assert(last_align == -1); - return plain_called == 1; - } - - bool expect_size(int n) const { - assert(plain_called == 0); - assert(aligned_sized_called == 0); - assert(aligned_called == 0); - assert(last_size == n); - assert(last_align == -1); - return sized_called == 1; - } - - bool expect_align(int a) const { - assert(plain_called == 0); - assert(aligned_sized_called == 0); - assert(sized_called == 0); - assert(last_size == -1); - assert(last_align == a); - return aligned_called == 1; - } - - bool expect_size_align(int n, int a) const { - assert(plain_called == 0); - assert(sized_called == 0); - assert(aligned_called == 0); - assert(last_size == n); - assert(last_align == a); - return aligned_sized_called == 1; - } -}; -alloc_stats stats; - -void operator delete(void *p) TEST_NOEXCEPT { - ::free(p); - stats.plain_called++; - stats.last_size = stats.last_align = -1; -} - -#ifndef NO_SIZE -void operator delete(void *p, size_t n) TEST_NOEXCEPT { - ::free(p); - stats.sized_called++; - stats.last_size = n; - stats.last_align = -1; -} -#endif - -#ifndef NO_ALIGN -void operator delete(void *p, std::align_val_t a) TEST_NOEXCEPT { - ::free(p); - stats.aligned_called++; - stats.last_align = static_cast(a); - stats.last_size = -1; -} - -void operator delete(void * p, size_t n, std::align_val_t a) TEST_NOEXCEPT { - ::free(p); - stats.aligned_sized_called++; - stats.last_align = static_cast(a); - stats.last_size = n; -} -#endif - -void test_libcpp_dealloc() { - void *p = nullptr; - size_t over_align_val = TEST_ALIGNOF(std::max_align_t) * 2; - size_t under_align_val = TEST_ALIGNOF(int); - size_t with_size_val = 2; - - { - std::__libcpp_deallocate_unsized(p, under_align_val); - assert(stats.expect_plain()); - } - stats.reset(); - -#if defined(NO_SIZE) && defined(NO_ALIGN) - { - std::__libcpp_deallocate(p, with_size_val, over_align_val); - assert(stats.expect_plain()); - } - stats.reset(); -#elif defined(NO_SIZE) - { - std::__libcpp_deallocate(p, with_size_val, over_align_val); - assert(stats.expect_align(over_align_val)); - } - stats.reset(); -#elif defined(NO_ALIGN) - { - std::__libcpp_deallocate(p, with_size_val, over_align_val); - assert(stats.expect_size(with_size_val)); - } - stats.reset(); -#else - { - std::__libcpp_deallocate(p, with_size_val, over_align_val); - assert(stats.expect_size_align(with_size_val, over_align_val)); - } - stats.reset(); - { - std::__libcpp_deallocate_unsized(p, over_align_val); - assert(stats.expect_align(over_align_val)); - } - stats.reset(); - { - std::__libcpp_deallocate(p, with_size_val, under_align_val); - assert(stats.expect_size(with_size_val)); - } - stats.reset(); -#endif -} - -struct TEST_ALIGNAS(128) AlignedType { - AlignedType() : elem(0) {} - TEST_ALIGNAS(128) char elem; -}; - -void test_allocator_and_new_match() { - stats.reset(); -#if defined(NO_SIZE) && defined(NO_ALIGN) - { - int *x = new int(42); - delete x; - assert(stats.expect_plain()); - } - stats.reset(); - { - AlignedType *a = new AlignedType(); - delete a; - assert(stats.expect_plain()); - } - stats.reset(); -#elif defined(NO_SIZE) - stats.reset(); -#if TEST_STD_VER >= 11 - { - int *x = new int(42); - delete x; - assert(stats.expect_plain()); - } -#endif - stats.reset(); - { - AlignedType *a = new AlignedType(); - delete a; - assert(stats.expect_align(TEST_ALIGNOF(AlignedType))); - } - stats.reset(); -#elif defined(NO_ALIGN) - stats.reset(); - { - int *x = new int(42); - delete x; - assert(stats.expect_size(sizeof(int))); - - } - stats.reset(); - { - AlignedType *a = new AlignedType(); - delete a; - assert(stats.expect_size(sizeof(AlignedType))); - } - stats.reset(); -#else - stats.reset(); - { - int *x = new int(42); - delete x; - assert(stats.expect_size(sizeof(int))); - } - stats.reset(); - { - AlignedType *a = new AlignedType(); - delete a; - assert(stats.expect_size_align(sizeof(AlignedType), TEST_ALIGNOF(AlignedType))); - } - stats.reset(); -#endif -} - -int main() { - test_libcpp_dealloc(); - test_allocator_and_new_match(); -} -- 2.7.4