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 #ifndef __has_include
17 #define __has_include(inc) 0
18 #endif
19
20 #if defined(__APPLE__) && !defined(LIBCXXRT)
21 #include <cxxabi.h>
22
23 #ifndef _LIBCPPABI_VERSION
24 // On Darwin, there are two STL shared libraries and a lower level ABI
25 // shared library. The global holding the current new handler is
26 // in the ABI library and named __cxa_new_handler.
27 #define __new_handler __cxxabiapple::__cxa_new_handler
28 #endif
29 #else // __APPLE__
30 #if defined(LIBCXXRT) || __has_include(<cxxabi.h>)
31 #include <cxxabi.h>
32 #endif // __has_include(<cxxabi.h>)
33 #if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
34 static std::new_handler __new_handler;
35 #endif // _LIBCPPABI_VERSION
36 #endif
37
38 #ifndef __GLIBCXX__
39
40 // Implement all new and delete operators as weak definitions
41 // in this shared library, so that they can be overridden by programs
42 // that define non-weak copies of the functions.
43
44 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
45 void *
operator new(std::size_t size)46 operator new(std::size_t size)
47 #if !__has_feature(cxx_noexcept)
48 throw(std::bad_alloc)
49 #endif
50 {
51 if (size == 0)
52 size = 1;
53 void* p;
54 while ((p = ::malloc(size)) == 0)
55 {
56 // If malloc fails and there is a new_handler,
57 // call it to try free up memory.
58 std::new_handler nh = std::get_new_handler();
59 if (nh)
60 nh();
61 else
62 #ifndef _LIBCPP_NO_EXCEPTIONS
63 throw std::bad_alloc();
64 #else
65 break;
66 #endif
67 }
68 return p;
69 }
70
71 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
72 void*
operator new(size_t size,const std::nothrow_t &)73 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
74 {
75 void* p = 0;
76 #ifndef _LIBCPP_NO_EXCEPTIONS
77 try
78 {
79 #endif // _LIBCPP_NO_EXCEPTIONS
80 p = ::operator new(size);
81 #ifndef _LIBCPP_NO_EXCEPTIONS
82 }
83 catch (...)
84 {
85 }
86 #endif // _LIBCPP_NO_EXCEPTIONS
87 return p;
88 }
89
90 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
91 void*
operator new[](size_t size)92 operator new[](size_t size)
93 #if !__has_feature(cxx_noexcept)
94 throw(std::bad_alloc)
95 #endif
96 {
97 return ::operator new(size);
98 }
99
100 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
101 void*
operator new[](size_t size,const std::nothrow_t &)102 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
103 {
104 void* p = 0;
105 #ifndef _LIBCPP_NO_EXCEPTIONS
106 try
107 {
108 #endif // _LIBCPP_NO_EXCEPTIONS
109 p = ::operator new[](size);
110 #ifndef _LIBCPP_NO_EXCEPTIONS
111 }
112 catch (...)
113 {
114 }
115 #endif // _LIBCPP_NO_EXCEPTIONS
116 return p;
117 }
118
119 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
120 void
operator delete(void * ptr)121 operator delete(void* ptr) _NOEXCEPT
122 {
123 if (ptr)
124 ::free(ptr);
125 }
126
127 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
128 void
operator delete(void * ptr,const std::nothrow_t &)129 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
130 {
131 ::operator delete(ptr);
132 }
133
134 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
135 void
operator delete(void * ptr,size_t)136 operator delete(void* ptr, size_t) _NOEXCEPT
137 {
138 ::operator delete(ptr);
139 }
140
141 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
142 void
operator delete[](void * ptr)143 operator delete[] (void* ptr) _NOEXCEPT
144 {
145 ::operator delete(ptr);
146 }
147
148 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
149 void
operator delete[](void * ptr,const std::nothrow_t &)150 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
151 {
152 ::operator delete[](ptr);
153 }
154
155 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
156 void
operator delete[](void * ptr,size_t)157 operator delete[] (void* ptr, size_t) _NOEXCEPT
158 {
159 ::operator delete[](ptr);
160 }
161
162 #endif // !__GLIBCXX__
163
164 namespace std
165 {
166
167 #ifndef __GLIBCXX__
168 const nothrow_t nothrow = {};
169 #endif
170
171 #ifndef _LIBCPPABI_VERSION
172
173 #ifndef __GLIBCXX__
174
175 new_handler
set_new_handler(new_handler handler)176 set_new_handler(new_handler handler) _NOEXCEPT
177 {
178 return __sync_lock_test_and_set(&__new_handler, handler);
179 }
180
181 new_handler
get_new_handler()182 get_new_handler() _NOEXCEPT
183 {
184 return __sync_fetch_and_add(&__new_handler, nullptr);
185 }
186
187 #endif // !__GLIBCXX__
188
189 #ifndef LIBCXXRT
190
bad_alloc()191 bad_alloc::bad_alloc() _NOEXCEPT
192 {
193 }
194
195 #ifndef __GLIBCXX__
196
~bad_alloc()197 bad_alloc::~bad_alloc() _NOEXCEPT
198 {
199 }
200
201 const char*
what() const202 bad_alloc::what() const _NOEXCEPT
203 {
204 return "std::bad_alloc";
205 }
206
207 #endif // !__GLIBCXX__
208
bad_array_new_length()209 bad_array_new_length::bad_array_new_length() _NOEXCEPT
210 {
211 }
212
~bad_array_new_length()213 bad_array_new_length::~bad_array_new_length() _NOEXCEPT
214 {
215 }
216
217 const char*
what() const218 bad_array_new_length::what() const _NOEXCEPT
219 {
220 return "bad_array_new_length";
221 }
222
223 #endif //LIBCXXRT
224
225 const char*
what() const226 bad_array_length::what() const _NOEXCEPT
227 {
228 return "bad_array_length";
229 }
230
bad_array_length()231 bad_array_length::bad_array_length() _NOEXCEPT
232 {
233 }
234
~bad_array_length()235 bad_array_length::~bad_array_length() _NOEXCEPT
236 {
237 }
238
239 #endif // _LIBCPPABI_VERSION
240
241 #ifndef LIBSTDCXX
242
243 void
__throw_bad_alloc()244 __throw_bad_alloc()
245 {
246 #ifndef _LIBCPP_NO_EXCEPTIONS
247 throw bad_alloc();
248 #endif
249 }
250
251 #endif // !LIBSTDCXX
252
253 } // std
254