Index: src/stdlib_new_delete.cpp =================================================================== --- src/stdlib_new_delete.cpp +++ src/stdlib_new_delete.cpp @@ -1,4 +1,4 @@ -//===------------------------ cxa_new_delete.cpp --------------------------===// +//===--------------------- stdlib_new_delete.cpp --------------------------===// // // The LLVM Compiler Infrastructure // @@ -10,33 +10,19 @@ //===----------------------------------------------------------------------===// #define _LIBCPP_BUILDING_NEW - +#define _LIBCPP_BUILDING_LIBRARY #include "__cxxabi_config.h" #include #include -#if !defined(_THROW_BAD_ALLOC) || !defined(_NOEXCEPT) -#error _THROW_BAD_ALLOC and _NOEXCEPT libc++ macros must already be defined \ - by libc++. +#if !defined(_THROW_BAD_ALLOC) || !defined(_NOEXCEPT) || !defined(_LIBCXXABI_WEAK) +#error The _THROW_BAD_ALLOC, _NOEXCEPT, and _LIBCXXABI_WEAK libc++ macros must \ + already be defined by libc++. #endif +// Implement all new and delete operators as weak definitions +// in this shared library, so that they can be overridden by programs +// that define non-weak copies of the functions. -/* -[new.delete.single] - -* Executes a loop: Within the loop, the function first attempts to allocate - the requested storage. Whether the attempt involves a call to the Standard C - library function malloc is unspecified. - -* Returns a pointer to the allocated storage if the attempt is successful. - Otherwise, if the current new_handler (18.6.2.5) is a null pointer value, - throws bad_alloc. - -* Otherwise, the function calls the current new_handler function (18.6.2.3). - If the called function returns, the loop repeats. - -* The loop terminates when an attempt to allocate the requested storage is - successful or when a called new_handler function does not return. -*/ _LIBCXXABI_WEAK void * operator new(std::size_t size) _THROW_BAD_ALLOC @@ -44,8 +30,10 @@ if (size == 0) size = 1; void* p; - while ((p = std::malloc(size)) == 0) + while ((p = ::malloc(size)) == 0) { + // If malloc fails and there is a new_handler, + // call it to try free up memory. std::new_handler nh = std::get_new_handler(); if (nh) nh(); @@ -59,18 +47,6 @@ return p; } -/* -Note: The relationships among these operators is both carefully considered -and standard in C++11. Please do not change them without fully understanding -the consequences of doing so. Reference: -http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2158.html -*/ -/* -[new.delete.single] - -Calls operator new(size). If the call returns normally, returns the result of -that call. Otherwise, returns a null pointer. -*/ _LIBCXXABI_WEAK void* operator new(size_t size, const std::nothrow_t&) _NOEXCEPT @@ -79,22 +55,17 @@ #ifndef _LIBCXXABI_NO_EXCEPTIONS try { -#endif +#endif // _LIBCXXABI_NO_EXCEPTIONS p = ::operator new(size); #ifndef _LIBCXXABI_NO_EXCEPTIONS } catch (...) { } -#endif +#endif // _LIBCXXABI_NO_EXCEPTIONS return p; } -/* -[new.delete.array] - -Returns operator new(size). -*/ _LIBCXXABI_WEAK void* operator new[](size_t size) _THROW_BAD_ALLOC @@ -102,12 +73,6 @@ return ::operator new(size); } -/* -[new.delete.array] - -Calls operator new[](size). If the call returns normally, returns the result -of that call. Otherwise, returns a null pointer. -*/ _LIBCXXABI_WEAK void* operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT @@ -116,36 +81,25 @@ #ifndef _LIBCXXABI_NO_EXCEPTIONS try { -#endif +#endif // _LIBCXXABI_NO_EXCEPTIONS p = ::operator new[](size); #ifndef _LIBCXXABI_NO_EXCEPTIONS } catch (...) { } -#endif +#endif // _LIBCXXABI_NO_EXCEPTIONS return p; } -/* -[new.delete.single] - -If ptr is null, does nothing. Otherwise, reclaims the storage allocated by the -earlier call to operator new. -*/ _LIBCXXABI_WEAK void operator delete(void* ptr) _NOEXCEPT { if (ptr) - std::free(ptr); + ::free(ptr); } -/* -[new.delete.single] - -calls operator delete(ptr) -*/ _LIBCXXABI_WEAK void operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT @@ -153,11 +107,13 @@ ::operator delete(ptr); } -/* -[new.delete.array] +_LIBCXXABI_WEAK +void +operator delete(void* ptr, size_t) _NOEXCEPT +{ + ::operator delete(ptr); +} -Calls operator delete(ptr) -*/ _LIBCXXABI_WEAK void operator delete[] (void* ptr) _NOEXCEPT @@ -165,14 +121,144 @@ ::operator delete(ptr); } -/* -[new.delete.array] - -calls operator delete[](ptr) -*/ _LIBCXXABI_WEAK void operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT { ::operator delete[](ptr); } + +_LIBCXXABI_WEAK +void +operator delete[] (void* ptr, size_t) _NOEXCEPT +{ + ::operator delete[](ptr); +} + +#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) + +_LIBCXXABI_WEAK +void * +operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC +{ + if (size == 0) + size = 1; + if (static_cast(alignment) < sizeof(void*)) + alignment = std::align_val_t(sizeof(void*)); + void* p; +#if defined(_LIBCPP_MSVCRT) + while ((p = _aligned_malloc(size, static_cast(alignment))) == nullptr) +#else + while (::posix_memalign(&p, static_cast(alignment), size) != 0) +#endif + { + // If posix_memalign fails and there is a new_handler, + // call it to try free up memory. + std::new_handler nh = std::get_new_handler(); + if (nh) + nh(); + else { +#ifndef _LIBCXXABI_NO_EXCEPTIONS + throw std::bad_alloc(); +#else + p = nullptr; // posix_memalign doesn't initialize 'p' on failure + break; +#endif + } + } + return p; +} + +_LIBCXXABI_WEAK +void* +operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT +{ + void* p = 0; +#ifndef _LIBCXXABI_NO_EXCEPTIONS + try + { +#endif // _LIBCXXABI_NO_EXCEPTIONS + p = ::operator new(size, alignment); +#ifndef _LIBCXXABI_NO_EXCEPTIONS + } + catch (...) + { + } +#endif // _LIBCXXABI_NO_EXCEPTIONS + return p; +} + +_LIBCXXABI_WEAK +void* +operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC +{ + return ::operator new(size, alignment); +} + +_LIBCXXABI_WEAK +void* +operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT +{ + void* p = 0; +#ifndef _LIBCXXABI_NO_EXCEPTIONS + try + { +#endif // _LIBCXXABI_NO_EXCEPTIONS + p = ::operator new[](size, alignment); +#ifndef _LIBCXXABI_NO_EXCEPTIONS + } + catch (...) + { + } +#endif // _LIBCXXABI_NO_EXCEPTIONS + return p; +} + +_LIBCXXABI_WEAK +void +operator delete(void* ptr, std::align_val_t) _NOEXCEPT +{ + if (ptr) +#if defined(_LIBCPP_MSVCRT) + ::_aligned_free(ptr); +#else + ::free(ptr); +#endif +} + +_LIBCXXABI_WEAK +void +operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT +{ + ::operator delete(ptr, alignment); +} + +_LIBCXXABI_WEAK +void +operator delete(void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT +{ + ::operator delete(ptr, alignment); +} + +_LIBCXXABI_WEAK +void +operator delete[] (void* ptr, std::align_val_t alignment) _NOEXCEPT +{ + ::operator delete(ptr, alignment); +} + +_LIBCXXABI_WEAK +void +operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) _NOEXCEPT +{ + ::operator delete[](ptr, alignment); +} + +_LIBCXXABI_WEAK +void +operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT +{ + ::operator delete[](ptr, alignment); +} + +#endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION