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