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