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