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 
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 
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 
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 
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*
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 
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*
171 operator 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