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
  16 #if defined(__APPLE__) && !defined(LIBCXXRT) && \
  17     !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
  18     #include <cxxabi.h>
  19
  20     #ifndef _LIBCPPABI_VERSION
  21         // On Darwin, there are two STL shared libraries and a lower level ABI
  22         // shared library.  The global holding the current new handler is
  23         // in the ABI library and named __cxa_new_handler.
  24         #define __new_handler __cxxabiapple::__cxa_new_handler
  25     #endif
  26 #else  // __APPLE__
  27     #if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
  28         #include <cxxabi.h>
  29     #endif  // defined(LIBCXX_BUILDING_LIBCXXABI)
  30     #if defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) || \
  31         (!defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__))
  32         static std::new_handler __new_handler;
  33     #endif  // _LIBCPPABI_VERSION
  34 #endif
  35
  36 #ifndef __GLIBCXX__
  37
  38 // Implement all new and delete operators as weak definitions
  39 // in this shared library, so that they can be overridden by programs
  40 // that define non-weak copies of the functions.
  41
  42 _LIBCPP_WEAK
  43 void *
  44 operator new(std::size_t size) _THROW_BAD_ALLOC
  45 {
  46     if (size == 0)
  47         size = 1;
  48     void* p;
  49     while ((p = ::malloc(size)) == 0)
  50     {
  51         // If malloc fails and there is a new_handler,
  52         // call it to try free up memory.
  53         std::new_handler nh = std::get_new_handler();
  54         if (nh)
  55             nh();
  56         else
  57 #ifndef _LIBCPP_NO_EXCEPTIONS
  58             throw std::bad_alloc();
  59 #else
  60             break;
  61 #endif
  62     }
  63     return p;
  64 }
  65
  66 _LIBCPP_WEAK
  67 void *
  68 operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
  69 {
  70     if (size == 0)
  71         size = 1;
  72     if (static_cast<size_t>(alignment) < sizeof(void*))
  73       alignment = std::align_val_t(sizeof(void*));
  74     void* p;
  75 #if defined(_LIBCPP_MSVCRT)
  76     while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr)
  77 #else
  78     while (::posix_memalign(&p, static_cast<size_t>(alignment), size) != 0)
  79 #endif
  80     {
  81         // If posix_memalign fails and there is a new_handler,
  82         // call it to try free up memory.
  83         std::new_handler nh = std::get_new_handler();
  84         if (nh)
  85             nh();
  86         else {
  87 #ifndef _LIBCPP_NO_EXCEPTIONS
  88             throw std::bad_alloc();
  89 #else
  90             p = nullptr; // posix_memalign doesn't initialize 'p' on failure
  91             break;
  92 #endif
  93         }
  94     }
  95     return p;
  96 }
  97
  98 _LIBCPP_WEAK
  99 void*
 100 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
 101 {
 102     void* p = 0;
 103 #ifndef _LIBCPP_NO_EXCEPTIONS
 104     try
 105     {
 106 #endif  // _LIBCPP_NO_EXCEPTIONS
 107         p = ::operator new(size);
 108 #ifndef _LIBCPP_NO_EXCEPTIONS
 109     }
 110     catch (...)
 111     {
 112     }
 113 #endif  // _LIBCPP_NO_EXCEPTIONS
 114     return p;
 115 }
 116
 117 _LIBCPP_WEAK
 118 void*
 119 operator new(size_t size, std::align_val_t alignment, 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, alignment);
 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 new[](size_t size) _THROW_BAD_ALLOC
 139 {
 140     return ::operator new(size);
 141 }
 142
 143 _LIBCPP_WEAK
 144 void*
 145 operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
 146 {
 147     return ::operator new(size, alignment);
 148 }
 149
 150 _LIBCPP_WEAK
 151 void*
 152 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
 153 {
 154     void* p = 0;
 155 #ifndef _LIBCPP_NO_EXCEPTIONS
 156     try
 157     {
 158 #endif  // _LIBCPP_NO_EXCEPTIONS
 159         p = ::operator new[](size);
 160 #ifndef _LIBCPP_NO_EXCEPTIONS
 161     }
 162     catch (...)
 163     {
 164     }
 165 #endif  // _LIBCPP_NO_EXCEPTIONS
 166     return p;
 167 }
 168
 169 _LIBCPP_WEAK
 170 void*
 171 operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 172 {
 173     void* p = 0;
 174 #ifndef _LIBCPP_NO_EXCEPTIONS
 175     try
 176     {
 177 #endif  // _LIBCPP_NO_EXCEPTIONS
 178         p = ::operator new[](size, alignment);
 179 #ifndef _LIBCPP_NO_EXCEPTIONS
 180     }
 181     catch (...)
 182     {
 183     }
 184 #endif  // _LIBCPP_NO_EXCEPTIONS
 185     return p;
 186 }
 187
 188 _LIBCPP_WEAK
 189 void
 190 operator delete(void* ptr) _NOEXCEPT
 191 {
 192     if (ptr)
 193         ::free(ptr);
 194 }
 195
 196 _LIBCPP_WEAK
 197 void
 198 operator delete(void* ptr, std::align_val_t) _NOEXCEPT
 199 {
 200     if (ptr)
 201 #if defined(_LIBCPP_MSVCRT)
 202         ::_aligned_free(ptr);
 203 #else
 204         ::free(ptr);
 205 #endif
 206 }
 207
 208 _LIBCPP_WEAK
 209 void
 210 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 211 {
 212     ::operator delete(ptr);
 213 }
 214
 215 _LIBCPP_WEAK
 216 void
 217 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 218 {
 219     ::operator delete(ptr, alignment);
 220 }
 221
 222 _LIBCPP_WEAK
 223 void
 224 operator delete(void* ptr, size_t) _NOEXCEPT
 225 {
 226     ::operator delete(ptr);
 227 }
 228
 229 _LIBCPP_WEAK
 230 void
 231 operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 232 {
 233     ::operator delete(ptr, alignment);
 234 }
 235
 236 _LIBCPP_WEAK
 237 void
 238 operator delete[] (void* ptr) _NOEXCEPT
 239 {
 240     ::operator delete(ptr);
 241 }
 242
 243 _LIBCPP_WEAK
 244 void
 245 operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
 246 {
 247     ::operator delete(ptr, alignment);
 248 }
 249
 250 _LIBCPP_WEAK
 251 void
 252 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 253 {
 254     ::operator delete[](ptr);
 255 }
 256
 257 _LIBCPP_WEAK
 258 void
 259 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 260 {
 261     ::operator delete[](ptr, alignment);
 262 }
 263
 264 _LIBCPP_WEAK
 265 void
 266 operator delete[] (void* ptr, size_t) _NOEXCEPT
 267 {
 268     ::operator delete[](ptr);
 269 }
 270
 271 _LIBCPP_WEAK
 272 void
 273 operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 274 {
 275     ::operator delete[](ptr, alignment);
 276 }
 277
 278 #endif // !__GLIBCXX__
 279
 280 namespace std
 281 {
 282
 283 #ifndef __GLIBCXX__
 284 const nothrow_t nothrow = {};
 285 #endif
 286
 287 #ifndef _LIBCPPABI_VERSION
 288
 289 #ifndef __GLIBCXX__
 290
 291 new_handler
 292 set_new_handler(new_handler handler) _NOEXCEPT
 293 {
 294     return __sync_lock_test_and_set(&__new_handler, handler);
 295 }
 296
 297 new_handler
 298 get_new_handler() _NOEXCEPT
 299 {
 300     return __sync_fetch_and_add(&__new_handler, nullptr);
 301 }
 302
 303 #endif // !__GLIBCXX__
 304
 305 #ifndef LIBCXXRT
 306
 307 bad_alloc::bad_alloc() _NOEXCEPT
 308 {
 309 }
 310
 311 #ifndef __GLIBCXX__
 312
 313 bad_alloc::~bad_alloc() _NOEXCEPT
 314 {
 315 }
 316
 317 const char*
 318 bad_alloc::what() const _NOEXCEPT
 319 {
 320     return "std::bad_alloc";
 321 }
 322
 323 #endif // !__GLIBCXX__
 324
 325 bad_array_new_length::bad_array_new_length() _NOEXCEPT
 326 {
 327 }
 328
 329 #ifndef __GLIBCXX__
 330
 331 bad_array_new_length::~bad_array_new_length() _NOEXCEPT
 332 {
 333 }
 334
 335 const char*
 336 bad_array_new_length::what() const _NOEXCEPT
 337 {
 338     return "bad_array_new_length";
 339 }
 340
 341 #endif // !__GLIBCXX__
 342
 343 #endif //LIBCXXRT
 344
 345 bad_array_length::bad_array_length() _NOEXCEPT
 346 {
 347 }
 348
 349 #ifndef __GLIBCXX__
 350
 351 bad_array_length::~bad_array_length() _NOEXCEPT
 352 {
 353 }
 354
 355 const char*
 356 bad_array_length::what() const _NOEXCEPT
 357 {
 358     return "bad_array_length";
 359 }
 360
 361 #endif // !__GLIBCXX__
 362
 363 #endif // _LIBCPPABI_VERSION
 364
 365 #ifndef LIBSTDCXX
 366
 367 void
 368 __throw_bad_alloc()
 369 {
 370 #ifndef _LIBCPP_NO_EXCEPTIONS
 371     throw bad_alloc();
 372 #else
 373     _VSTD::abort();
 374 #endif
 375 }
 376
 377 #endif // !LIBSTDCXX
 378
 379 }  // std