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 #ifdef __APPLE__ 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) _NOEXCEPT 137 { 138 ::operator delete (ptr); 139 } 140 141 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS 142 void 143 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT 144 { 145 ::operator delete[](ptr); 146 } 147 148 #endif // !__GLIBCXX__ 149 150 namespace std 151 { 152 153 #ifndef __GLIBCXX__ 154 const nothrow_t nothrow = {}; 155 #endif 156 157 #ifndef _LIBCPPABI_VERSION 158 159 #ifndef __GLIBCXX__ 160 161 new_handler 162 set_new_handler(new_handler handler) _NOEXCEPT 163 { 164 return __sync_lock_test_and_set(&__new_handler, handler); 165 } 166 167 new_handler 168 get_new_handler() _NOEXCEPT 169 { 170 return __sync_fetch_and_add(&__new_handler, nullptr); 171 } 172 173 #endif // !__GLIBCXX__ 174 175 #ifndef LIBCXXRT 176 177 bad_alloc::bad_alloc() _NOEXCEPT 178 { 179 } 180 181 #ifndef __GLIBCXX__ 182 183 bad_alloc::~bad_alloc() _NOEXCEPT 184 { 185 } 186 187 const char* 188 bad_alloc::what() const _NOEXCEPT 189 { 190 return "std::bad_alloc"; 191 } 192 193 #endif // !__GLIBCXX__ 194 195 #endif //LIBCXXRT 196 197 bad_array_new_length::bad_array_new_length() _NOEXCEPT 198 { 199 } 200 201 bad_array_new_length::~bad_array_new_length() _NOEXCEPT 202 { 203 } 204 205 const char* 206 bad_array_length::what() const _NOEXCEPT 207 { 208 return "bad_array_length"; 209 } 210 211 bad_array_length::bad_array_length() _NOEXCEPT 212 { 213 } 214 215 bad_array_length::~bad_array_length() _NOEXCEPT 216 { 217 } 218 219 const char* 220 bad_array_new_length::what() const _NOEXCEPT 221 { 222 return "bad_array_new_length"; 223 } 224 225 #endif // _LIBCPPABI_VERSION 226 227 #ifndef LIBSTDCXX 228 229 void 230 __throw_bad_alloc() 231 { 232 #ifndef _LIBCPP_NO_EXCEPTIONS 233 throw bad_alloc(); 234 #endif 235 } 236 237 #endif // !LIBSTDCXX 238 239 } // std 240
