[libc++]Use __libcpp_malloc/__libcpp_calloc in places of malloc/calloc

[xingxue]

Summary

AIX system header <stdlib.h> maps system calls malloc and calloc to vec_malloc and vec_calloc under macro __VEC__ which is pre-defined by compiler when the target architecture supports Altivec. vec_malloc/vec_calloc give 16-byte aligned allocation and as a result, greatly increase the heap memory consumption if an application makes a large number of small heap allocations. This causes existing applications built with certain heap size to run out of memory unexpectedly when running against a newer version of libc++/libc++abi built with __VEC__ defined (on AIX, linker option -bmaxdata is used to specify the maximum size of user data area). For example, an application usually malloc()s 1.5GB heap memory through the new operator out of 40M allocations but it allocates more than 2GB when running against the newer libc++abi.

To mitigate this issue, this patch defines __libcpp_malloc()/__libcpp_calloc() that are true malloc()/calloc() and use them in libc++ and libc++abi implementations in places of the plain malloc()/calloc(} where a specific alignment is not required. For AIX, __libcpp_malloc()/__libcpp_calloc() map to assembly label malloc/calloc. For other platforms, they are function macros mapping to malloc/calloc. Functions std::malloc()/std::calloc() are not changed to maintain the original AIX semantic, i.e., they are mapped to vec_malloc()/vec_calloc() if macro __VEC__ is defined.

Calls to malloc()/calloc() in libunwind are used for DWARF based unwinding. Since AIX uses the traceback table based unwinding and the code for DWARF based unwinding is compiled out, the code in libunwind is not changed.

[xingxue]

Addressed issues in pre-merge check.

[ldionne]

I don't understand the problem statement. Doesn't malloc and calloc always align stuff at 16 bytes? https://godbolt.org/z/oor5KaedP

[xingxue]

In D112168#3079369, @ldionne wrote:

I don't understand the problem statement. Doesn't malloc and calloc always align stuff at 16 bytes? https://godbolt.org/z/oor5KaedP

The malloc and calloc of the AIX libc do not always align at 16 bytes.

$ cat malloc.c
#include <stdlib.h>
#include <stdio.h>

int main()
{
  char *ptr=malloc(8);
  char *vec_ptr=vec_malloc(8);
  printf("ptr=0x%p, vec_ptr=0x%p\n", ptr, vec_ptr);
}
$ xlc malloc.c
$ a.out
ptr=0x200005b8, vec_ptr=0x200005d0

[xingxue]

The code block mapping malloc/calloc to vec_malloc/vec_calloc in AIX header stdlib.h is enabled by macro _ALL_SOURCE which is defined for building the libc++/libc++abi on AIX. As per discussion, we think it is a good idea not to define it. So, this patch is no longer needed.

libcxx/include/__support/ibm/xlocale.h

unsigned long strtoul_l(const char *__nptr, char **__endptr,
     int __base, locale_t locale) {
   __setAndRestore __newloc(locale);
   return strtoul(__nptr, __endptr, __base);
 }
 
 static inline
 int vasprintf(char **strp, const char *fmt, va_list ap) {
   const size_t buff_size = 256;
-  if ((*strp = (char *)malloc(buff_size)) == NULL) {
+  if ((*strp = (char*)std::__libcpp_malloc(buff_size)) == NULL) {
     return -1;
   }
 
   va_list ap_copy;
   // va_copy may not be provided by the C library in C++ 03 mode.
 #if defined(_LIBCPP_CXX03_LANG) && __has_builtin(__builtin_va_copy)
   __builtin_va_copy(ap_copy, ap);
 #else

libcxx/include/locale

__scan_keyword(_InputIterator& __b, _InputIterator __e,
     const unsigned char __doesnt_match = '\0';
     const unsigned char __might_match = '\1';
     const unsigned char __does_match = '\2';
     unsigned char __statbuf[100];
     unsigned char* __status = __statbuf;
     unique_ptr<unsigned char, void(*)(void*)> __stat_hold(nullptr, free);
     if (__nkw > sizeof(__statbuf))
     {
-        __status = (unsigned char*)malloc(__nkw);
-        if (__status == nullptr)
-            __throw_bad_alloc();
-        __stat_hold.reset(__status);
+      __status = (unsigned char*)std::__libcpp_malloc(__nkw);
     }
     size_t __n_might_match = __nkw;  // At this point, any keyword might match
     size_t __n_does_match = 0;       // but none of them definitely do
     // Initialize all statuses to __might_match, except for "" keywords are __does_match
     unsigned char* __st = __status;
     for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
     {
         if (!__ky->empty())
num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char* __ne = __nb + __nc;
     char* __np = this->__identify_padding(__nb, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __ob = __o;
     unique_ptr<char_type, void(*)(void*)> __obh(0, free);
     if (__nb != __nar)
     {
-        __ob = (char_type*)malloc(2*static_cast<size_t>(__nc)*sizeof(char_type));
-        if (__ob == 0)
-            __throw_bad_alloc();
-        __obh.reset(__ob);
+      __ob = (char_type*)std::__libcpp_malloc(2*static_cast<size_t>(__nc)*sizeof(char_type));
     }
     char_type* __op;  // pad here
     char_type* __oe;  // end of output
     this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
     // [__o, __oe) contains thousands_sep'd wide number
     // Stage 3 & 4
     __s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
     return __s;
num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char* __ne = __nb + __nc;
     char* __np = this->__identify_padding(__nb, __ne, __iob);
     // Stage 2 - Widen __nar while adding thousands separators
     char_type __o[2*(__nbuf-1) - 1];
     char_type* __ob = __o;
     unique_ptr<char_type, void(*)(void*)> __obh(0, free);
     if (__nb != __nar)
     {
-        __ob = (char_type*)malloc(2*static_cast<size_t>(__nc)*sizeof(char_type));
-        if (__ob == 0)
-            __throw_bad_alloc();
-        __obh.reset(__ob);
+      __ob = (char_type*)std::__libcpp_malloc(2*static_cast<size_t>(__nc)*sizeof(char_type));
     }
     char_type* __op;  // pad here
     char_type* __oe;  // end of output
     this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
     // [__o, __oe) contains thousands_sep'd wide number
     // Stage 3 & 4
     __s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
     return __s;
if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
         const char __src[] = "0123456789";
         char_type __atoms[sizeof(__src)-1];
         __ct.widen(__src, __src + (sizeof(__src)-1), __atoms);
         char __nbuf[__bz];
         char* __nc = __nbuf;
         unique_ptr<char, void(*)(void*)> __h(nullptr, free);
         if (__wn - __wb.get() > __bz-2)
         {
-            __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
-            if (__h.get() == nullptr)
-                __throw_bad_alloc();
-            __nc = __h.get();
+          __h.reset((char*)std::__libcpp_malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
         }
         if (__neg)
             *__nc++ = '-';
         for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
             *__nc = __src[find(__atoms, _VSTD::end(__atoms), *__w) - __atoms];
         *__nc = char();
         if (sscanf(__nbuf, "%Lf", &__v) != 1)
             __throw_runtime_error("money_get error");
money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
     unique_ptr<char_type, void(*)(void*)> __hd(0, free);
     // secure memory for digit storage
     if (static_cast<size_t>(__n) > __bs-1)
     {
         __n = __libcpp_asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
         if (__n == -1)
             __throw_bad_alloc();
         __hn.reset(__bb);
-        __hd.reset((char_type*)malloc(static_cast<size_t>(__n) * sizeof(char_type)));
+        __hd.reset((char_type*)std::__libcpp_malloc(static_cast<size_t>(__n) * sizeof(char_type)));
         if (__hd == nullptr)
             __throw_bad_alloc();
         __db = __hd.get();
     }
     // gather info
     locale __loc = __iob.getloc();
     const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
     __ct.widen(__bb, __bb + __n, __db);
money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
     char_type* __mb = __mbuf;
     unique_ptr<char_type, void(*)(void*)> __hw(0, free);
     size_t __exn = __n > __fd ?
                    (static_cast<size_t>(__n) - static_cast<size_t>(__fd)) * 2 +
                     __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1
                  : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
     if (__exn > __bs)
     {
-        __hw.reset((char_type*)malloc(__exn * sizeof(char_type)));
-        __mb = __hw.get();
-        if (__mb == 0)
-            __throw_bad_alloc();
+      __hw.reset((char_type*)std::__libcpp_malloc(__exn * sizeof(char_type)));
     }
     // format
     char_type* __mi;
     char_type* __me;
     this->__format(__mb, __mi, __me, __iob.flags(),
                    __db, __db + __n, __ct,
                    __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
     return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
     char_type* __mb = __mbuf;
     unique_ptr<char_type, void(*)(void*)> __h(0, free);
     size_t __exn = static_cast<int>(__digits.size()) > __fd ?
                    (__digits.size() - static_cast<size_t>(__fd)) * 2 +
                     __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1
                  : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
     if (__exn > 100)
     {
-        __h.reset((char_type*)malloc(__exn * sizeof(char_type)));
-        __mb = __h.get();
-        if (__mb == 0)
-            __throw_bad_alloc();
+      __h.reset((char_type*)std::__libcpp_malloc(__exn * sizeof(char_type)));
     }
     // format
     char_type* __mi;
     char_type* __me;
     this->__format(__mb, __mi, __me, __iob.flags(),
                    __digits.data(), __digits.data() + __digits.size(), __ct,
                    __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
     return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);

libcxx/include/new

 #if defined(_LIBCPP_MSVCRT_LIKE)
   ::_aligned_free(__ptr);
 #else
   ::free(__ptr);
 #endif
 }
 #endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION
 
+#if defined(_AIX)
+// AIX system header <stdlib.h> maps malloc and calloc to vec_malloc and
+// vec_calloc under macro __VEC__ which is pre-defined by the compiler when
+// the target architecture supports Altivec. The vec_ version always aligns
+// to 16-byte and causes some applications to run out of heap space
+// unexpectedly. Define __libcpp_malloc/__libcpp_calloc and use them in
+// libcxx and libcxxabi in places of the plain malloc/calloc where a
+// specific alignment is not required.
+void* __libcpp_malloc(std::size_t) __asm__("malloc");
+void* __libcpp_calloc(std::size_t, std::size_t) __asm__("calloc");
+#else
+#  define __libcpp_malloc(size) malloc((size))
+#  define __libcpp_calloc(count, size) calloc((count), (size))
+#endif
 
 template <class _Tp>
 _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT
 {
     static_assert (!(is_function<_Tp>::value), "can't launder functions" );
     static_assert (!(is_same<void, typename remove_cv<_Tp>::type>::value), "can't launder cv-void" );
     return __builtin_launder(__p);

libcxx/include/ostream

#endif // _LIBCPP_NO_EXCEPTIONS
             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
             size_t __len = char_traits<char>::length(__strn);
             const int __bs = 100;
             _CharT __wbb[__bs];
             _CharT* __wb = __wbb;
             unique_ptr<_CharT, void(*)(void*)> __h(0, free);
             if (__len > __bs)
             {
-                __wb = (_CharT*)malloc(__len*sizeof(_CharT));
-                if (__wb == 0)
-                    __throw_bad_alloc();
-                __h.reset(__wb);
+              __wb = (_CharT*)std::__libcpp_malloc(__len * sizeof(_CharT));
             }
             for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
                 *__p = __os.widen(*__strn);
             if (__pad_and_output(_Ip(__os),
                                  __wb,
                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
                                      __wb + __len :
                                      __wb,

libcxx/src/debug.cpp

 __libcpp_db::__insert_c(void* __c, __libcpp_db::_InsertConstruct *__fn)
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
     WLock _(mut());
 #endif
     if (__csz_ + 1 > static_cast<size_t>(__cend_ - __cbeg_))
     {
         size_t nc = __next_prime(2*static_cast<size_t>(__cend_ - __cbeg_) + 1);
-        __c_node** cbeg = static_cast<__c_node**>(calloc(nc, sizeof(__c_node*)));
+        __c_node** cbeg = static_cast<__c_node**>(std::__libcpp_calloc(nc, sizeof(__c_node*)));
         if (cbeg == nullptr)
             __throw_bad_alloc();
 
         for (__c_node** p = __cbeg_; p != __cend_; ++p)
         {
             __c_node* q = *p;
             while (q != nullptr)
             {
                 size_t h = hash<void*>()(q->__c_) % nc;
                 __c_node* r = q->__next_;
                 q->__next_ = cbeg[h];
                 cbeg[h] = q;
                 q = r;
             }
         }
         free(__cbeg_);
         __cbeg_ = cbeg;
         __cend_ = __cbeg_ + nc;
     }
     size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
     __c_node* p = __cbeg_[hc];
-    void *buf = malloc(sizeof(__c_node));
+    void* buf = std::__libcpp_malloc(sizeof(__c_node));
     if (buf == nullptr)
       __throw_bad_alloc();
     __cbeg_[hc] = __fn(buf, __c, p);
 
     ++__csz_;
 }
 
 void

 void
 __c_node::__add(__i_node* i)
 {
     if (end_ == cap_)
     {
         size_t nc = 2*static_cast<size_t>(cap_ - beg_);
         if (nc == 0)
             nc = 1;
-        __i_node** beg =
-           static_cast<__i_node**>(malloc(nc * sizeof(__i_node*)));
+        __i_node** beg = static_cast<__i_node**>(std::__libcpp_malloc(nc * sizeof(__i_node*)));
         if (beg == nullptr)
             __throw_bad_alloc();
 
         if (nc > 1)
             memcpy(beg, beg_, nc/2*sizeof(__i_node*));
         free(beg_);
         beg_ = beg;
         end_ = beg_ + nc/2;
         cap_ = beg_ + nc;
     }
     *end_++ = i;
 }
 
 // private api
 
 _LIBCPP_HIDDEN
 __i_node*
 __libcpp_db::__insert_iterator(void* __i)
 {
     if (__isz_ + 1 > static_cast<size_t>(__iend_ - __ibeg_))
     {
         size_t nc = __next_prime(2*static_cast<size_t>(__iend_ - __ibeg_) + 1);
-        __i_node** ibeg = static_cast<__i_node**>(calloc(nc, sizeof(__i_node*)));
+        __i_node** ibeg = static_cast<__i_node**>(std::__libcpp_calloc(nc, sizeof(__i_node*)));
         if (ibeg == nullptr)
             __throw_bad_alloc();
 
         for (__i_node** p = __ibeg_; p != __iend_; ++p)
         {
             __i_node* q = *p;
             while (q != nullptr)
             {
                 size_t h = hash<void*>()(q->__i_) % nc;
                 __i_node* r = q->__next_;
                 q->__next_ = ibeg[h];
                 ibeg[h] = q;
                 q = r;
             }
         }
         free(__ibeg_);
         __ibeg_ = ibeg;
         __iend_ = __ibeg_ + nc;
     }
     size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_);
     __i_node* p = __ibeg_[hi];
-    __i_node* r = __ibeg_[hi] =
-      static_cast<__i_node*>(malloc(sizeof(__i_node)));
+    __i_node* r = __ibeg_[hi] = static_cast<__i_node*>(std::__libcpp_malloc(sizeof(__i_node)));
     if (r == nullptr)
         __throw_bad_alloc();
 
     ::new(r) __i_node(__i, p, nullptr);
     ++__isz_;
     return r;
 }
 

libcxx/src/filesystem/posix_compat.h

wchar_t *realpath(const wchar_t *path, wchar_t *resolved_name) {
 
   WinHandle h(path, FILE_READ_ATTRIBUTES, 0);
   if (!h) {
     set_errno();
     return nullptr;
   }
   size_t buff_size = MAX_PATH + 10;
   std::unique_ptr<wchar_t, decltype(&::free)> buff(
-      static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))), &::free);
+      static_cast<wchar_t*>(std::__libcpp_malloc(buff_size * sizeof(wchar_t))), &::free);
   DWORD retval = GetFinalPathNameByHandleW(
       h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
   if (retval > buff_size) {
     buff_size = retval;
-    buff.reset(static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))));
+    buff.reset(static_cast<wchar_t*>(std::__libcpp_malloc(buff_size * sizeof(wchar_t))));
     retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size,
                                        FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
   }
   if (!retval) {
     set_errno();
     return nullptr;
   }
   wchar_t *ptr = buff.get();

libcxx/src/ios.cpp

ios_base::copyfmt(const ios_base& rhs)
     // Don't alter *this until all needed resources are acquired
     unique_ptr<event_callback, void (*)(void*)> new_callbacks(0, free);
     unique_ptr<int, void (*)(void*)> new_ints(0, free);
     unique_ptr<long, void (*)(void*)> new_longs(0, free);
     unique_ptr<void*, void (*)(void*)> new_pointers(0, free);
     if (__event_cap_ < rhs.__event_size_)
     {
         size_t newesize = sizeof(event_callback) * rhs.__event_size_;
-        new_callbacks.reset(static_cast<event_callback*>(malloc(newesize)));
+        new_callbacks.reset(static_cast<event_callback*>(std::__libcpp_malloc(newesize)));
         if (!new_callbacks)
             __throw_bad_alloc();
 
         size_t newisize = sizeof(int) * rhs.__event_size_;
-        new_ints.reset(static_cast<int *>(malloc(newisize)));
+        new_ints.reset(static_cast<int*>(std::__libcpp_malloc(newisize)));
         if (!new_ints)
             __throw_bad_alloc();
     }
     if (__iarray_cap_ < rhs.__iarray_size_)
     {
         size_t newsize = sizeof(long) * rhs.__iarray_size_;
-        new_longs.reset(static_cast<long*>(malloc(newsize)));
+        new_longs.reset(static_cast<long*>(std::__libcpp_malloc(newsize)));
         if (!new_longs)
             __throw_bad_alloc();
     }
     if (__parray_cap_ < rhs.__parray_size_)
     {
         size_t newsize = sizeof(void*) * rhs.__parray_size_;
-        new_pointers.reset(static_cast<void**>(malloc(newsize)));
+        new_pointers.reset(static_cast<void**>(std::__libcpp_malloc(newsize)));
         if (!new_pointers)
             __throw_bad_alloc();
     }
     // Got everything we need.  Copy everything but __rdstate_, __rdbuf_ and __exceptions_
     __fmtflags_ = rhs.__fmtflags_;
     __precision_ = rhs.__precision_;
     __width_ = rhs.__width_;
     locale& lhs_loc = *reinterpret_cast<locale*>(&__loc_);

libcxx/src/new.cpp

 
 _LIBCPP_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     void* p;
-    while ((p = ::malloc(size)) == nullptr)
-    {
-        // 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();
-        else
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw std::bad_alloc();
-#else
-            break;
-#endif
+    while ((p = std::__libcpp_malloc(size)) == nullptr) {
+#  ifndef _LIBCPP_NO_EXCEPTIONS
+#  else
+#  endif
     }
     return p;
 }
 
 _LIBCPP_WEAK
 void*
 operator new(size_t size, const std::nothrow_t&) noexcept
 {

libcxxabi/src/cxa_demangle.cpp

class BumpPointerAllocator {
 
   static constexpr size_t AllocSize = 4096;
   static constexpr size_t UsableAllocSize = AllocSize - sizeof(BlockMeta);
 
   alignas(long double) char InitialBuffer[AllocSize];
   BlockMeta* BlockList = nullptr;
 
   void grow() {
-    char* NewMeta = static_cast<char *>(std::malloc(AllocSize));
+    char* NewMeta = static_cast<char*>(std::__libcpp_malloc(AllocSize));
     if (NewMeta == nullptr)
       std::terminate();
     BlockList = new (NewMeta) BlockMeta{BlockList, 0};
   }
 
   void* allocateMassive(size_t NBytes) {
     NBytes += sizeof(BlockMeta);
-    BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::malloc(NBytes));
+    BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::__libcpp_malloc(NBytes));
     if (NewMeta == nullptr)
       std::terminate();
     BlockList->Next = new (NewMeta) BlockMeta{BlockList->Next, 0};
     return static_cast<void*>(NewMeta + 1);
   }
 
 public:
   BumpPointerAllocator()

libcxxabi/src/cxa_thread_atexit.cpp

if (__cxa_thread_atexit_impl) {
 
       if (!dtors_alive) {
         if (std::__libcpp_tls_set(dtors_key, &dtors_key) != 0) {
           return -1;
         }
         dtors_alive = true;
       }
 
-      auto head = static_cast<DtorList*>(::malloc(sizeof(DtorList)));
+      auto head = static_cast<DtorList*>(std::__libcpp_malloc(sizeof(DtorList)));
       if (!head) {
         return -1;
       }
 
       head->dtor = dtor;
       head->obj = obj;
       head->next = dtors;
       dtors = head;
 
       return 0;
     }
 #endif // HAVE___CXA_THREAD_ATEXIT_IMPL
   }
 
 } // extern "C"
 } // namespace __cxxabiv1

libcxxabi/src/fallback_malloc.cpp

 
 struct __attribute__((aligned)) __aligned_type {};
 
 void* __aligned_malloc_with_fallback(size_t size) {
 #if defined(_WIN32)
   if (void* dest = std::__libcpp_aligned_alloc(alignof(__aligned_type), size))
     return dest;
 #elif defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
-  if (void* dest = ::malloc(size))
+  if (void* dest = std::__libcpp_malloc(size))
     return dest;
 #else
   if (size == 0)
     size = 1;
   if (void* dest = std::__libcpp_aligned_alloc(__alignof(__aligned_type), size))
     return dest;
 #endif
   return fallback_malloc(size);
 }
 
 void* __calloc_with_fallback(size_t count, size_t size) {
-  void* ptr = ::calloc(count, size);
+  void* ptr = std::__libcpp_calloc(count, size);
   if (NULL != ptr)
     return ptr;
   // if calloc fails, fall back to emergency stash
   ptr = fallback_malloc(size * count);
   if (NULL != ptr)
     ::memset(ptr, 0, size * count);
   return ptr;
 }

libcxxabi/src/stdlib_new_delete.cpp

 
 _LIBCXXABI_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     void* p;
-    while ((p = ::malloc(size)) == nullptr)
-    {
-        // 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();
-        else
+    while ((p = std::__libcpp_malloc(size)) == nullptr) {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
             throw std::bad_alloc();
 #else
             break;
 #endif
     }
     return p;
 }