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
__throw_bad_alloc()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 *
operator new(std::size_t size)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)) == nullptr)
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*
operator new(size_t size,const std::nothrow_t &)86 operator new(size_t size, const std::nothrow_t&) noexcept
87 {
88 void* p = nullptr;
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*
operator new[](size_t size)105 operator new[](size_t size) _THROW_BAD_ALLOC
106 {
107 return ::operator new(size);
108 }
109
110 _LIBCPP_WEAK
111 void*
operator new[](size_t size,const std::nothrow_t &)112 operator new[](size_t size, const std::nothrow_t&) noexcept
113 {
114 void* p = nullptr;
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
operator delete(void * ptr)131 operator delete(void* ptr) noexcept
132 {
133 ::free(ptr);
134 }
135
136 _LIBCPP_WEAK
137 void
operator delete(void * ptr,const std::nothrow_t &)138 operator delete(void* ptr, const std::nothrow_t&) noexcept
139 {
140 ::operator delete(ptr);
141 }
142
143 _LIBCPP_WEAK
144 void
operator delete(void * ptr,size_t)145 operator delete(void* ptr, size_t) noexcept
146 {
147 ::operator delete(ptr);
148 }
149
150 _LIBCPP_WEAK
151 void
operator delete[](void * ptr)152 operator delete[] (void* ptr) noexcept
153 {
154 ::operator delete(ptr);
155 }
156
157 _LIBCPP_WEAK
158 void
operator delete[](void * ptr,const std::nothrow_t &)159 operator delete[] (void* ptr, const std::nothrow_t&) noexcept
160 {
161 ::operator delete[](ptr);
162 }
163
164 _LIBCPP_WEAK
165 void
operator delete[](void * ptr,size_t)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 *
operator new(std::size_t size,std::align_val_t alignment)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
182 // Try allocating memory. If allocation fails and there is a new_handler,
183 // call it to try free up memory, and try again until it succeeds, or until
184 // the new_handler decides to terminate.
185 //
186 // If allocation fails and there is no new_handler, we throw bad_alloc
187 // (or return nullptr if exceptions are disabled).
188 void* p;
189 while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr)
190 {
191 std::new_handler nh = std::get_new_handler();
192 if (nh)
193 nh();
194 else {
195 #ifndef _LIBCPP_NO_EXCEPTIONS
196 throw std::bad_alloc();
197 #else
198 break;
199 #endif
200 }
201 }
202 return p;
203 }
204
205 _LIBCPP_WEAK
206 void*
operator new(size_t size,std::align_val_t alignment,const std::nothrow_t &)207 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
208 {
209 void* p = nullptr;
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*
operator new[](size_t size,std::align_val_t alignment)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*
operator new[](size_t size,std::align_val_t alignment,const std::nothrow_t &)233 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
234 {
235 void* p = nullptr;
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
operator delete(void * ptr,std::align_val_t)252 operator delete(void* ptr, std::align_val_t) noexcept
253 {
254 std::__libcpp_aligned_free(ptr);
255 }
256
257 _LIBCPP_WEAK
258 void
operator delete(void * ptr,std::align_val_t alignment,const std::nothrow_t &)259 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
260 {
261 ::operator delete(ptr, alignment);
262 }
263
264 _LIBCPP_WEAK
265 void
operator delete(void * ptr,size_t,std::align_val_t alignment)266 operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
267 {
268 ::operator delete(ptr, alignment);
269 }
270
271 _LIBCPP_WEAK
272 void
operator delete[](void * ptr,std::align_val_t alignment)273 operator delete[] (void* ptr, std::align_val_t alignment) noexcept
274 {
275 ::operator delete(ptr, alignment);
276 }
277
278 _LIBCPP_WEAK
279 void
operator delete[](void * ptr,std::align_val_t alignment,const std::nothrow_t &)280 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
281 {
282 ::operator delete[](ptr, alignment);
283 }
284
285 _LIBCPP_WEAK
286 void
operator delete[](void * ptr,size_t,std::align_val_t alignment)287 operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
288 {
289 ::operator delete[](ptr, alignment);
290 }
291
292 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
293 #endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS
294