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