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)) == 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*
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*
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 = 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
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 
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*
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*
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 = 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
252 operator delete(void* ptr, std::align_val_t) noexcept
253 {
254     std::__libcpp_aligned_free(ptr);
255 }
256 
257 _LIBCPP_WEAK
258 void
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
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
273 operator delete[] (void* ptr, std::align_val_t alignment) noexcept
274 {
275     ::operator delete(ptr, alignment);
276 }
277 
278 _LIBCPP_WEAK
279 void
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
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