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(_LIBCPP_ABI_MICROSOFT) 17 // nothing todo 18 #elif defined(LIBCXX_BUILDING_LIBCXXABI) 19 #include <cxxabi.h> 20 #elif defined(LIBCXXRT) 21 #include <cxxabi.h> 22 #include "support/runtime/new_handler_fallback.ipp" 23 #elif defined(__GLIBCXX__) 24 // nothing todo 25 #else 26 # if defined(__APPLE__) && !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) 27 # include <cxxabi.h> // FIXME: remove this once buildit is gone. 28 # else 29 # include "support/runtime/new_handler_fallback.ipp" 30 # endif 31 #endif 32 33 namespace std 34 { 35 36 #ifndef __GLIBCXX__ 37 const nothrow_t nothrow = {}; 38 #endif 39 40 #ifndef LIBSTDCXX 41 42 void 43 __throw_bad_alloc() 44 { 45 #ifndef _LIBCPP_NO_EXCEPTIONS 46 throw bad_alloc(); 47 #else 48 _VSTD::abort(); 49 #endif 50 } 51 52 #endif // !LIBSTDCXX 53 54 } // std 55 56 #if !defined(__GLIBCXX__) && !defined(_LIBCPP_ABI_MICROSOFT) && \ 57 !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS) 58 59 // Implement all new and delete operators as weak definitions 60 // in this shared library, so that they can be overridden by programs 61 // that define non-weak copies of the functions. 62 63 _LIBCPP_WEAK 64 void * 65 operator new(std::size_t size) _THROW_BAD_ALLOC 66 { 67 if (size == 0) 68 size = 1; 69 void* p; 70 while ((p = ::malloc(size)) == 0) 71 { 72 // If malloc fails and there is a new_handler, 73 // call it to try free up memory. 74 std::new_handler nh = std::get_new_handler(); 75 if (nh) 76 nh(); 77 else 78 #ifndef _LIBCPP_NO_EXCEPTIONS 79 throw std::bad_alloc(); 80 #else 81 break; 82 #endif 83 } 84 return p; 85 } 86 87 _LIBCPP_WEAK 88 void* 89 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT 90 { 91 void* p = 0; 92 #ifndef _LIBCPP_NO_EXCEPTIONS 93 try 94 { 95 #endif // _LIBCPP_NO_EXCEPTIONS 96 p = ::operator new(size); 97 #ifndef _LIBCPP_NO_EXCEPTIONS 98 } 99 catch (...) 100 { 101 } 102 #endif // _LIBCPP_NO_EXCEPTIONS 103 return p; 104 } 105 106 _LIBCPP_WEAK 107 void* 108 operator new[](size_t size) _THROW_BAD_ALLOC 109 { 110 return ::operator new(size); 111 } 112 113 _LIBCPP_WEAK 114 void* 115 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT 116 { 117 void* p = 0; 118 #ifndef _LIBCPP_NO_EXCEPTIONS 119 try 120 { 121 #endif // _LIBCPP_NO_EXCEPTIONS 122 p = ::operator new[](size); 123 #ifndef _LIBCPP_NO_EXCEPTIONS 124 } 125 catch (...) 126 { 127 } 128 #endif // _LIBCPP_NO_EXCEPTIONS 129 return p; 130 } 131 132 _LIBCPP_WEAK 133 void 134 operator delete(void* ptr) _NOEXCEPT 135 { 136 if (ptr) 137 ::free(ptr); 138 } 139 140 _LIBCPP_WEAK 141 void 142 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT 143 { 144 ::operator delete(ptr); 145 } 146 147 _LIBCPP_WEAK 148 void 149 operator delete(void* ptr, size_t) _NOEXCEPT 150 { 151 ::operator delete(ptr); 152 } 153 154 _LIBCPP_WEAK 155 void 156 operator delete[] (void* ptr) _NOEXCEPT 157 { 158 ::operator delete(ptr); 159 } 160 161 _LIBCPP_WEAK 162 void 163 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT 164 { 165 ::operator delete[](ptr); 166 } 167 168 _LIBCPP_WEAK 169 void 170 operator delete[] (void* ptr, size_t) _NOEXCEPT 171 { 172 ::operator delete[](ptr); 173 } 174 175 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) 176 177 _LIBCPP_WEAK 178 void * 179 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 180 { 181 if (size == 0) 182 size = 1; 183 if (static_cast<size_t>(alignment) < sizeof(void*)) 184 alignment = std::align_val_t(sizeof(void*)); 185 void* p; 186 #if defined(_LIBCPP_MSVCRT_LIKE) 187 while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr) 188 #else 189 while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0) 190 #endif 191 { 192 // If posix_memalign fails and there is a new_handler, 193 // call it to try free up memory. 194 std::new_handler nh = std::get_new_handler(); 195 if (nh) 196 nh(); 197 else { 198 #ifndef _LIBCPP_NO_EXCEPTIONS 199 throw std::bad_alloc(); 200 #else 201 p = nullptr; // posix_memalign doesn't initialize 'p' on failure 202 break; 203 #endif 204 } 205 } 206 return p; 207 } 208 209 _LIBCPP_WEAK 210 void* 211 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 212 { 213 void* p = 0; 214 #ifndef _LIBCPP_NO_EXCEPTIONS 215 try 216 { 217 #endif // _LIBCPP_NO_EXCEPTIONS 218 p = ::operator new(size, alignment); 219 #ifndef _LIBCPP_NO_EXCEPTIONS 220 } 221 catch (...) 222 { 223 } 224 #endif // _LIBCPP_NO_EXCEPTIONS 225 return p; 226 } 227 228 _LIBCPP_WEAK 229 void* 230 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 231 { 232 return ::operator new(size, alignment); 233 } 234 235 _LIBCPP_WEAK 236 void* 237 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 238 { 239 void* p = 0; 240 #ifndef _LIBCPP_NO_EXCEPTIONS 241 try 242 { 243 #endif // _LIBCPP_NO_EXCEPTIONS 244 p = ::operator new[](size, alignment); 245 #ifndef _LIBCPP_NO_EXCEPTIONS 246 } 247 catch (...) 248 { 249 } 250 #endif // _LIBCPP_NO_EXCEPTIONS 251 return p; 252 } 253 254 _LIBCPP_WEAK 255 void 256 operator delete(void* ptr, std::align_val_t) _NOEXCEPT 257 { 258 if (ptr) 259 #if defined(_LIBCPP_MSVCRT_LIKE) 260 ::_aligned_free(ptr); 261 #else 262 ::free(ptr); 263 #endif 264 } 265 266 _LIBCPP_WEAK 267 void 268 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 269 { 270 ::operator delete(ptr, alignment); 271 } 272 273 _LIBCPP_WEAK 274 void 275 operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT 276 { 277 ::operator delete(ptr, alignment); 278 } 279 280 _LIBCPP_WEAK 281 void 282 operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT 283 { 284 ::operator delete(ptr, alignment); 285 } 286 287 _LIBCPP_WEAK 288 void 289 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT 290 { 291 ::operator delete[](ptr, alignment); 292 } 293 294 _LIBCPP_WEAK 295 void 296 operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT 297 { 298 ::operator delete[](ptr, alignment); 299 } 300 301 #endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION 302 #endif // !__GLIBCXX__ && !_LIBCPP_ABI_MICROSOFT && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS 303
