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

source code of libcxx/src/new.cpp