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)) == 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*
operator new(size_t size,const std::nothrow_t &)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*
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 = 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
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 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*
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 = 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*
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 = 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
operator delete(void * ptr,std::align_val_t)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
operator delete(void * ptr,std::align_val_t alignment,const std::nothrow_t &)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
operator delete(void * ptr,size_t,std::align_val_t alignment)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
operator delete[](void * ptr,std::align_val_t alignment)277 operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
278 {
279 ::operator delete(ptr, alignment);
280 }
281
282 _LIBCPP_WEAK
283 void
operator delete[](void * ptr,std::align_val_t alignment,const std::nothrow_t &)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
operator delete[](void * ptr,size_t,std::align_val_t alignment)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