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 #if defined(_LIBCPP_MSVCRT) 202 ::_aligned_free(ptr); 203 #else 204 ::free(ptr); 205 #endif 206 } 207 208 _LIBCPP_WEAK 209 void 210 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT 211 { 212 ::operator delete(ptr); 213 } 214 215 _LIBCPP_WEAK 216 void 217 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 218 { 219 ::operator delete(ptr, alignment); 220 } 221 222 _LIBCPP_WEAK 223 void 224 operator delete(void* ptr, size_t) _NOEXCEPT 225 { 226 ::operator delete(ptr); 227 } 228 229 _LIBCPP_WEAK 230 void 231 operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT 232 { 233 ::operator delete(ptr, alignment); 234 } 235 236 _LIBCPP_WEAK 237 void 238 operator delete[] (void* ptr) _NOEXCEPT 239 { 240 ::operator delete(ptr); 241 } 242 243 _LIBCPP_WEAK 244 void 245 operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT 246 { 247 ::operator delete(ptr, alignment); 248 } 249 250 _LIBCPP_WEAK 251 void 252 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT 253 { 254 ::operator delete[](ptr); 255 } 256 257 _LIBCPP_WEAK 258 void 259 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 260 { 261 ::operator delete[](ptr, alignment); 262 } 263 264 _LIBCPP_WEAK 265 void 266 operator delete[] (void* ptr, size_t) _NOEXCEPT 267 { 268 ::operator delete[](ptr); 269 } 270 271 _LIBCPP_WEAK 272 void 273 operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT 274 { 275 ::operator delete[](ptr, alignment); 276 } 277 278 #endif // !__GLIBCXX__ 279 280 namespace std 281 { 282 283 #ifndef __GLIBCXX__ 284 const nothrow_t nothrow = {}; 285 #endif 286 287 #ifndef _LIBCPPABI_VERSION 288 289 #ifndef __GLIBCXX__ 290 291 new_handler 292 set_new_handler(new_handler handler) _NOEXCEPT 293 { 294 return __sync_lock_test_and_set(&__new_handler, handler); 295 } 296 297 new_handler 298 get_new_handler() _NOEXCEPT 299 { 300 return __sync_fetch_and_add(&__new_handler, nullptr); 301 } 302 303 #endif // !__GLIBCXX__ 304 305 #ifndef LIBCXXRT 306 307 bad_alloc::bad_alloc() _NOEXCEPT 308 { 309 } 310 311 #ifndef __GLIBCXX__ 312 313 bad_alloc::~bad_alloc() _NOEXCEPT 314 { 315 } 316 317 const char* 318 bad_alloc::what() const _NOEXCEPT 319 { 320 return "std::bad_alloc"; 321 } 322 323 #endif // !__GLIBCXX__ 324 325 bad_array_new_length::bad_array_new_length() _NOEXCEPT 326 { 327 } 328 329 #ifndef __GLIBCXX__ 330 331 bad_array_new_length::~bad_array_new_length() _NOEXCEPT 332 { 333 } 334 335 const char* 336 bad_array_new_length::what() const _NOEXCEPT 337 { 338 return "bad_array_new_length"; 339 } 340 341 #endif // !__GLIBCXX__ 342 343 #endif //LIBCXXRT 344 345 bad_array_length::bad_array_length() _NOEXCEPT 346 { 347 } 348 349 #ifndef __GLIBCXX__ 350 351 bad_array_length::~bad_array_length() _NOEXCEPT 352 { 353 } 354 355 const char* 356 bad_array_length::what() const _NOEXCEPT 357 { 358 return "bad_array_length"; 359 } 360 361 #endif // !__GLIBCXX__ 362 363 #endif // _LIBCPPABI_VERSION 364 365 #ifndef LIBSTDCXX 366 367 void 368 __throw_bad_alloc() 369 { 370 #ifndef _LIBCPP_NO_EXCEPTIONS 371 throw bad_alloc(); 372 #else 373 _VSTD::abort(); 374 #endif 375 } 376 377 #endif // !LIBSTDCXX 378 379 } // std 380