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(__APPLE__) && !defined(LIBCXXRT) && \ 17 !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) 18 #include <cxxabi.h> 19 20 #ifndef _LIBCPPABI_VERSION 21 // On Darwin, there are two STL shared libraries and a lower level ABI 22 // shared library. The global holding the current new handler is 23 // in the ABI library and named __cxa_new_handler. 24 #define __new_handler __cxxabiapple::__cxa_new_handler 25 #endif 26 #else // __APPLE__ 27 #if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI) 28 #include <cxxabi.h> 29 #endif // defined(LIBCXX_BUILDING_LIBCXXABI) 30 #if defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) || \ 31 (!defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)) 32 static std::new_handler __new_handler; 33 #endif // _LIBCPPABI_VERSION 34 #endif 35 36 #ifndef __GLIBCXX__ 37 38 // Implement all new and delete operators as weak definitions 39 // in this shared library, so that they can be overridden by programs 40 // that define non-weak copies of the functions. 41 42 _LIBCPP_WEAK 43 void * 44 operator new(std::size_t size) _THROW_BAD_ALLOC 45 { 46 if (size == 0) 47 size = 1; 48 void* p; 49 while ((p = ::malloc(size)) == 0) 50 { 51 // If malloc fails and there is a new_handler, 52 // call it to try free up memory. 53 std::new_handler nh = std::get_new_handler(); 54 if (nh) 55 nh(); 56 else 57 #ifndef _LIBCPP_NO_EXCEPTIONS 58 throw std::bad_alloc(); 59 #else 60 break; 61 #endif 62 } 63 return p; 64 } 65 66 _LIBCPP_WEAK 67 void * 68 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 69 { 70 if (size == 0) 71 size = 1; 72 if (static_cast<size_t>(alignment) < sizeof(void*)) 73 alignment = std::align_val_t(sizeof(void*)); 74 void* p; 75 #if defined(_LIBCPP_MSVCRT) 76 while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr) 77 #else 78 while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0) 79 #endif 80 { 81 // If posix_memalign fails and there is a new_handler, 82 // call it to try free up memory. 83 std::new_handler nh = std::get_new_handler(); 84 if (nh) 85 nh(); 86 else { 87 #ifndef _LIBCPP_NO_EXCEPTIONS 88 throw std::bad_alloc(); 89 #else 90 p = nullptr; // posix_memalign doesn't initialize 'p' on failure 91 break; 92 #endif 93 } 94 } 95 return p; 96 } 97 98 _LIBCPP_WEAK 99 void* 100 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT 101 { 102 void* p = 0; 103 #ifndef _LIBCPP_NO_EXCEPTIONS 104 try 105 { 106 #endif // _LIBCPP_NO_EXCEPTIONS 107 p = ::operator new(size); 108 #ifndef _LIBCPP_NO_EXCEPTIONS 109 } 110 catch (...) 111 { 112 } 113 #endif // _LIBCPP_NO_EXCEPTIONS 114 return p; 115 } 116 117 _LIBCPP_WEAK 118 void* 119 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 120 { 121 void* p = 0; 122 #ifndef _LIBCPP_NO_EXCEPTIONS 123 try 124 { 125 #endif // _LIBCPP_NO_EXCEPTIONS 126 p = ::operator new(size, alignment); 127 #ifndef _LIBCPP_NO_EXCEPTIONS 128 } 129 catch (...) 130 { 131 } 132 #endif // _LIBCPP_NO_EXCEPTIONS 133 return p; 134 } 135 136 _LIBCPP_WEAK 137 void* 138 operator new[](size_t size) _THROW_BAD_ALLOC 139 { 140 return ::operator new(size); 141 } 142 143 _LIBCPP_WEAK 144 void* 145 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 146 { 147 return ::operator new(size, alignment); 148 } 149 150 _LIBCPP_WEAK 151 void* 152 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT 153 { 154 void* p = 0; 155 #ifndef _LIBCPP_NO_EXCEPTIONS 156 try 157 { 158 #endif // _LIBCPP_NO_EXCEPTIONS 159 p = ::operator new[](size); 160 #ifndef _LIBCPP_NO_EXCEPTIONS 161 } 162 catch (...) 163 { 164 } 165 #endif // _LIBCPP_NO_EXCEPTIONS 166 return p; 167 } 168 169 _LIBCPP_WEAK 170 void* 171 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 172 { 173 void* p = 0; 174 #ifndef _LIBCPP_NO_EXCEPTIONS 175 try 176 { 177 #endif // _LIBCPP_NO_EXCEPTIONS 178 p = ::operator new[](size, alignment); 179 #ifndef _LIBCPP_NO_EXCEPTIONS 180 } 181 catch (...) 182 { 183 } 184 #endif // _LIBCPP_NO_EXCEPTIONS 185 return p; 186 } 187 188 _LIBCPP_WEAK 189 void 190 operator delete(void* ptr) _NOEXCEPT 191 { 192 if (ptr) 193 ::free(ptr); 194 } 195 196 _LIBCPP_WEAK 197 void 198 operator delete(void* ptr, std::align_val_t) _NOEXCEPT 199 { 200 if (ptr) 201 ::free(ptr); 202 } 203 204 _LIBCPP_WEAK 205 void 206 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT 207 { 208 ::operator delete(ptr); 209 } 210 211 _LIBCPP_WEAK 212 void 213 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 214 { 215 ::operator delete(ptr, alignment); 216 } 217 218 _LIBCPP_WEAK 219 void 220 operator delete(void* ptr, size_t) _NOEXCEPT 221 { 222 ::operator delete(ptr); 223 } 224 225 _LIBCPP_WEAK 226 void 227 operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT 228 { 229 ::operator delete(ptr, alignment); 230 } 231 232 _LIBCPP_WEAK 233 void 234 operator delete[] (void* ptr) _NOEXCEPT 235 { 236 ::operator delete(ptr); 237 } 238 239 _LIBCPP_WEAK 240 void 241 operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT 242 { 243 ::operator delete(ptr, alignment); 244 } 245 246 _LIBCPP_WEAK 247 void 248 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT 249 { 250 ::operator delete[](ptr); 251 } 252 253 _LIBCPP_WEAK 254 void 255 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 256 { 257 ::operator delete[](ptr, alignment); 258 } 259 260 _LIBCPP_WEAK 261 void 262 operator delete[] (void* ptr, size_t) _NOEXCEPT 263 { 264 ::operator delete[](ptr); 265 } 266 267 _LIBCPP_WEAK 268 void 269 operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT 270 { 271 ::operator delete[](ptr, alignment); 272 } 273 274 #endif // !__GLIBCXX__ 275 276 namespace std 277 { 278 279 #ifndef __GLIBCXX__ 280 const nothrow_t nothrow = {}; 281 #endif 282 283 #ifndef _LIBCPPABI_VERSION 284 285 #ifndef __GLIBCXX__ 286 287 new_handler 288 set_new_handler(new_handler handler) _NOEXCEPT 289 { 290 return __sync_lock_test_and_set(&__new_handler, handler); 291 } 292 293 new_handler 294 get_new_handler() _NOEXCEPT 295 { 296 return __sync_fetch_and_add(&__new_handler, nullptr); 297 } 298 299 #endif // !__GLIBCXX__ 300 301 #ifndef LIBCXXRT 302 303 bad_alloc::bad_alloc() _NOEXCEPT 304 { 305 } 306 307 #ifndef __GLIBCXX__ 308 309 bad_alloc::~bad_alloc() _NOEXCEPT 310 { 311 } 312 313 const char* 314 bad_alloc::what() const _NOEXCEPT 315 { 316 return "std::bad_alloc"; 317 } 318 319 #endif // !__GLIBCXX__ 320 321 bad_array_new_length::bad_array_new_length() _NOEXCEPT 322 { 323 } 324 325 #ifndef __GLIBCXX__ 326 327 bad_array_new_length::~bad_array_new_length() _NOEXCEPT 328 { 329 } 330 331 const char* 332 bad_array_new_length::what() const _NOEXCEPT 333 { 334 return "bad_array_new_length"; 335 } 336 337 #endif // !__GLIBCXX__ 338 339 #endif //LIBCXXRT 340 341 bad_array_length::bad_array_length() _NOEXCEPT 342 { 343 } 344 345 #ifndef __GLIBCXX__ 346 347 bad_array_length::~bad_array_length() _NOEXCEPT 348 { 349 } 350 351 const char* 352 bad_array_length::what() const _NOEXCEPT 353 { 354 return "bad_array_length"; 355 } 356 357 #endif // !__GLIBCXX__ 358 359 #endif // _LIBCPPABI_VERSION 360 361 #ifndef LIBSTDCXX 362 363 void 364 __throw_bad_alloc() 365 { 366 #ifndef _LIBCPP_NO_EXCEPTIONS 367 throw bad_alloc(); 368 #else 369 _VSTD::abort(); 370 #endif 371 } 372 373 #endif // !LIBSTDCXX 374 375 } // std 376