libcxx/src/new.cpp

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