1 //===----------------------------------------------------------------------===//
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 // This file implements the new and delete operators.
9 //===----------------------------------------------------------------------===//
10 
11 #include "__cxxabi_config.h"
12 #include <new>
13 #include <cstdlib>
14 
15 #if !defined(_THROW_BAD_ALLOC) || !defined(_LIBCXXABI_WEAK)
16 #error The _THROW_BAD_ALLOC and _LIBCXXABI_WEAK libc++ macros must \
17        already be defined by libc++.
18 #endif
19 // Implement all new and delete operators as weak definitions
20 // in this shared library, so that they can be overridden by programs
21 // that define non-weak copies of the functions.
22 
23 _LIBCXXABI_WEAK
24 void *
25 operator new(std::size_t size) _THROW_BAD_ALLOC
26 {
27     if (size == 0)
28         size = 1;
29     void* p;
30     while ((p = ::malloc(size)) == nullptr)
31     {
32         // If malloc fails and there is a new_handler,
33         // call it to try free up memory.
34         std::new_handler nh = std::get_new_handler();
35         if (nh)
36             nh();
37         else
38 #ifndef _LIBCXXABI_NO_EXCEPTIONS
39             throw std::bad_alloc();
40 #else
41             break;
42 #endif
43     }
44     return p;
45 }
46 
47 _LIBCXXABI_WEAK
48 void*
49 operator new(size_t size, const std::nothrow_t&) noexcept
50 {
51     void* p = nullptr;
52 #ifndef _LIBCXXABI_NO_EXCEPTIONS
53     try
54     {
55 #endif // _LIBCXXABI_NO_EXCEPTIONS
56         p = ::operator new(size);
57 #ifndef _LIBCXXABI_NO_EXCEPTIONS
58     }
59     catch (...)
60     {
61     }
62 #endif // _LIBCXXABI_NO_EXCEPTIONS
63     return p;
64 }
65 
66 _LIBCXXABI_WEAK
67 void*
68 operator new[](size_t size) _THROW_BAD_ALLOC
69 {
70     return ::operator new(size);
71 }
72 
73 _LIBCXXABI_WEAK
74 void*
75 operator new[](size_t size, const std::nothrow_t&) noexcept
76 {
77     void* p = nullptr;
78 #ifndef _LIBCXXABI_NO_EXCEPTIONS
79     try
80     {
81 #endif // _LIBCXXABI_NO_EXCEPTIONS
82         p = ::operator new[](size);
83 #ifndef _LIBCXXABI_NO_EXCEPTIONS
84     }
85     catch (...)
86     {
87     }
88 #endif // _LIBCXXABI_NO_EXCEPTIONS
89     return p;
90 }
91 
92 _LIBCXXABI_WEAK
93 void
94 operator delete(void* ptr) noexcept
95 {
96     ::free(ptr);
97 }
98 
99 _LIBCXXABI_WEAK
100 void
101 operator delete(void* ptr, const std::nothrow_t&) noexcept
102 {
103     ::operator delete(ptr);
104 }
105 
106 _LIBCXXABI_WEAK
107 void
108 operator delete(void* ptr, size_t) noexcept
109 {
110     ::operator delete(ptr);
111 }
112 
113 _LIBCXXABI_WEAK
114 void
115 operator delete[] (void* ptr) noexcept
116 {
117     ::operator delete(ptr);
118 }
119 
120 _LIBCXXABI_WEAK
121 void
122 operator delete[] (void* ptr, const std::nothrow_t&) noexcept
123 {
124     ::operator delete[](ptr);
125 }
126 
127 _LIBCXXABI_WEAK
128 void
129 operator delete[] (void* ptr, size_t) noexcept
130 {
131     ::operator delete[](ptr);
132 }
133 
134 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
135 
136 _LIBCXXABI_WEAK
137 void *
138 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
139 {
140     if (size == 0)
141         size = 1;
142     if (static_cast<size_t>(alignment) < sizeof(void*))
143       alignment = std::align_val_t(sizeof(void*));
144 
145     // Try allocating memory. If allocation fails and there is a new_handler,
146     // call it to try free up memory, and try again until it succeeds, or until
147     // the new_handler decides to terminate.
148     //
149     // If allocation fails and there is no new_handler, we throw bad_alloc
150     // (or return nullptr if exceptions are disabled).
151     void* p;
152     while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr)
153     {
154         std::new_handler nh = std::get_new_handler();
155         if (nh)
156             nh();
157         else {
158 #ifndef _LIBCXXABI_NO_EXCEPTIONS
159             throw std::bad_alloc();
160 #else
161             break;
162 #endif
163         }
164     }
165     return p;
166 }
167 
168 _LIBCXXABI_WEAK
169 void*
170 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
171 {
172     void* p = nullptr;
173 #ifndef _LIBCXXABI_NO_EXCEPTIONS
174     try
175     {
176 #endif // _LIBCXXABI_NO_EXCEPTIONS
177         p = ::operator new(size, alignment);
178 #ifndef _LIBCXXABI_NO_EXCEPTIONS
179     }
180     catch (...)
181     {
182     }
183 #endif // _LIBCXXABI_NO_EXCEPTIONS
184     return p;
185 }
186 
187 _LIBCXXABI_WEAK
188 void*
189 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
190 {
191     return ::operator new(size, alignment);
192 }
193 
194 _LIBCXXABI_WEAK
195 void*
196 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
197 {
198     void* p = nullptr;
199 #ifndef _LIBCXXABI_NO_EXCEPTIONS
200     try
201     {
202 #endif // _LIBCXXABI_NO_EXCEPTIONS
203         p = ::operator new[](size, alignment);
204 #ifndef _LIBCXXABI_NO_EXCEPTIONS
205     }
206     catch (...)
207     {
208     }
209 #endif // _LIBCXXABI_NO_EXCEPTIONS
210     return p;
211 }
212 
213 _LIBCXXABI_WEAK
214 void
215 operator delete(void* ptr, std::align_val_t) noexcept
216 {
217     std::__libcpp_aligned_free(ptr);
218 }
219 
220 _LIBCXXABI_WEAK
221 void
222 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
223 {
224     ::operator delete(ptr, alignment);
225 }
226 
227 _LIBCXXABI_WEAK
228 void
229 operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
230 {
231     ::operator delete(ptr, alignment);
232 }
233 
234 _LIBCXXABI_WEAK
235 void
236 operator delete[] (void* ptr, std::align_val_t alignment) noexcept
237 {
238     ::operator delete(ptr, alignment);
239 }
240 
241 _LIBCXXABI_WEAK
242 void
243 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
244 {
245     ::operator delete[](ptr, alignment);
246 }
247 
248 _LIBCXXABI_WEAK
249 void
250 operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
251 {
252     ::operator delete[](ptr, alignment);
253 }
254 
255 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
256