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