libcxxabi/src/stdlib_new_delete.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 "__cxxabi_config.h"
  10 #include <__memory/aligned_alloc.h>
  11 #include <cstdlib>
  12 #include <new>
  13
  14 // Perform a few sanity checks on libc++ and libc++abi macros to ensure that
  15 // the code below can be an exact copy of the code in libcxx/src/new.cpp.
  16 #if !defined(_THROW_BAD_ALLOC)
  17 #  error The _THROW_BAD_ALLOC macro should be already defined by libc++
  18 #endif
  19
  20 #ifndef _LIBCPP_WEAK
  21 #  error The _LIBCPP_WEAK macro should be already defined by libc++
  22 #endif
  23
  24 #if defined(_LIBCXXABI_NO_EXCEPTIONS) != defined(_LIBCPP_HAS_NO_EXCEPTIONS)
  25 #  error libc++ and libc++abi seem to disagree on whether exceptions are enabled
  26 #endif
  27
  28 // ------------------ BEGIN COPY ------------------
  29 // Implement all new and delete operators as weak definitions
  30 // in this shared library, so that they can be overridden by programs
  31 // that define non-weak copies of the functions.
  32
  33 _LIBCPP_WEAK
  34 void *
  35 operator new(std::size_t size) _THROW_BAD_ALLOC
  36 {
  37     if (size == 0)
  38         size = 1;
  39     void* p;
  40     while ((p = std::malloc(size)) == nullptr)
  41     {
  42         // If malloc fails and there is a new_handler,
  43         // call it to try free up memory.
  44         std::new_handler nh = std::get_new_handler();
  45         if (nh)
  46             nh();
  47         else
  48 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  49             throw std::bad_alloc();
  50 #else
  51             break;
  52 #endif
  53     }
  54     return p;
  55 }
  56
  57 _LIBCPP_WEAK
  58 void*
  59 operator new(size_t size, const std::nothrow_t&) noexcept
  60 {
  61     void* p = nullptr;
  62 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  63     try
  64     {
  65 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
  66         p = ::operator new(size);
  67 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  68     }
  69     catch (...)
  70     {
  71     }
  72 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
  73     return p;
  74 }
  75
  76 _LIBCPP_WEAK
  77 void*
  78 operator new[](size_t size) _THROW_BAD_ALLOC
  79 {
  80     return ::operator new(size);
  81 }
  82
  83 _LIBCPP_WEAK
  84 void*
  85 operator new[](size_t size, const std::nothrow_t&) noexcept
  86 {
  87     void* p = nullptr;
  88 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  89     try
  90     {
  91 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
  92         p = ::operator new[](size);
  93 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  94     }
  95     catch (...)
  96     {
  97     }
  98 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
  99     return p;
 100 }
 101
 102 _LIBCPP_WEAK
 103 void
 104 operator delete(void* ptr) noexcept
 105 {
 106     std::free(ptr);
 107 }
 108
 109 _LIBCPP_WEAK
 110 void
 111 operator delete(void* ptr, const std::nothrow_t&) noexcept
 112 {
 113     ::operator delete(ptr);
 114 }
 115
 116 _LIBCPP_WEAK
 117 void
 118 operator delete(void* ptr, size_t) noexcept
 119 {
 120     ::operator delete(ptr);
 121 }
 122
 123 _LIBCPP_WEAK
 124 void
 125 operator delete[] (void* ptr) noexcept
 126 {
 127     ::operator delete(ptr);
 128 }
 129
 130 _LIBCPP_WEAK
 131 void
 132 operator delete[] (void* ptr, const std::nothrow_t&) noexcept
 133 {
 134     ::operator delete[](ptr);
 135 }
 136
 137 _LIBCPP_WEAK
 138 void
 139 operator delete[] (void* ptr, size_t) noexcept
 140 {
 141     ::operator delete[](ptr);
 142 }
 143
 144 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
 145
 146 _LIBCPP_WEAK
 147 void *
 148 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 149 {
 150     if (size == 0)
 151         size = 1;
 152     if (static_cast<size_t>(alignment) < sizeof(void*))
 153       alignment = std::align_val_t(sizeof(void*));
 154
 155     // Try allocating memory. If allocation fails and there is a new_handler,
 156     // call it to try free up memory, and try again until it succeeds, or until
 157     // the new_handler decides to terminate.
 158     //
 159     // If allocation fails and there is no new_handler, we throw bad_alloc
 160     // (or return nullptr if exceptions are disabled).
 161     void* p;
 162     while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr)
 163     {
 164         std::new_handler nh = std::get_new_handler();
 165         if (nh)
 166             nh();
 167         else {
 168 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 169             throw std::bad_alloc();
 170 #else
 171             break;
 172 #endif
 173         }
 174     }
 175     return p;
 176 }
 177
 178 _LIBCPP_WEAK
 179 void*
 180 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 181 {
 182     void* p = nullptr;
 183 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 184     try
 185     {
 186 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 187         p = ::operator new(size, alignment);
 188 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 189     }
 190     catch (...)
 191     {
 192     }
 193 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 194     return p;
 195 }
 196
 197 _LIBCPP_WEAK
 198 void*
 199 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 200 {
 201     return ::operator new(size, alignment);
 202 }
 203
 204 _LIBCPP_WEAK
 205 void*
 206 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 207 {
 208     void* p = nullptr;
 209 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 210     try
 211     {
 212 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 213         p = ::operator new[](size, alignment);
 214 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 215     }
 216     catch (...)
 217     {
 218     }
 219 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 220     return p;
 221 }
 222
 223 _LIBCPP_WEAK
 224 void
 225 operator delete(void* ptr, std::align_val_t) noexcept
 226 {
 227     std::__libcpp_aligned_free(ptr);
 228 }
 229
 230 _LIBCPP_WEAK
 231 void
 232 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 233 {
 234     ::operator delete(ptr, alignment);
 235 }
 236
 237 _LIBCPP_WEAK
 238 void
 239 operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
 240 {
 241     ::operator delete(ptr, alignment);
 242 }
 243
 244 _LIBCPP_WEAK
 245 void
 246 operator delete[] (void* ptr, std::align_val_t alignment) noexcept
 247 {
 248     ::operator delete(ptr, alignment);
 249 }
 250
 251 _LIBCPP_WEAK
 252 void
 253 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
 254 {
 255     ::operator delete[](ptr, alignment);
 256 }
 257
 258 _LIBCPP_WEAK
 259 void
 260 operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
 261 {
 262     ::operator delete[](ptr, alignment);
 263 }
 264
 265 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
 266 // ------------------ END COPY ------------------