1 | // <memory> -*- 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 | /* |
26 | * Copyright (c) 1997-1999 |
27 | * Silicon Graphics Computer Systems, Inc. |
28 | * |
29 | * Permission to use, copy, modify, distribute and sell this software |
30 | * and its documentation for any purpose is hereby granted without fee, |
31 | * provided that the above copyright notice appear in all copies and |
32 | * that both that copyright notice and this permission notice appear |
33 | * in supporting documentation. Silicon Graphics makes no |
34 | * representations about the suitability of this software for any |
35 | * purpose. It is provided "as is" without express or implied warranty. |
36 | * |
37 | */ |
38 | |
39 | /** @file include/memory |
40 | * This is a Standard C++ Library header. |
41 | */ |
42 | |
43 | #ifndef _GLIBCXX_MEMORY |
44 | #define _GLIBCXX_MEMORY 1 |
45 | |
46 | #pragma GCC system_header |
47 | |
48 | /** |
49 | * @defgroup memory Memory |
50 | * @ingroup utilities |
51 | * |
52 | * Components for memory allocation, deallocation, and management. |
53 | */ |
54 | |
55 | /** |
56 | * @defgroup pointer_abstractions Pointer Abstractions |
57 | * @ingroup memory |
58 | * |
59 | * Smart pointers, etc. |
60 | */ |
61 | |
62 | #include <bits/stl_algobase.h> |
63 | #include <bits/allocator.h> |
64 | #include <bits/stl_construct.h> |
65 | #include <bits/stl_uninitialized.h> |
66 | #include <bits/stl_tempbuf.h> |
67 | #include <bits/stl_raw_storage_iter.h> |
68 | |
69 | #if __cplusplus >= 201103L |
70 | # include <exception> // std::exception |
71 | # include <typeinfo> // std::type_info in get_deleter |
72 | # include <iosfwd> // std::basic_ostream |
73 | # include <ext/atomicity.h> |
74 | # include <ext/concurrence.h> |
75 | # include <bits/functexcept.h> |
76 | # include <bits/stl_function.h> // std::less |
77 | # include <bits/uses_allocator.h> |
78 | # include <type_traits> |
79 | # include <debug/debug.h> |
80 | # include <bits/unique_ptr.h> |
81 | # include <bits/shared_ptr.h> |
82 | # include <bits/shared_ptr_atomic.h> |
83 | # if _GLIBCXX_USE_DEPRECATED |
84 | # include <backward/auto_ptr.h> |
85 | # endif |
86 | #else |
87 | # include <backward/auto_ptr.h> |
88 | #endif |
89 | |
90 | #if __cplusplus >= 201103L |
91 | #include <cstdint> |
92 | #if __cplusplus > 201703L |
93 | # include <bit> // for ispow2 |
94 | # include <new> // for placement operator new |
95 | # include <tuple> // for tuple, make_tuple, make_from_tuple |
96 | #endif |
97 | namespace std _GLIBCXX_VISIBILITY(default) |
98 | { |
99 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
100 | |
101 | /** |
102 | * @brief Fit aligned storage in buffer. |
103 | * |
104 | * [ptr.align] |
105 | * |
106 | * This function tries to fit @a __size bytes of storage with alignment |
107 | * @a __align into the buffer @a __ptr of size @a __space bytes. If such |
108 | * a buffer fits then @a __ptr is changed to point to the first byte of the |
109 | * aligned storage and @a __space is reduced by the bytes used for alignment. |
110 | * |
111 | * @param __align A fundamental or extended alignment value. |
112 | * @param __size Size of the aligned storage required. |
113 | * @param __ptr Pointer to a buffer of @a __space bytes. |
114 | * @param __space Size of the buffer pointed to by @a __ptr. |
115 | * @return the updated pointer if the aligned storage fits, otherwise nullptr. |
116 | */ |
117 | inline void* |
118 | align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept |
119 | { |
120 | #ifdef _GLIBCXX_USE_C99_STDINT_TR1 |
121 | const auto __intptr = reinterpret_cast<uintptr_t>(__ptr); |
122 | #else |
123 | // Cannot use std::uintptr_t so assume that std::size_t can be used instead. |
124 | static_assert(sizeof(size_t) >= sizeof(void*), |
125 | "std::size_t must be a suitable substitute for std::uintptr_t" ); |
126 | const auto __intptr = reinterpret_cast<unsigned long long>(__ptr); |
127 | #endif |
128 | const auto __aligned = (__intptr - 1u + __align) & -__align; |
129 | const auto __diff = __aligned - __intptr; |
130 | if ((__size + __diff) > __space) |
131 | return nullptr; |
132 | else |
133 | { |
134 | __space -= __diff; |
135 | return __ptr = reinterpret_cast<void*>(__aligned); |
136 | } |
137 | } |
138 | |
139 | // 20.7.4 [util.dynamic.safety], pointer safety |
140 | |
141 | enum class pointer_safety { relaxed, preferred, strict }; |
142 | |
143 | inline void |
144 | declare_reachable(void*) { } |
145 | |
146 | template <typename _Tp> |
147 | inline _Tp* |
148 | undeclare_reachable(_Tp* __p) { return __p; } |
149 | |
150 | inline void |
151 | declare_no_pointers(char*, size_t) { } |
152 | |
153 | inline void |
154 | undeclare_no_pointers(char*, size_t) { } |
155 | |
156 | inline pointer_safety |
157 | get_pointer_safety() noexcept { return pointer_safety::relaxed; } |
158 | |
159 | #if __cplusplus > 201703L |
160 | #define __cpp_lib_assume_aligned 201811L |
161 | /** @brief Inform the compiler that a pointer is aligned. |
162 | * |
163 | * @tparam _Align An alignment value (i.e. a power of two) |
164 | * @tparam _Tp An object type |
165 | * @param __ptr A pointer that is aligned to _Align |
166 | * |
167 | * C++20 20.10.6 [ptr.align] |
168 | * |
169 | * @ingroup memory |
170 | */ |
171 | template<size_t _Align, class _Tp> |
172 | [[nodiscard,__gnu__::__always_inline__]] |
173 | constexpr _Tp* |
174 | assume_aligned(_Tp* __ptr) noexcept |
175 | { |
176 | static_assert(std::ispow2(_Align)); |
177 | if (std::is_constant_evaluated()) |
178 | return __ptr; |
179 | else |
180 | { |
181 | // This function is expected to be used in hot code, where |
182 | // __glibcxx_assert would add unwanted overhead. |
183 | _GLIBCXX_DEBUG_ASSERT((std::uintptr_t)__ptr % _Align == 0); |
184 | return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Align)); |
185 | } |
186 | } |
187 | #endif // C++2a |
188 | |
189 | #if __cplusplus > 201703L |
190 | template<typename _Tp> |
191 | struct __is_pair : false_type { }; |
192 | template<typename _Tp, typename _Up> |
193 | struct __is_pair<pair<_Tp, _Up>> : true_type { }; |
194 | template<typename _Tp, typename _Up> |
195 | struct __is_pair<const pair<_Tp, _Up>> : true_type { }; |
196 | |
197 | template<typename _Tp, typename __ = _Require<__not_<__is_pair<_Tp>>>, |
198 | typename _Alloc, typename... _Args> |
199 | constexpr auto |
200 | __uses_alloc_args(const _Alloc& __a, _Args&&... __args) noexcept |
201 | { |
202 | if constexpr (uses_allocator_v<remove_cv_t<_Tp>, _Alloc>) |
203 | { |
204 | if constexpr (is_constructible_v<_Tp, allocator_arg_t, |
205 | const _Alloc&, _Args...>) |
206 | { |
207 | return tuple<allocator_arg_t, const _Alloc&, _Args&&...>( |
208 | allocator_arg, __a, std::forward<_Args>(__args)...); |
209 | } |
210 | else |
211 | { |
212 | static_assert(is_constructible_v<_Tp, _Args..., const _Alloc&>, |
213 | "construction with an allocator must be possible" |
214 | " if uses_allocator is true" ); |
215 | |
216 | return tuple<_Args&&..., const _Alloc&>( |
217 | std::forward<_Args>(__args)..., __a); |
218 | } |
219 | } |
220 | else |
221 | { |
222 | static_assert(is_constructible_v<_Tp, _Args...>); |
223 | |
224 | return tuple<_Args&&...>(std::forward<_Args>(__args)...); |
225 | } |
226 | } |
227 | |
228 | #if __cpp_concepts |
229 | template<typename _Tp> |
230 | concept _Std_pair = __is_pair<_Tp>::value; |
231 | #endif |
232 | |
233 | // This is a temporary workaround until -fconcepts is implied by -std=gnu++2a |
234 | #if __cpp_concepts |
235 | # define _GLIBCXX_STD_PAIR_CONSTRAINT(T) _Std_pair T |
236 | # define _GLIBCXX_STD_PAIR_CONSTRAINT_(T) _Std_pair T |
237 | #else |
238 | # define _GLIBCXX_STD_PAIR_CONSTRAINT(T) \ |
239 | typename T, typename __ = _Require<__is_pair<T>> |
240 | # define _GLIBCXX_STD_PAIR_CONSTRAINT_(T) typename T, typename |
241 | #endif |
242 | |
243 | template<typename _Tp, |
244 | #if ! __cpp_concepts |
245 | typename __ = _Require<__not_<__is_pair<_Tp>>>, |
246 | #endif |
247 | typename _Alloc, typename... _Args> |
248 | constexpr auto |
249 | uses_allocator_construction_args(const _Alloc& __a, |
250 | _Args&&... __args) noexcept |
251 | #if __cpp_concepts |
252 | requires (! _Std_pair<_Tp>) |
253 | #endif |
254 | { |
255 | return std::__uses_alloc_args<_Tp>(__a, std::forward<_Args>(__args)...); |
256 | } |
257 | |
258 | template<_GLIBCXX_STD_PAIR_CONSTRAINT(_Tp), typename _Alloc, |
259 | typename _Tuple1, typename _Tuple2> |
260 | constexpr auto |
261 | uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t, |
262 | _Tuple1&& __x, _Tuple2&& __y) noexcept; |
263 | |
264 | template<_GLIBCXX_STD_PAIR_CONSTRAINT(_Tp), typename _Alloc> |
265 | constexpr auto |
266 | uses_allocator_construction_args(const _Alloc&) noexcept; |
267 | |
268 | template<_GLIBCXX_STD_PAIR_CONSTRAINT(_Tp), typename _Alloc, |
269 | typename _Up, typename _Vp> |
270 | constexpr auto |
271 | uses_allocator_construction_args(const _Alloc&, _Up&&, _Vp&&) noexcept; |
272 | |
273 | template<_GLIBCXX_STD_PAIR_CONSTRAINT(_Tp), typename _Alloc, |
274 | typename _Up, typename _Vp> |
275 | constexpr auto |
276 | uses_allocator_construction_args(const _Alloc&, |
277 | const pair<_Up, _Vp>&) noexcept; |
278 | |
279 | template<_GLIBCXX_STD_PAIR_CONSTRAINT(_Tp), typename _Alloc, |
280 | typename _Up, typename _Vp> |
281 | constexpr auto |
282 | uses_allocator_construction_args(const _Alloc&, pair<_Up, _Vp>&&) noexcept; |
283 | |
284 | template<_GLIBCXX_STD_PAIR_CONSTRAINT_(_Tp), typename _Alloc, |
285 | typename _Tuple1, typename _Tuple2> |
286 | constexpr auto |
287 | uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t, |
288 | _Tuple1&& __x, _Tuple2&& __y) noexcept |
289 | { |
290 | using _Tp1 = typename _Tp::first_type; |
291 | using _Tp2 = typename _Tp::second_type; |
292 | |
293 | return std::make_tuple(piecewise_construct, |
294 | std::apply([&__a](auto&&... __args1) { |
295 | return std::uses_allocator_construction_args<_Tp1>( |
296 | __a, std::forward<decltype(__args1)>(__args1)...); |
297 | }, std::forward<_Tuple1>(__x)), |
298 | std::apply([&__a](auto&&... __args2) { |
299 | return std::uses_allocator_construction_args<_Tp2>( |
300 | __a, std::forward<decltype(__args2)>(__args2)...); |
301 | }, std::forward<_Tuple2>(__y))); |
302 | } |
303 | |
304 | template<_GLIBCXX_STD_PAIR_CONSTRAINT_(_Tp), typename _Alloc> |
305 | constexpr auto |
306 | uses_allocator_construction_args(const _Alloc& __a) noexcept |
307 | { |
308 | using _Tp1 = typename _Tp::first_type; |
309 | using _Tp2 = typename _Tp::second_type; |
310 | |
311 | return std::make_tuple(piecewise_construct, |
312 | std::uses_allocator_construction_args<_Tp1>(__a), |
313 | std::uses_allocator_construction_args<_Tp2>(__a)); |
314 | } |
315 | |
316 | template<_GLIBCXX_STD_PAIR_CONSTRAINT_(_Tp), typename _Alloc, |
317 | typename _Up, typename _Vp> |
318 | constexpr auto |
319 | uses_allocator_construction_args(const _Alloc& __a, _Up&& __u, _Vp&& __v) |
320 | noexcept |
321 | { |
322 | using _Tp1 = typename _Tp::first_type; |
323 | using _Tp2 = typename _Tp::second_type; |
324 | |
325 | return std::make_tuple(piecewise_construct, |
326 | std::uses_allocator_construction_args<_Tp1>(__a, |
327 | std::forward<_Up>(__u)), |
328 | std::uses_allocator_construction_args<_Tp2>(__a, |
329 | std::forward<_Vp>(__v))); |
330 | } |
331 | |
332 | template<_GLIBCXX_STD_PAIR_CONSTRAINT_(_Tp), typename _Alloc, |
333 | typename _Up, typename _Vp> |
334 | constexpr auto |
335 | uses_allocator_construction_args(const _Alloc& __a, |
336 | const pair<_Up, _Vp>& __pr) noexcept |
337 | { |
338 | using _Tp1 = typename _Tp::first_type; |
339 | using _Tp2 = typename _Tp::second_type; |
340 | |
341 | return std::make_tuple(piecewise_construct, |
342 | std::uses_allocator_construction_args<_Tp1>(__a, __pr.first), |
343 | std::uses_allocator_construction_args<_Tp2>(__a, __pr.second)); |
344 | } |
345 | |
346 | template<_GLIBCXX_STD_PAIR_CONSTRAINT_(_Tp), typename _Alloc, |
347 | typename _Up, typename _Vp> |
348 | constexpr auto |
349 | uses_allocator_construction_args(const _Alloc& __a, |
350 | pair<_Up, _Vp>&& __pr) noexcept |
351 | { |
352 | using _Tp1 = typename _Tp::first_type; |
353 | using _Tp2 = typename _Tp::second_type; |
354 | |
355 | return std::make_tuple(piecewise_construct, |
356 | std::uses_allocator_construction_args<_Tp1>(__a, |
357 | std::move(__pr).first), |
358 | std::uses_allocator_construction_args<_Tp2>(__a, |
359 | std::move(__pr).second)); |
360 | } |
361 | |
362 | template<typename _Tp, typename _Alloc, typename... _Args> |
363 | inline _Tp |
364 | make_obj_using_allocator(const _Alloc& __a, _Args&&... __args) |
365 | { |
366 | return std::make_from_tuple<_Tp>( |
367 | std::uses_allocator_construction_args<_Tp>(__a, |
368 | std::forward<_Args>(__args)...)); |
369 | } |
370 | |
371 | template<typename _Tp, typename _Alloc, typename... _Args> |
372 | inline _Tp* |
373 | uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __a, |
374 | _Args&&... __args) |
375 | { |
376 | void* __vp = const_cast<void*>(static_cast<const volatile void*>(__p)); |
377 | return ::new(__vp) _Tp(std::make_obj_using_allocator<_Tp>(__a, |
378 | std::forward<_Args>(__args)...)); |
379 | } |
380 | |
381 | #endif // C++2a |
382 | |
383 | _GLIBCXX_END_NAMESPACE_VERSION |
384 | } // namespace |
385 | #endif // C++11 |
386 | |
387 | #if __cplusplus > 201402L |
388 | // Parallel STL algorithms |
389 | # if __PSTL_EXECUTION_POLICIES_DEFINED |
390 | // If <execution> has already been included, pull in implementations |
391 | # include <pstl/glue_memory_impl.h> |
392 | # else |
393 | // Otherwise just pull in forward declarations |
394 | # include <pstl/glue_memory_defs.h> |
395 | # endif |
396 | |
397 | // Feature test macro for parallel algorithms |
398 | # define __cpp_lib_parallel_algorithm 201603L |
399 | #endif // C++17 |
400 | |
401 | #endif /* _GLIBCXX_MEMORY */ |
402 | |