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) _NOEXCEPT 144 { 145 ::operator delete(ptr); 146 } 147 148 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 149 void 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 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 176 set_new_handler(new_handler handler) _NOEXCEPT 177 { 178 return __sync_lock_test_and_set(&__new_handler, handler); 179 } 180 181 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 191 bad_alloc::bad_alloc() _NOEXCEPT 192 { 193 } 194 195 #ifndef __GLIBCXX__ 196 197 bad_alloc::~bad_alloc() _NOEXCEPT 198 { 199 } 200 201 const char* 202 bad_alloc::what() const _NOEXCEPT 203 { 204 return "std::bad_alloc"; 205 } 206 207 #endif // !__GLIBCXX__ 208 209 bad_array_new_length::bad_array_new_length() _NOEXCEPT 210 { 211 } 212 213 bad_array_new_length::~bad_array_new_length() _NOEXCEPT 214 { 215 } 216 217 const char* 218 bad_array_new_length::what() const _NOEXCEPT 219 { 220 return "bad_array_new_length"; 221 } 222 223 #endif //LIBCXXRT 224 225 const char* 226 bad_array_length::what() const _NOEXCEPT 227 { 228 return "bad_array_length"; 229 } 230 231 bad_array_length::bad_array_length() _NOEXCEPT 232 { 233 } 234 235 bad_array_length::~bad_array_length() _NOEXCEPT 236 { 237 } 238 239 #endif // _LIBCPPABI_VERSION 240 241 #ifndef LIBSTDCXX 242 243 void 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
