1 | //===--------------------------- new.cpp ----------------------------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include <stdlib.h> |
10 | |
11 | #include "new" |
12 | #include "include/atomic_support.h" |
13 | |
14 | #if defined(_LIBCPP_ABI_MICROSOFT) |
15 | # if !defined(_LIBCPP_ABI_VCRUNTIME) |
16 | # include "support/runtime/new_handler_fallback.ipp" |
17 | # endif |
18 | #elif defined(LIBCXX_BUILDING_LIBCXXABI) |
19 | # include <cxxabi.h> |
20 | #elif defined(LIBCXXRT) |
21 | # include <cxxabi.h> |
22 | # include "support/runtime/new_handler_fallback.ipp" |
23 | #elif defined(__GLIBCXX__) |
24 | // nothing to do |
25 | #else |
26 | # include "support/runtime/new_handler_fallback.ipp" |
27 | #endif |
28 | |
29 | namespace std |
30 | { |
31 | |
32 | #ifndef __GLIBCXX__ |
33 | const nothrow_t nothrow{}; |
34 | #endif |
35 | |
36 | #ifndef LIBSTDCXX |
37 | |
38 | void |
39 | __throw_bad_alloc() |
40 | { |
41 | #ifndef _LIBCPP_NO_EXCEPTIONS |
42 | throw bad_alloc(); |
43 | #else |
44 | _VSTD::abort(); |
45 | #endif |
46 | } |
47 | |
48 | #endif // !LIBSTDCXX |
49 | |
50 | } // std |
51 | |
52 | #if !defined(__GLIBCXX__) && \ |
53 | !defined(_LIBCPP_ABI_VCRUNTIME) && \ |
54 | !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS) |
55 | |
56 | // Implement all new and delete operators as weak definitions |
57 | // in this shared library, so that they can be overridden by programs |
58 | // that define non-weak copies of the functions. |
59 | |
60 | _LIBCPP_WEAK |
61 | void * |
62 | operator new(std::size_t size) _THROW_BAD_ALLOC |
63 | { |
64 | if (size == 0) |
65 | size = 1; |
66 | void* p; |
67 | while ((p = ::malloc(size)) == 0) |
68 | { |
69 | // If malloc fails and there is a new_handler, |
70 | // call it to try free up memory. |
71 | std::new_handler nh = std::get_new_handler(); |
72 | if (nh) |
73 | nh(); |
74 | else |
75 | #ifndef _LIBCPP_NO_EXCEPTIONS |
76 | throw std::bad_alloc(); |
77 | #else |
78 | break; |
79 | #endif |
80 | } |
81 | return p; |
82 | } |
83 | |
84 | _LIBCPP_WEAK |
85 | void* |
86 | operator new(size_t size, const std::nothrow_t&) _NOEXCEPT |
87 | { |
88 | void* p = 0; |
89 | #ifndef _LIBCPP_NO_EXCEPTIONS |
90 | try |
91 | { |
92 | #endif // _LIBCPP_NO_EXCEPTIONS |
93 | p = ::operator new(size); |
94 | #ifndef _LIBCPP_NO_EXCEPTIONS |
95 | } |
96 | catch (...) |
97 | { |
98 | } |
99 | #endif // _LIBCPP_NO_EXCEPTIONS |
100 | return p; |
101 | } |
102 | |
103 | _LIBCPP_WEAK |
104 | void* |
105 | operator new[](size_t size) _THROW_BAD_ALLOC |
106 | { |
107 | return ::operator new(size); |
108 | } |
109 | |
110 | _LIBCPP_WEAK |
111 | void* |
112 | operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT |
113 | { |
114 | void* p = 0; |
115 | #ifndef _LIBCPP_NO_EXCEPTIONS |
116 | try |
117 | { |
118 | #endif // _LIBCPP_NO_EXCEPTIONS |
119 | p = ::operator new[](size); |
120 | #ifndef _LIBCPP_NO_EXCEPTIONS |
121 | } |
122 | catch (...) |
123 | { |
124 | } |
125 | #endif // _LIBCPP_NO_EXCEPTIONS |
126 | return p; |
127 | } |
128 | |
129 | _LIBCPP_WEAK |
130 | void |
131 | operator delete(void* ptr) _NOEXCEPT |
132 | { |
133 | ::free(ptr); |
134 | } |
135 | |
136 | _LIBCPP_WEAK |
137 | void |
138 | operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT |
139 | { |
140 | ::operator delete(ptr); |
141 | } |
142 | |
143 | _LIBCPP_WEAK |
144 | void |
145 | operator delete(void* ptr, size_t) _NOEXCEPT |
146 | { |
147 | ::operator delete(ptr); |
148 | } |
149 | |
150 | _LIBCPP_WEAK |
151 | void |
152 | operator delete[] (void* ptr) _NOEXCEPT |
153 | { |
154 | ::operator delete(ptr); |
155 | } |
156 | |
157 | _LIBCPP_WEAK |
158 | void |
159 | operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT |
160 | { |
161 | ::operator delete[](ptr); |
162 | } |
163 | |
164 | _LIBCPP_WEAK |
165 | void |
166 | operator delete[] (void* ptr, size_t) _NOEXCEPT |
167 | { |
168 | ::operator delete[](ptr); |
169 | } |
170 | |
171 | #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) |
172 | |
173 | _LIBCPP_WEAK |
174 | void * |
175 | operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC |
176 | { |
177 | if (size == 0) |
178 | size = 1; |
179 | if (static_cast<size_t>(alignment) < sizeof(void*)) |
180 | alignment = std::align_val_t(sizeof(void*)); |
181 | void* p; |
182 | #if defined(_LIBCPP_MSVCRT_LIKE) |
183 | while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr) |
184 | #else |
185 | while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0) |
186 | #endif |
187 | { |
188 | // If posix_memalign fails and there is a new_handler, |
189 | // call it to try free up memory. |
190 | std::new_handler nh = std::get_new_handler(); |
191 | if (nh) |
192 | nh(); |
193 | else { |
194 | #ifndef _LIBCPP_NO_EXCEPTIONS |
195 | throw std::bad_alloc(); |
196 | #else |
197 | p = nullptr; // posix_memalign doesn't initialize 'p' on failure |
198 | break; |
199 | #endif |
200 | } |
201 | } |
202 | return p; |
203 | } |
204 | |
205 | _LIBCPP_WEAK |
206 | void* |
207 | operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT |
208 | { |
209 | void* p = 0; |
210 | #ifndef _LIBCPP_NO_EXCEPTIONS |
211 | try |
212 | { |
213 | #endif // _LIBCPP_NO_EXCEPTIONS |
214 | p = ::operator new(size, alignment); |
215 | #ifndef _LIBCPP_NO_EXCEPTIONS |
216 | } |
217 | catch (...) |
218 | { |
219 | } |
220 | #endif // _LIBCPP_NO_EXCEPTIONS |
221 | return p; |
222 | } |
223 | |
224 | _LIBCPP_WEAK |
225 | void* |
226 | operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC |
227 | { |
228 | return ::operator new(size, alignment); |
229 | } |
230 | |
231 | _LIBCPP_WEAK |
232 | void* |
233 | operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT |
234 | { |
235 | void* p = 0; |
236 | #ifndef _LIBCPP_NO_EXCEPTIONS |
237 | try |
238 | { |
239 | #endif // _LIBCPP_NO_EXCEPTIONS |
240 | p = ::operator new[](size, alignment); |
241 | #ifndef _LIBCPP_NO_EXCEPTIONS |
242 | } |
243 | catch (...) |
244 | { |
245 | } |
246 | #endif // _LIBCPP_NO_EXCEPTIONS |
247 | return p; |
248 | } |
249 | |
250 | _LIBCPP_WEAK |
251 | void |
252 | operator delete(void* ptr, std::align_val_t) _NOEXCEPT |
253 | { |
254 | #if defined(_LIBCPP_MSVCRT_LIKE) |
255 | ::_aligned_free(ptr); |
256 | #else |
257 | ::free(ptr); |
258 | #endif |
259 | } |
260 | |
261 | _LIBCPP_WEAK |
262 | void |
263 | operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT |
264 | { |
265 | ::operator delete(ptr, alignment); |
266 | } |
267 | |
268 | _LIBCPP_WEAK |
269 | void |
270 | operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT |
271 | { |
272 | ::operator delete(ptr, alignment); |
273 | } |
274 | |
275 | _LIBCPP_WEAK |
276 | void |
277 | operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT |
278 | { |
279 | ::operator delete(ptr, alignment); |
280 | } |
281 | |
282 | _LIBCPP_WEAK |
283 | void |
284 | operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT |
285 | { |
286 | ::operator delete[](ptr, alignment); |
287 | } |
288 | |
289 | _LIBCPP_WEAK |
290 | void |
291 | operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT |
292 | { |
293 | ::operator delete[](ptr, alignment); |
294 | } |
295 | |
296 | #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION |
297 | #endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS |
298 | |