external/bsd/libc++/dist/libcxx/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 #ifndef __has_include
  17 #define __has_include(inc) 0
  18 #endif
  19
  20 #ifdef __APPLE__
  21     #include <cxxabi.h>
  22
  23     #ifndef _LIBCPPABI_VERSION
  24         // On Darwin, there are two STL shared libraries and a lower level ABI
  25         // shared library.  The global holding the current new handler is
  26         // in the ABI library and named __cxa_new_handler.
  27         #define __new_handler __cxxabiapple::__cxa_new_handler
  28     #endif
  29 #else  // __APPLE__
  30     #if defined(LIBCXXRT) || __has_include(<cxxabi.h>)
  31         #include <cxxabi.h>
  32     #endif  // __has_include(<cxxabi.h>)
  33     #if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
  34         static std::new_handler __new_handler;
  35     #endif  // _LIBCPPABI_VERSION
  36 #endif
  37
  38 #ifndef __GLIBCXX__
  39
  40 // Implement all new and delete operators as weak definitions
  41 // in this shared library, so that they can be overriden by programs
  42 // that define non-weak copies of the functions.
  43
  44 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
  45 void *
  46 operator new(std::size_t size)
  47 #if !__has_feature(cxx_noexcept)
  48     throw(std::bad_alloc)
  49 #endif
  50 {
  51     if (size == 0)
  52         size = 1;
  53     void* p;
  54     while ((p = ::malloc(size)) == 0)
  55     {
  56         // If malloc fails and there is a new_handler,
  57         // call it to try free up memory.
  58         std::new_handler nh = std::get_new_handler();
  59         if (nh)
  60             nh();
  61         else
  62 #ifndef _LIBCPP_NO_EXCEPTIONS
  63             throw std::bad_alloc();
  64 #else
  65             break;
  66 #endif
  67     }
  68     return p;
  69 }
  70
  71 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
  72 void*
  73 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
  74 {
  75     void* p = 0;
  76 #ifndef _LIBCPP_NO_EXCEPTIONS
  77     try
  78     {
  79 #endif  // _LIBCPP_NO_EXCEPTIONS
  80         p = ::operator new(size);
  81 #ifndef _LIBCPP_NO_EXCEPTIONS
  82     }
  83     catch (...)
  84     {
  85     }
  86 #endif  // _LIBCPP_NO_EXCEPTIONS
  87     return p;
  88 }
  89
  90 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
  91 void*
  92 operator new[](size_t size)
  93 #if !__has_feature(cxx_noexcept)
  94     throw(std::bad_alloc)
  95 #endif
  96 {
  97     return ::operator new(size);
  98 }
  99
 100 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 101 void*
 102 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
 103 {
 104     void* p = 0;
 105 #ifndef _LIBCPP_NO_EXCEPTIONS
 106     try
 107     {
 108 #endif  // _LIBCPP_NO_EXCEPTIONS
 109         p = ::operator new[](size);
 110 #ifndef _LIBCPP_NO_EXCEPTIONS
 111     }
 112     catch (...)
 113     {
 114     }
 115 #endif  // _LIBCPP_NO_EXCEPTIONS
 116     return p;
 117 }
 118
 119 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 120 void
 121 operator delete(void* ptr) _NOEXCEPT
 122 {
 123     if (ptr)
 124         ::free(ptr);
 125 }
 126
 127 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 128 void
 129 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 130 {
 131     ::operator delete(ptr);
 132 }
 133
 134 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 135 void
 136 operator delete[] (void* ptr) _NOEXCEPT
 137 {
 138     ::operator delete (ptr);
 139 }
 140
 141 _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
 142 void
 143 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 144 {
 145     ::operator delete[](ptr);
 146 }
 147
 148 #endif // !__GLIBCXX__
 149
 150 namespace std
 151 {
 152
 153 #ifndef __GLIBCXX__
 154 const nothrow_t nothrow = {};
 155 #endif
 156
 157 #ifndef _LIBCPPABI_VERSION
 158
 159 #ifndef __GLIBCXX__
 160
 161 new_handler
 162 set_new_handler(new_handler handler) _NOEXCEPT
 163 {
 164     return __sync_lock_test_and_set(&__new_handler, handler);
 165 }
 166
 167 new_handler
 168 get_new_handler() _NOEXCEPT
 169 {
 170     return __sync_fetch_and_add(&__new_handler, (new_handler)0);
 171 }
 172
 173 #endif // !__GLIBCXX__
 174
 175 #ifndef LIBCXXRT
 176
 177 bad_alloc::bad_alloc() _NOEXCEPT
 178 {
 179 }
 180
 181 #ifndef __GLIBCXX__
 182
 183 bad_alloc::~bad_alloc() _NOEXCEPT
 184 {
 185 }
 186
 187 const char*
 188 bad_alloc::what() const _NOEXCEPT
 189 {
 190     return "std::bad_alloc";
 191 }
 192
 193 #endif // !__GLIBCXX__
 194
 195 #endif //LIBCXXRT
 196
 197 bad_array_new_length::bad_array_new_length() _NOEXCEPT
 198 {
 199 }
 200
 201 bad_array_new_length::~bad_array_new_length() _NOEXCEPT
 202 {
 203 }
 204
 205 const char*
 206 bad_array_length::what() const _NOEXCEPT
 207 {
 208     return "bad_array_length";
 209 }
 210
 211 bad_array_length::bad_array_length() _NOEXCEPT
 212 {
 213 }
 214
 215 bad_array_length::~bad_array_length() _NOEXCEPT
 216 {
 217 }
 218
 219 const char*
 220 bad_array_new_length::what() const _NOEXCEPT
 221 {
 222     return "bad_array_new_length";
 223 }
 224
 225 #endif // _LIBCPPABI_VERSION
 226
 227 #ifndef LIBSTDCXX
 228
 229 void
 230 __throw_bad_alloc()
 231 {
 232 #ifndef _LIBCPP_NO_EXCEPTIONS
 233     throw bad_alloc();
 234 #endif
 235 }
 236
 237 #endif // !LIBSTDCXX
 238
 239 }  // std