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
45void *
46operator 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
72void*
73operator 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
91void*
92operator 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
101void*
102operator 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
120void
121operator delete(void* ptr) _NOEXCEPT
122{
123    if (ptr)
124        ::free(ptr);
125}
126
127_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
128void
129operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
130{
131    ::operator delete(ptr);
132}
133
134_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
135void
136operator delete[] (void* ptr) _NOEXCEPT
137{
138    ::operator delete (ptr);
139}
140
141_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS
142void
143operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
144{
145    ::operator delete[](ptr);
146}
147
148#endif // !__GLIBCXX__
149
150namespace std
151{
152
153#ifndef __GLIBCXX__
154const nothrow_t nothrow = {};
155#endif
156
157#ifndef _LIBCPPABI_VERSION
158
159#ifndef __GLIBCXX__
160
161new_handler
162set_new_handler(new_handler handler) _NOEXCEPT
163{
164    return __sync_lock_test_and_set(&__new_handler, handler);
165}
166
167new_handler
168get_new_handler() _NOEXCEPT
169{
170    return __sync_fetch_and_add(&__new_handler, nullptr);
171}
172
173#endif // !__GLIBCXX__
174
175#ifndef LIBCXXRT
176
177bad_alloc::bad_alloc() _NOEXCEPT
178{
179}
180
181#ifndef __GLIBCXX__
182
183bad_alloc::~bad_alloc() _NOEXCEPT
184{
185}
186
187const char*
188bad_alloc::what() const _NOEXCEPT
189{
190    return "std::bad_alloc";
191}
192
193#endif // !__GLIBCXX__
194
195#endif //LIBCXXRT
196
197bad_array_new_length::bad_array_new_length() _NOEXCEPT
198{
199}
200
201bad_array_new_length::~bad_array_new_length() _NOEXCEPT
202{
203}
204
205const char*
206bad_array_length::what() const _NOEXCEPT
207{
208    return "bad_array_length";
209}
210
211bad_array_length::bad_array_length() _NOEXCEPT
212{
213}
214
215bad_array_length::~bad_array_length() _NOEXCEPT
216{
217}
218
219const char*
220bad_array_new_length::what() const _NOEXCEPT
221{
222    return "bad_array_new_length";
223}
224
225#endif // _LIBCPPABI_VERSION
226
227#ifndef LIBSTDCXX
228
229void
230__throw_bad_alloc()
231{
232#ifndef _LIBCPP_NO_EXCEPTIONS
233    throw bad_alloc();
234#endif
235}
236
237#endif // !LIBSTDCXX
238
239}  // std
240