Import C++ Standard Template Library

You can now use the hardest fastest and most dangerous language there is
with Cosmopolitan. So far about 75% of LLVM libcxx has been added. A few
breaking changes needed to be made to help this go smoothly.

- Rename nothrow to dontthrow
- Rename nodiscard to dontdiscard
- Add some libm functions, e.g. lgamma, nan, etc.
- Change intmax_t from int128 to int64 like everything else
- Introduce %jjd formatting directive for int128_t
- Introduce strtoi128(), strtou128(), etc.
- Rename bsrmax() to bsr128()

Some of the templates that should be working currently are std::vector,
std::string, std::map, std::set, std::deque, etc.

third_party/libcxx/new.cc

@@ -0,0 +1,226 @@
+//===--------------------------- new.cpp ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "third_party/libcxx/stdlib.h"
+
+#include "third_party/libcxx/new"
+#include "third_party/libcxx/atomic_support.hh"
+#include "third_party/libcxx/new_handler_fallback.hh"
+
+namespace std {
+
+#ifndef __GLIBCXX__
+const nothrow_t nothrow{};
+#endif
+
+#ifndef LIBSTDCXX
+
+void __throw_bad_alloc() {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  throw bad_alloc();
+#else
+  _VSTD::abort();
+#endif
+}
+
+#endif // !LIBSTDCXX
+
+} // namespace std
+
+#if !defined(__GLIBCXX__) && !defined(_LIBCPP_ABI_VCRUNTIME) &&                \
+    !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
+
+// 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.
+
+_LIBCPP_WEAK
+void* operator new(std::size_t size) _THROW_BAD_ALLOC {
+  if (size == 0)
+    size = 1;
+  void* p;
+  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();
+    else
+#ifndef _LIBCPP_NO_EXCEPTIONS
+      throw std::bad_alloc();
+#else
+      break;
+#endif
+  }
+  return p;
+}
+
+_LIBCPP_WEAK
+void* operator new(size_t size, const std::nothrow_t&) _NOEXCEPT {
+  void* p = 0;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_NO_EXCEPTIONS
+    p = ::operator new(size);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  } catch (...) {
+  }
+#endif // _LIBCPP_NO_EXCEPTIONS
+  return p;
+}
+
+_LIBCPP_WEAK
+void* operator new[](size_t size) _THROW_BAD_ALLOC {
+  return ::operator new(size);
+}
+
+_LIBCPP_WEAK
+void* operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT {
+  void* p = 0;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_NO_EXCEPTIONS
+    p = ::operator new[](size);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  } catch (...) {
+  }
+#endif // _LIBCPP_NO_EXCEPTIONS
+  return p;
+}
+
+_LIBCPP_WEAK
+void operator delete(void* ptr)_NOEXCEPT { ::free(ptr); }
+
+_LIBCPP_WEAK
+void operator delete(void* ptr, const std::nothrow_t&)_NOEXCEPT {
+  ::operator delete(ptr);
+}
+
+_LIBCPP_WEAK
+void operator delete(void* ptr, size_t)_NOEXCEPT { ::operator delete(ptr); }
+
+_LIBCPP_WEAK
+void operator delete[](void* ptr) _NOEXCEPT { ::operator delete(ptr); }
+
+_LIBCPP_WEAK
+void operator delete[](void* ptr, const std::nothrow_t&) _NOEXCEPT {
+  ::operator delete[](ptr);
+}
+
+_LIBCPP_WEAK
+void operator delete[](void* ptr, size_t) _NOEXCEPT {
+  ::operator delete[](ptr);
+}
+
+#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
+
+_LIBCPP_WEAK
+void* operator new(std::size_t size,
+                   std::align_val_t alignment) _THROW_BAD_ALLOC {
+  if (size == 0)
+    size = 1;
+  if (static_cast<size_t>(alignment) < sizeof(void*))
+    alignment = std::align_val_t(sizeof(void*));
+  void* p;
+#if defined(_LIBCPP_MSVCRT_LIKE)
+  while ((p = _aligned_malloc(size, static_cast<size_t>(alignment))) == nullptr)
+#else
+  while (::posix_memalign(&p, static_cast<size_t>(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 _LIBCPP_NO_EXCEPTIONS
+      throw std::bad_alloc();
+#else
+      p = nullptr; // posix_memalign doesn't initialize 'p' on failure
+      break;
+#endif
+    }
+  }
+  return p;
+}
+
+_LIBCPP_WEAK
+void* operator new(size_t size, std::align_val_t alignment,
+                   const std::nothrow_t&) _NOEXCEPT {
+  void* p = 0;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_NO_EXCEPTIONS
+    p = ::operator new(size, alignment);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  } catch (...) {
+  }
+#endif // _LIBCPP_NO_EXCEPTIONS
+  return p;
+}
+
+_LIBCPP_WEAK
+void* operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
+  return ::operator new(size, alignment);
+}
+
+_LIBCPP_WEAK
+void* operator new[](size_t size, std::align_val_t alignment,
+                     const std::nothrow_t&) _NOEXCEPT {
+  void* p = 0;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_NO_EXCEPTIONS
+    p = ::operator new[](size, alignment);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  } catch (...) {
+  }
+#endif // _LIBCPP_NO_EXCEPTIONS
+  return p;
+}
+
+_LIBCPP_WEAK
+void operator delete(void* ptr, std::align_val_t)_NOEXCEPT {
+#if defined(_LIBCPP_MSVCRT_LIKE)
+  ::_aligned_free(ptr);
+#else
+  ::free(ptr);
+#endif
+}
+
+_LIBCPP_WEAK
+void operator delete(void* ptr, std::align_val_t alignment,
+                     const std::nothrow_t&)_NOEXCEPT {
+  ::operator delete(ptr, alignment);
+}
+
+_LIBCPP_WEAK
+void operator delete(void* ptr, size_t, std::align_val_t alignment)_NOEXCEPT {
+  ::operator delete(ptr, alignment);
+}
+
+_LIBCPP_WEAK
+void operator delete[](void* ptr, std::align_val_t alignment) _NOEXCEPT {
+  ::operator delete(ptr, alignment);
+}
+
+_LIBCPP_WEAK
+void operator delete[](void* ptr, std::align_val_t alignment,
+                       const std::nothrow_t&) _NOEXCEPT {
+  ::operator delete[](ptr, alignment);
+}
+
+_LIBCPP_WEAK
+void operator delete[](void* ptr, size_t,
+                       std::align_val_t alignment) _NOEXCEPT {
+  ::operator delete[](ptr, alignment);
+}
+
+#endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+#endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS