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 overriden by programs 42 // that define non-weak copies of the functions. 43 44 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 45 void * 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* 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* 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* 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 121 operator delete(void* ptr) _NOEXCEPT 122 { 123 if (ptr) 124 ::free(ptr); 125 } 126 127 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 128 void 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 136 operator delete(void* ptr, size_t) _NOEXCEPT 137 { 138 ::operator delete(ptr); 139 } 140 141 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 142 void 143 operator delete(void* ptr, size_t, const std::nothrow_t& nt) _NOEXCEPT 144 { 145 ::operator delete(ptr, nt); 146 } 147 148 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 149 void 150 operator delete[] (void* ptr) _NOEXCEPT 151 { 152 ::operator delete(ptr); 153 } 154 155 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 156 void 157 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT 158 { 159 ::operator delete[](ptr); 160 } 161 162 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 163 void 164 operator delete[] (void* ptr, size_t) _NOEXCEPT 165 { 166 ::operator delete[](ptr); 167 } 168 169 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 170 void 171 operator delete[] (void* ptr, size_t, const std::nothrow_t& nt) _NOEXCEPT 172 { 173 ::operator delete[](ptr, nt); 174 } 175 176 #endif // !__GLIBCXX__ 177 178 namespace std 179 { 180 181 #ifndef __GLIBCXX__ 182 const nothrow_t nothrow = {}; 183 #endif 184 185 #ifndef _LIBCPPABI_VERSION 186 187 #ifndef __GLIBCXX__ 188 189 new_handler 190 set_new_handler(new_handler handler) _NOEXCEPT 191 { 192 return __sync_lock_test_and_set(&__new_handler, handler); 193 } 194 195 new_handler 196 get_new_handler() _NOEXCEPT 197 { 198 return __sync_fetch_and_add(&__new_handler, nullptr); 199 } 200 201 #endif // !__GLIBCXX__ 202 203 #ifndef LIBCXXRT 204 205 bad_alloc::bad_alloc() _NOEXCEPT 206 { 207 } 208 209 #ifndef __GLIBCXX__ 210 211 bad_alloc::~bad_alloc() _NOEXCEPT 212 { 213 } 214 215 const char* 216 bad_alloc::what() const _NOEXCEPT 217 { 218 return "std::bad_alloc"; 219 } 220 221 #endif // !__GLIBCXX__ 222 223 bad_array_new_length::bad_array_new_length() _NOEXCEPT 224 { 225 } 226 227 bad_array_new_length::~bad_array_new_length() _NOEXCEPT 228 { 229 } 230 231 const char* 232 bad_array_new_length::what() const _NOEXCEPT 233 { 234 return "bad_array_new_length"; 235 } 236 237 #endif //LIBCXXRT 238 239 const char* 240 bad_array_length::what() const _NOEXCEPT 241 { 242 return "bad_array_length"; 243 } 244 245 bad_array_length::bad_array_length() _NOEXCEPT 246 { 247 } 248 249 bad_array_length::~bad_array_length() _NOEXCEPT 250 { 251 } 252 253 #endif // _LIBCPPABI_VERSION 254 255 #ifndef LIBSTDCXX 256 257 void 258 __throw_bad_alloc() 259 { 260 #ifndef _LIBCPP_NO_EXCEPTIONS 261 throw bad_alloc(); 262 #endif 263 } 264 265 #endif // !LIBSTDCXX 266 267 } // std 268