1//===----------------------------------------------------------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include <new> 10#include <stdlib.h> 11 12#include "include/atomic_support.h" 13 14#if defined(_LIBCPP_ABI_MICROSOFT) 15# if !defined(_LIBCPP_ABI_VCRUNTIME) 16# include "support/runtime/new_handler_fallback.ipp" 17# endif 18#elif defined(LIBCXX_BUILDING_LIBCXXABI) 19# include <cxxabi.h> 20#elif defined(LIBCXXRT) 21# include <cxxabi.h> 22# include "support/runtime/new_handler_fallback.ipp" 23#elif defined(__GLIBCXX__) 24 // nothing to do 25#else 26# include "support/runtime/new_handler_fallback.ipp" 27#endif 28 29namespace std 30{ 31 32#ifndef __GLIBCXX__ 33const nothrow_t nothrow{}; 34#endif 35 36#ifndef LIBSTDCXX 37 38void 39__throw_bad_alloc() 40{ 41#ifndef _LIBCPP_NO_EXCEPTIONS 42 throw bad_alloc(); 43#else 44 _VSTD::abort(); 45#endif 46} 47 48#endif // !LIBSTDCXX 49 50} // std 51 52#if !defined(__GLIBCXX__) && \ 53 !defined(_LIBCPP_ABI_VCRUNTIME) && \ 54 !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS) 55 56// Implement all new and delete operators as weak definitions 57// in this shared library, so that they can be overridden by programs 58// that define non-weak copies of the functions. 59 60_LIBCPP_WEAK 61void * 62operator new(std::size_t size) _THROW_BAD_ALLOC 63{ 64 if (size == 0) 65 size = 1; 66 void* p; 67 while ((p = ::malloc(size)) == nullptr) 68 { 69 // If malloc fails and there is a new_handler, 70 // call it to try free up memory. 71 std::new_handler nh = std::get_new_handler(); 72 if (nh) 73 nh(); 74 else 75#ifndef _LIBCPP_NO_EXCEPTIONS 76 throw std::bad_alloc(); 77#else 78 break; 79#endif 80 } 81 return p; 82} 83 84_LIBCPP_WEAK 85void* 86operator new(size_t size, const std::nothrow_t&) noexcept 87{ 88 void* p = nullptr; 89#ifndef _LIBCPP_NO_EXCEPTIONS 90 try 91 { 92#endif // _LIBCPP_NO_EXCEPTIONS 93 p = ::operator new(size); 94#ifndef _LIBCPP_NO_EXCEPTIONS 95 } 96 catch (...) 97 { 98 } 99#endif // _LIBCPP_NO_EXCEPTIONS 100 return p; 101} 102 103_LIBCPP_WEAK 104void* 105operator new[](size_t size) _THROW_BAD_ALLOC 106{ 107 return ::operator new(size); 108} 109 110_LIBCPP_WEAK 111void* 112operator new[](size_t size, const std::nothrow_t&) noexcept 113{ 114 void* p = nullptr; 115#ifndef _LIBCPP_NO_EXCEPTIONS 116 try 117 { 118#endif // _LIBCPP_NO_EXCEPTIONS 119 p = ::operator new[](size); 120#ifndef _LIBCPP_NO_EXCEPTIONS 121 } 122 catch (...) 123 { 124 } 125#endif // _LIBCPP_NO_EXCEPTIONS 126 return p; 127} 128 129_LIBCPP_WEAK 130void 131operator delete(void* ptr) noexcept 132{ 133 ::free(ptr); 134} 135 136_LIBCPP_WEAK 137void 138operator delete(void* ptr, const std::nothrow_t&) noexcept 139{ 140 ::operator delete(ptr); 141} 142 143_LIBCPP_WEAK 144void 145operator delete(void* ptr, size_t) noexcept 146{ 147 ::operator delete(ptr); 148} 149 150_LIBCPP_WEAK 151void 152operator delete[] (void* ptr) noexcept 153{ 154 ::operator delete(ptr); 155} 156 157_LIBCPP_WEAK 158void 159operator delete[] (void* ptr, const std::nothrow_t&) noexcept 160{ 161 ::operator delete[](ptr); 162} 163 164_LIBCPP_WEAK 165void 166operator delete[] (void* ptr, size_t) noexcept 167{ 168 ::operator delete[](ptr); 169} 170 171#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) 172 173_LIBCPP_WEAK 174void * 175operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 176{ 177 if (size == 0) 178 size = 1; 179 if (static_cast<size_t>(alignment) < sizeof(void*)) 180 alignment = std::align_val_t(sizeof(void*)); 181 182 // Try allocating memory. If allocation fails and there is a new_handler, 183 // call it to try free up memory, and try again until it succeeds, or until 184 // the new_handler decides to terminate. 185 // 186 // If allocation fails and there is no new_handler, we throw bad_alloc 187 // (or return nullptr if exceptions are disabled). 188 void* p; 189 while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr) 190 { 191 std::new_handler nh = std::get_new_handler(); 192 if (nh) 193 nh(); 194 else { 195#ifndef _LIBCPP_NO_EXCEPTIONS 196 throw std::bad_alloc(); 197#else 198 break; 199#endif 200 } 201 } 202 return p; 203} 204 205_LIBCPP_WEAK 206void* 207operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept 208{ 209 void* p = nullptr; 210#ifndef _LIBCPP_NO_EXCEPTIONS 211 try 212 { 213#endif // _LIBCPP_NO_EXCEPTIONS 214 p = ::operator new(size, alignment); 215#ifndef _LIBCPP_NO_EXCEPTIONS 216 } 217 catch (...) 218 { 219 } 220#endif // _LIBCPP_NO_EXCEPTIONS 221 return p; 222} 223 224_LIBCPP_WEAK 225void* 226operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC 227{ 228 return ::operator new(size, alignment); 229} 230 231_LIBCPP_WEAK 232void* 233operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept 234{ 235 void* p = nullptr; 236#ifndef _LIBCPP_NO_EXCEPTIONS 237 try 238 { 239#endif // _LIBCPP_NO_EXCEPTIONS 240 p = ::operator new[](size, alignment); 241#ifndef _LIBCPP_NO_EXCEPTIONS 242 } 243 catch (...) 244 { 245 } 246#endif // _LIBCPP_NO_EXCEPTIONS 247 return p; 248} 249 250_LIBCPP_WEAK 251void 252operator delete(void* ptr, std::align_val_t) noexcept 253{ 254 std::__libcpp_aligned_free(ptr); 255} 256 257_LIBCPP_WEAK 258void 259operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept 260{ 261 ::operator delete(ptr, alignment); 262} 263 264_LIBCPP_WEAK 265void 266operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept 267{ 268 ::operator delete(ptr, alignment); 269} 270 271_LIBCPP_WEAK 272void 273operator delete[] (void* ptr, std::align_val_t alignment) noexcept 274{ 275 ::operator delete(ptr, alignment); 276} 277 278_LIBCPP_WEAK 279void 280operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept 281{ 282 ::operator delete[](ptr, alignment); 283} 284 285_LIBCPP_WEAK 286void 287operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept 288{ 289 ::operator delete[](ptr, alignment); 290} 291 292#endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION 293#endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS 294