contrib/libc++/src/new.cpp

   1 //===--------------------------- new.cpp ----------------------------------===//
   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 <stdlib.h>
  10
  11 #include "new"
  12 #include "include/atomic_support.h"
  13
  14 #if defined(_LIBCPP_ABI_MICROSOFT)
  15 #   if !defined(_LIBCPP_ABI_VCRUNTIME)
  16 #       include "support/runtime/new_handler_fallback.ipp"
  17 #   endif
  18 #elif defined(LIBCXX_BUILDING_LIBCXXABI)
  19 #   include <cxxabi.h>
  20 #elif defined(LIBCXXRT)
  21 #   include <cxxabi.h>
  22 #   include "support/runtime/new_handler_fallback.ipp"
  23 #elif defined(__GLIBCXX__)
  24     // nothing to do
  25 #else
  26 #   include "support/runtime/new_handler_fallback.ipp"
  27 #endif
  28
  29 namespace std
  30 {
  31
  32 #ifndef __GLIBCXX__
  33 const nothrow_t nothrow{};
  34 #endif
  35
  36 #ifndef LIBSTDCXX
  37
  38 void
  39 __throw_bad_alloc()
  40 {
  41 #ifndef _LIBCPP_NO_EXCEPTIONS
  42     throw bad_alloc();
  43 #else
  44     _VSTD::abort();
  45 #endif
  46 }
  47
  48 #endif // !LIBSTDCXX
  49
  50 }  // std
  51
  52 #if !defined(__GLIBCXX__) &&                                                   \
  53     !defined(_LIBCPP_ABI_VCRUNTIME) &&      \
  54     !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
  55
  56 // Implement all new and delete operators as weak definitions
  57 // in this shared library, so that they can be overridden by programs
  58 // that define non-weak copies of the functions.
  59
  60 _LIBCPP_WEAK
  61 void *
  62 operator new(std::size_t size) _THROW_BAD_ALLOC
  63 {
  64     if (size == 0)
  65         size = 1;
  66     void* p;
  67     while ((p = ::malloc(size)) == 0)
  68     {
  69         // If malloc fails and there is a new_handler,
  70         // call it to try free up memory.
  71         std::new_handler nh = std::get_new_handler();
  72         if (nh)
  73             nh();
  74         else
  75 #ifndef _LIBCPP_NO_EXCEPTIONS
  76             throw std::bad_alloc();
  77 #else
  78             break;
  79 #endif
  80     }
  81     return p;
  82 }
  83
  84 _LIBCPP_WEAK
  85 void*
  86 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
  87 {
  88     void* p = 0;
  89 #ifndef _LIBCPP_NO_EXCEPTIONS
  90     try
  91     {
  92 #endif  // _LIBCPP_NO_EXCEPTIONS
  93         p = ::operator new(size);
  94 #ifndef _LIBCPP_NO_EXCEPTIONS
  95     }
  96     catch (...)
  97     {
  98     }
  99 #endif  // _LIBCPP_NO_EXCEPTIONS
 100     return p;
 101 }
 102
 103 _LIBCPP_WEAK
 104 void*
 105 operator new[](size_t size) _THROW_BAD_ALLOC
 106 {
 107     return ::operator new(size);
 108 }
 109
 110 _LIBCPP_WEAK
 111 void*
 112 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
 113 {
 114     void* p = 0;
 115 #ifndef _LIBCPP_NO_EXCEPTIONS
 116     try
 117     {
 118 #endif  // _LIBCPP_NO_EXCEPTIONS
 119         p = ::operator new[](size);
 120 #ifndef _LIBCPP_NO_EXCEPTIONS
 121     }
 122     catch (...)
 123     {
 124     }
 125 #endif  // _LIBCPP_NO_EXCEPTIONS
 126     return p;
 127 }
 128
 129 _LIBCPP_WEAK
 130 void
 131 operator delete(void* ptr) _NOEXCEPT
 132 {
 133     ::free(ptr);
 134 }
 135
 136 _LIBCPP_WEAK
 137 void
 138 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 139 {
 140     ::operator delete(ptr);
 141 }
 142
 143 _LIBCPP_WEAK
 144 void
 145 operator delete(void* ptr, size_t) _NOEXCEPT
 146 {
 147     ::operator delete(ptr);
 148 }
 149
 150 _LIBCPP_WEAK
 151 void
 152 operator delete[] (void* ptr) _NOEXCEPT
 153 {
 154     ::operator delete(ptr);
 155 }
 156
 157 _LIBCPP_WEAK
 158 void
 159 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 160 {
 161     ::operator delete[](ptr);
 162 }
 163
 164 _LIBCPP_WEAK
 165 void
 166 operator delete[] (void* ptr, size_t) _NOEXCEPT
 167 {
 168     ::operator delete[](ptr);
 169 }
 170
 171 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
 172
 173 _LIBCPP_WEAK
 174 void *
 175 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 176 {
 177     if (size == 0)
 178         size = 1;
 179     if (static_cast<size_t>(alignment) < sizeof(void*))
 180       alignment = std::align_val_t(sizeof(void*));
 181     void* p;
 182 #if defined(_LIBCPP_MSVCRT_LIKE)
 183     while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr)
 184 #else
 185     while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0)
 186 #endif
 187     {
 188         // If posix_memalign fails and there is a new_handler,
 189         // call it to try free up memory.
 190         std::new_handler nh = std::get_new_handler();
 191         if (nh)
 192             nh();
 193         else {
 194 #ifndef _LIBCPP_NO_EXCEPTIONS
 195             throw std::bad_alloc();
 196 #else
 197             p = nullptr; // posix_memalign doesn't initialize 'p' on failure
 198             break;
 199 #endif
 200         }
 201     }
 202     return p;
 203 }
 204
 205 _LIBCPP_WEAK
 206 void*
 207 operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 208 {
 209     void* p = 0;
 210 #ifndef _LIBCPP_NO_EXCEPTIONS
 211     try
 212     {
 213 #endif  // _LIBCPP_NO_EXCEPTIONS
 214         p = ::operator new(size, alignment);
 215 #ifndef _LIBCPP_NO_EXCEPTIONS
 216     }
 217     catch (...)
 218     {
 219     }
 220 #endif  // _LIBCPP_NO_EXCEPTIONS
 221     return p;
 222 }
 223
 224 _LIBCPP_WEAK
 225 void*
 226 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 227 {
 228     return ::operator new(size, alignment);
 229 }
 230
 231 _LIBCPP_WEAK
 232 void*
 233 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 234 {
 235     void* p = 0;
 236 #ifndef _LIBCPP_NO_EXCEPTIONS
 237     try
 238     {
 239 #endif  // _LIBCPP_NO_EXCEPTIONS
 240         p = ::operator new[](size, alignment);
 241 #ifndef _LIBCPP_NO_EXCEPTIONS
 242     }
 243     catch (...)
 244     {
 245     }
 246 #endif  // _LIBCPP_NO_EXCEPTIONS
 247     return p;
 248 }
 249
 250 _LIBCPP_WEAK
 251 void
 252 operator delete(void* ptr, std::align_val_t) _NOEXCEPT
 253 {
 254 #if defined(_LIBCPP_MSVCRT_LIKE)
 255     ::_aligned_free(ptr);
 256 #else
 257     ::free(ptr);
 258 #endif
 259 }
 260
 261 _LIBCPP_WEAK
 262 void
 263 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 264 {
 265     ::operator delete(ptr, alignment);
 266 }
 267
 268 _LIBCPP_WEAK
 269 void
 270 operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 271 {
 272     ::operator delete(ptr, alignment);
 273 }
 274
 275 _LIBCPP_WEAK
 276 void
 277 operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
 278 {
 279     ::operator delete(ptr, alignment);
 280 }
 281
 282 _LIBCPP_WEAK
 283 void
 284 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 285 {
 286     ::operator delete[](ptr, alignment);
 287 }
 288
 289 _LIBCPP_WEAK
 290 void
 291 operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 292 {
 293     ::operator delete[](ptr, alignment);
 294 }
 295
 296 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
 297 #endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS