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