Line data Source code
1 : // Allocator that wraps operator new -*- C++ -*- 2 : 3 : // Copyright (C) 2001-2019 Free Software Foundation, Inc. 4 : // 5 : // This file is part of the GNU ISO C++ Library. This library is free 6 : // software; you can redistribute it and/or modify it under the 7 : // terms of the GNU General Public License as published by the 8 : // Free Software Foundation; either version 3, or (at your option) 9 : // any later version. 10 : 11 : // This library is distributed in the hope that it will be useful, 12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 : // GNU General Public License for more details. 15 : 16 : // Under Section 7 of GPL version 3, you are granted additional 17 : // permissions described in the GCC Runtime Library Exception, version 18 : // 3.1, as published by the Free Software Foundation. 19 : 20 : // You should have received a copy of the GNU General Public License and 21 : // a copy of the GCC Runtime Library Exception along with this program; 22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 : // <http://www.gnu.org/licenses/>. 24 : 25 : /** @file ext/new_allocator.h 26 : * This file is a GNU extension to the Standard C++ Library. 27 : */ 28 : 29 : #ifndef _NEW_ALLOCATOR_H 30 : #define _NEW_ALLOCATOR_H 1 31 : 32 : #include <bits/c++config.h> 33 : #include <new> 34 : #include <bits/functexcept.h> 35 : #include <bits/move.h> 36 : #if __cplusplus >= 201103L 37 : #include <type_traits> 38 : #endif 39 : 40 : namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 41 : { 42 : _GLIBCXX_BEGIN_NAMESPACE_VERSION 43 : 44 : using std::size_t; 45 : using std::ptrdiff_t; 46 : 47 : /** 48 : * @brief An allocator that uses global new, as per [20.4]. 49 : * @ingroup allocators 50 : * 51 : * This is precisely the allocator defined in the C++ Standard. 52 : * - all allocation calls operator new 53 : * - all deallocation calls operator delete 54 : * 55 : * @tparam _Tp Type of allocated object. 56 : */ 57 : template<typename _Tp> 58 : class new_allocator 59 : { 60 : public: 61 : typedef size_t size_type; 62 : typedef ptrdiff_t difference_type; 63 : typedef _Tp* pointer; 64 : typedef const _Tp* const_pointer; 65 : typedef _Tp& reference; 66 : typedef const _Tp& const_reference; 67 : typedef _Tp value_type; 68 : 69 : template<typename _Tp1> 70 : struct rebind 71 : { typedef new_allocator<_Tp1> other; }; 72 : 73 : #if __cplusplus >= 201103L 74 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 75 : // 2103. propagate_on_container_move_assignment 76 : typedef std::true_type propagate_on_container_move_assignment; 77 : #endif 78 : 79 : _GLIBCXX20_CONSTEXPR 80 2146575900 : new_allocator() _GLIBCXX_USE_NOEXCEPT { } 81 : 82 : _GLIBCXX20_CONSTEXPR 83 2024199726 : new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { } 84 : 85 : template<typename _Tp1> 86 : _GLIBCXX20_CONSTEXPR 87 : new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { } 88 : 89 4041262651 : ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } 90 : 91 : pointer 92 : address(reference __x) const _GLIBCXX_NOEXCEPT 93 : { return std::__addressof(__x); } 94 : 95 : const_pointer 96 : address(const_reference __x) const _GLIBCXX_NOEXCEPT 97 : { return std::__addressof(__x); } 98 : 99 : // NB: __n is permitted to be 0. The C++ standard says nothing 100 : // about what the return value is when __n == 0. 101 : _GLIBCXX_NODISCARD pointer 102 88218015 : allocate(size_type __n, const void* = static_cast<const void*>(0)) 103 : { 104 88218015 : if (__n > this->max_size()) 105 0 : std::__throw_bad_alloc(); 106 : 107 : #if __cpp_aligned_new 108 : if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) 109 : { 110 : std::align_val_t __al = std::align_val_t(alignof(_Tp)); 111 : return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al)); 112 : } 113 : #endif 114 58132004 : return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); 115 : } 116 : 117 : // __p is not permitted to be a null pointer. 118 : void 119 1362438898 : deallocate(pointer __p, size_type) 120 : { 121 : #if __cpp_aligned_new 122 : if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) 123 : { 124 : ::operator delete(__p, std::align_val_t(alignof(_Tp))); 125 : return; 126 : } 127 : #endif 128 1362438898 : ::operator delete(__p); 129 0 : } 130 : 131 : size_type 132 1173831932 : max_size() const _GLIBCXX_USE_NOEXCEPT 133 : { 134 : #if __PTRDIFF_MAX__ < __SIZE_MAX__ 135 : return size_t(__PTRDIFF_MAX__) / sizeof(_Tp); 136 : #else 137 : return size_t(-1) / sizeof(_Tp); 138 : #endif 139 : } 140 : 141 : #if __cplusplus >= 201103L 142 : template<typename _Up, typename... _Args> 143 : void 144 4112885769 : construct(_Up* __p, _Args&&... __args) 145 : noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) 146 5500109655 : { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } 147 : 148 : template<typename _Up> 149 : void 150 921292286 : destroy(_Up* __p) 151 : noexcept(std::is_nothrow_destructible<_Up>::value) 152 779479962 : { __p->~_Up(); } 153 : #else 154 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 155 : // 402. wrong new expression in [some_] allocator::construct 156 : void 157 : construct(pointer __p, const _Tp& __val) 158 : { ::new((void *)__p) _Tp(__val); } 159 : 160 : void 161 : destroy(pointer __p) { __p->~_Tp(); } 162 : #endif 163 : 164 : template<typename _Up> 165 : friend bool 166 : operator==(const new_allocator&, const new_allocator<_Up>&) 167 : _GLIBCXX_NOTHROW 168 : { return true; } 169 : 170 : template<typename _Up> 171 : friend bool 172 : operator!=(const new_allocator&, const new_allocator<_Up>&) 173 : _GLIBCXX_NOTHROW 174 : { return false; } 175 : }; 176 : 177 : _GLIBCXX_END_NAMESPACE_VERSION 178 : } // namespace 179 : 180 : #endif