contrib/libc++/src/new.cpp

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