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         ::free(ptr);
 202 }
 203
 204 _LIBCPP_WEAK
 205 void
 206 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 207 {
 208     ::operator delete(ptr);
 209 }
 210
 211 _LIBCPP_WEAK
 212 void
 213 operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 214 {
 215     ::operator delete(ptr, alignment);
 216 }
 217
 218 _LIBCPP_WEAK
 219 void
 220 operator delete(void* ptr, size_t) _NOEXCEPT
 221 {
 222     ::operator delete(ptr);
 223 }
 224
 225 _LIBCPP_WEAK
 226 void
 227 operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 228 {
 229     ::operator delete(ptr, alignment);
 230 }
 231
 232 _LIBCPP_WEAK
 233 void
 234 operator delete[] (void* ptr) _NOEXCEPT
 235 {
 236     ::operator delete(ptr);
 237 }
 238
 239 _LIBCPP_WEAK
 240 void
 241 operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT
 242 {
 243     ::operator delete(ptr, alignment);
 244 }
 245
 246 _LIBCPP_WEAK
 247 void
 248 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 249 {
 250     ::operator delete[](ptr);
 251 }
 252
 253 _LIBCPP_WEAK
 254 void
 255 operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT
 256 {
 257     ::operator delete[](ptr, alignment);
 258 }
 259
 260 _LIBCPP_WEAK
 261 void
 262 operator delete[] (void* ptr, size_t) _NOEXCEPT
 263 {
 264     ::operator delete[](ptr);
 265 }
 266
 267 _LIBCPP_WEAK
 268 void
 269 operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 270 {
 271     ::operator delete[](ptr, alignment);
 272 }
 273
 274 #endif // !__GLIBCXX__
 275
 276 namespace std
 277 {
 278
 279 #ifndef __GLIBCXX__
 280 const nothrow_t nothrow = {};
 281 #endif
 282
 283 #ifndef _LIBCPPABI_VERSION
 284
 285 #ifndef __GLIBCXX__
 286
 287 new_handler
 288 set_new_handler(new_handler handler) _NOEXCEPT
 289 {
 290     return __sync_lock_test_and_set(&__new_handler, handler);
 291 }
 292
 293 new_handler
 294 get_new_handler() _NOEXCEPT
 295 {
 296     return __sync_fetch_and_add(&__new_handler, nullptr);
 297 }
 298
 299 #endif // !__GLIBCXX__
 300
 301 #ifndef LIBCXXRT
 302
 303 bad_alloc::bad_alloc() _NOEXCEPT
 304 {
 305 }
 306
 307 #ifndef __GLIBCXX__
 308
 309 bad_alloc::~bad_alloc() _NOEXCEPT
 310 {
 311 }
 312
 313 const char*
 314 bad_alloc::what() const _NOEXCEPT
 315 {
 316     return "std::bad_alloc";
 317 }
 318
 319 #endif // !__GLIBCXX__
 320
 321 bad_array_new_length::bad_array_new_length() _NOEXCEPT
 322 {
 323 }
 324
 325 #ifndef __GLIBCXX__
 326
 327 bad_array_new_length::~bad_array_new_length() _NOEXCEPT
 328 {
 329 }
 330
 331 const char*
 332 bad_array_new_length::what() const _NOEXCEPT
 333 {
 334     return "bad_array_new_length";
 335 }
 336
 337 #endif // !__GLIBCXX__
 338
 339 #endif //LIBCXXRT
 340
 341 bad_array_length::bad_array_length() _NOEXCEPT
 342 {
 343 }
 344
 345 #ifndef __GLIBCXX__
 346
 347 bad_array_length::~bad_array_length() _NOEXCEPT
 348 {
 349 }
 350
 351 const char*
 352 bad_array_length::what() const _NOEXCEPT
 353 {
 354     return "bad_array_length";
 355 }
 356
 357 #endif // !__GLIBCXX__
 358
 359 #endif // _LIBCPPABI_VERSION
 360
 361 #ifndef LIBSTDCXX
 362
 363 void
 364 __throw_bad_alloc()
 365 {
 366 #ifndef _LIBCPP_NO_EXCEPTIONS
 367     throw bad_alloc();
 368 #else
 369     _VSTD::abort();
 370 #endif
 371 }
 372
 373 #endif // !LIBSTDCXX
 374
 375 }  // std