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