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
__throw_bad_alloc_shim()20 inline 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
operator_new_impl(std::size_t size)29 static 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
operator new(std::size_t size)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
operator new(size_t size,const std::nothrow_t &)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
operator new[](size_t size)76 _LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void* operator new[](size_t size) _THROW_BAD_ALLOC {
77 return ::operator new(size);
78 }
79
operator new[](size_t size,const std::nothrow_t &)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
operator delete(void * ptr)104 _LIBCPP_WEAK void operator delete(void* ptr) noexcept { std::free(ptr); }
105
operator delete(void * ptr,const std::nothrow_t &)106 _LIBCPP_WEAK void operator delete(void* ptr, const std::nothrow_t&) noexcept { ::operator delete(ptr); }
107
operator delete(void * ptr,size_t)108 _LIBCPP_WEAK void operator delete(void* ptr, size_t) noexcept { ::operator delete(ptr); }
109
operator delete[](void * ptr)110 _LIBCPP_WEAK void operator delete[](void* ptr) noexcept { ::operator delete(ptr); }
111
operator delete[](void * ptr,const std::nothrow_t &)112 _LIBCPP_WEAK void operator delete[](void* ptr, const std::nothrow_t&) noexcept { ::operator delete[](ptr); }
113
operator delete[](void * ptr,size_t)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
operator_new_aligned_impl(std::size_t size,std::align_val_t alignment)118 static 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*
operator new(std::size_t size,std::align_val_t alignment)139 operator 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
operator new(size_t size,std::align_val_t alignment,const std::nothrow_t &)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*
operator new[](size_t size,std::align_val_t alignment)171 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
172 return ::operator new(size, alignment);
173 }
174
operator new[](size_t size,std::align_val_t alignment,const std::nothrow_t &)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
operator delete(void * ptr,std::align_val_t)200 _LIBCPP_WEAK void operator delete(void* ptr, std::align_val_t) noexcept { std::__libcpp_aligned_free(ptr); }
201
operator delete(void * ptr,std::align_val_t alignment,const std::nothrow_t &)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
operator delete(void * ptr,size_t,std::align_val_t alignment)206 _LIBCPP_WEAK void operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept {
207 ::operator delete(ptr, alignment);
208 }
209
operator delete[](void * ptr,std::align_val_t alignment)210 _LIBCPP_WEAK void operator delete[](void* ptr, std::align_val_t alignment) noexcept {
211 ::operator delete(ptr, alignment);
212 }
213
operator delete[](void * ptr,std::align_val_t alignment,const std::nothrow_t &)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
operator delete[](void * ptr,size_t,std::align_val_t alignment)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