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