1 //===----------------------------------------------------------------------===// 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 <__memory/aligned_alloc.h> 10 #include <cstdlib> 11 #include <new> 12 13 #if !defined(__GLIBCXX__) && !defined(_LIBCPP_ABI_VCRUNTIME) 14 15 // The code below is copied as-is into libc++abi's libcxxabi/src/stdlib_new_delete.cpp 16 // file. The version in this file is the canonical one. 17 18 // ------------------ BEGIN COPY ------------------ 19 // Implement all new and delete operators as weak definitions 20 // in this shared library, so that they can be overridden by programs 21 // that define non-weak copies of the functions. 22 23 _LIBCPP_WEAK 24 void * 25 operator new(std::size_t size) _THROW_BAD_ALLOC 26 { 27 if (size == 0) 28 size = 1; 29 void* p; 30 while ((p = std::malloc(size)) == nullptr) 31 { 32 // If malloc fails and there is a new_handler, 33 // call it to try free up memory. 34 std::new_handler nh = std::get_new_handler(); 35 if (nh) 36 nh(); 37 else 38 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 39 throw std::bad_alloc(); 40 #else 41 break; 42 #endif 43 } 44 return p; 45 } 46 47 _LIBCPP_WEAK 48 void* 49 operator new(size_t size, const std::nothrow_t&) noexcept 50 { 51 void* p = nullptr; 52 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 53 try 54 { 55 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 56 p = ::operator new(size); 57 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 58 } 59 catch (...) 60 { 61 } 62 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 63 return p; 64 } 65 66 _LIBCPP_WEAK 67 void* 68 operator new[](size_t size) _THROW_BAD_ALLOC 69 { 70 return ::operator new(size); 71 } 72 73 _LIBCPP_WEAK 74 void* 75 operator new[](size_t size, const std::nothrow_t&) noexcept 76 { 77 void* p = nullptr; 78 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 79 try 80 { 81 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 82 p = ::operator new[](size); 83 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 84 } 85 catch (...) 86 { 87 } 88 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 89 return p; 90 } 91 92 _LIBCPP_WEAK 93 void 94 operator delete(void* ptr) noexcept 95 { 96 std::free(ptr); 97 } 98 99 _LIBCPP_WEAK 100 void 101 operator delete(void* ptr, const std::nothrow_t&) noexcept 102 { 103 ::operator delete(ptr); 104 } 105 106 _LIBCPP_WEAK 107 void 108 operator delete(void* ptr, size_t) noexcept 109 { 110 ::operator delete(ptr); 111 } 112 113 _LIBCPP_WEAK 114 void 115 operator delete[] (void* ptr) noexcept 116 { 117 ::operator delete(ptr); 118 } 119 120 _LIBCPP_WEAK 121 void 122 operator delete[] (void* ptr, const std::nothrow_t&) noexcept 123 { 124 ::operator delete[](ptr); 125 } 126 127 _LIBCPP_WEAK 128 void 129 operator delete[] (void* ptr, size_t) noexcept 130 { 131 ::operator delete[](ptr); 132 } 133 134 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) 135 136 _LIBCPP_WEAK 137 void * 138 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 139 { 140 if (size == 0) 141 size = 1; 142 if (static_cast<size_t>(alignment) < sizeof(void*)) 143 alignment = std::align_val_t(sizeof(void*)); 144 145 // Try allocating memory. If allocation fails and there is a new_handler, 146 // call it to try free up memory, and try again until it succeeds, or until 147 // the new_handler decides to terminate. 148 // 149 // If allocation fails and there is no new_handler, we throw bad_alloc 150 // (or return nullptr if exceptions are disabled). 151 void* p; 152 while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr) 153 { 154 std::new_handler nh = std::get_new_handler(); 155 if (nh) 156 nh(); 157 else { 158 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 159 throw std::bad_alloc(); 160 #else 161 break; 162 #endif 163 } 164 } 165 return p; 166 } 167 168 _LIBCPP_WEAK 169 void* 170 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept 171 { 172 void* p = nullptr; 173 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 174 try 175 { 176 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 177 p = ::operator new(size, alignment); 178 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 179 } 180 catch (...) 181 { 182 } 183 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 184 return p; 185 } 186 187 _LIBCPP_WEAK 188 void* 189 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 190 { 191 return ::operator new(size, alignment); 192 } 193 194 _LIBCPP_WEAK 195 void* 196 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept 197 { 198 void* p = nullptr; 199 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 200 try 201 { 202 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 203 p = ::operator new[](size, alignment); 204 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 205 } 206 catch (...) 207 { 208 } 209 #endif // _LIBCPP_HAS_NO_EXCEPTIONS 210 return p; 211 } 212 213 _LIBCPP_WEAK 214 void 215 operator delete(void* ptr, std::align_val_t) noexcept 216 { 217 std::__libcpp_aligned_free(ptr); 218 } 219 220 _LIBCPP_WEAK 221 void 222 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept 223 { 224 ::operator delete(ptr, alignment); 225 } 226 227 _LIBCPP_WEAK 228 void 229 operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept 230 { 231 ::operator delete(ptr, alignment); 232 } 233 234 _LIBCPP_WEAK 235 void 236 operator delete[] (void* ptr, std::align_val_t alignment) noexcept 237 { 238 ::operator delete(ptr, alignment); 239 } 240 241 _LIBCPP_WEAK 242 void 243 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept 244 { 245 ::operator delete[](ptr, alignment); 246 } 247 248 _LIBCPP_WEAK 249 void 250 operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept 251 { 252 ::operator delete[](ptr, alignment); 253 } 254 255 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION 256 // ------------------ END COPY ------------------ 257 258 #endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME 259