[libc++][WIP] Implement P0881R7 (std::stacktrace)

[philnik]

Summary

The tests are currently incomplete. There are also still some other things not implemented that are required here.

[Mordante]

Nice see this being worked on!
I mainly looked at the code out of curiosity, I didn't do a review.

libcxx/include/__stacktrace/basic_stacktrace.h

24

Since this function is in the dylib it needs an availability macro in <__availability>.

libcxx/src/stacktrace/stacktrace_entry.cpp

41

When line 45 throws the pointer leaks.
I would suggest to do something like

// Unused; the returned pointer is used to test the conversion status.
int __s;
unique_ptr<char, void (*)(void*)> __demangled{abi::__cxa_demangle(__name, nullptr, 0, &__s), std::free};

(I wrote this for a libc++ formatting experiment.)

[philnik]

• Fix CI

[philnik]

libcxx/src/stacktrace/stacktrace_entry.cpp

41

Thanks, good catch!

[philnik]

• Fix CI
• Add more tests

[philnik]

• Remove non-ASCII characters

[philnik]

• Try to fix CI

[philnik]

• Add DWARF 5 32bit (not actually working)

[tschuett]

libcxx/src/stacktrace/stacktrace_entry.cpp

36

I do not know about the libcxx coding style, but LLVM prefers static over functions in anonymous namespaces. I believe there are quite a few functions that you could make static.

[philnik]

• DWARF works now for simple programs

[Febbe]

What prevents this from a merge? I don't think, that you must implement / support all binary formats to merge this. For now, ELF + DWARF should be enough, right?

[philnik]

In D123228#4424336, @Febbe wrote:

What prevents this from a merge? I don't think, that you must implement / support all binary formats to merge this. For now, ELF + DWARF should be enough, right?

If that worked it would be a start, but this doesn't. I think we need some external library (maybe something from LLDB) to support a reasonable set of binaries, so I haven't continued working on this.

[Febbe]

You could take a look at libbacktrace. The GNU stdlibc++ is using it to generate stacktraces.

[philnik]

In D123228#4428314, @Febbe wrote:

You could take a look at libbacktrace. The GNU stdlibc++ is using it to generate stacktraces.

That doesn't work for licensing reasons.

libcxx/CMakeLists.txt

if (LIBCXX_ENABLE_ASSERTIONS)
   config_define(1 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT)
 else()
   config_define(0 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT)
 endif()
 # Incomplete features get their own specific disabling flags. This makes it
 # easier to grep for target specific flags once the feature is complete.
 config_define_if_not(LIBCXX_ENABLE_INCOMPLETE_FEATURES _LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
 config_define_if_not(LIBCXX_ENABLE_INCOMPLETE_FEATURES _LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+config_define_if(LIBCXXABI_USE_LLVM_UNWINDER _LIBCPP_UNWINDLIB_LIBUNWIND)
+config_define_if(LIBCXX_HAS_GCC_S_LIB _LIBCPP_UNWINDLIB_GCC_S)
 
 if (LIBCXX_ABI_DEFINES)
   set(abi_defines)
   foreach (abi_define ${LIBCXX_ABI_DEFINES})
     if (NOT abi_define MATCHES "^_LIBCPP_ABI_")
       message(SEND_ERROR "Invalid ABI macro ${abi_define} in LIBCXX_ABI_DEFINES")
     endif()
     list(APPEND abi_defines "#define ${abi_define}")

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_ranges_to_container``                 *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_zip``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_reference_from_temporary``            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_spanstream``                          *unimplemented*
     ------------------------------------------------- -----------------
-    ``__cpp_lib_stacktrace``                          *unimplemented*
+    ``__cpp_lib_stacktrace``                          ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_stdatomic_h``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_contains``                     ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_resize_and_overwrite``         ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_to_underlying``                       ``202102L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_unreachable``                         ``202202L``
     ================================================= =================
 

libcxx/include/CMakeLists.txt

set(files
   __ranges/take_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __ranges/views.h
   __ranges/zip_view.h
   __split_buffer
   __std_stream
   __string
+  __stacktrace/stacktrace_entry.h
+  __stacktrace/basic_stacktrace.h
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h
   __support/ibm/limits.h
   __support/ibm/locale_mgmt_zos.h
   __support/ibm/nanosleep.h
   __support/ibm/support.h
   __support/ibm/xlocale.h
set(files
   scoped_allocator
   semaphore
   set
   setjmp.h
   shared_mutex
   span
   sstream
   stack
+  stacktrace
   stdbool.h
   stddef.h
   stdexcept
   stdint.h
   stdio.h
   stdlib.h
   streambuf
   string

libcxx/include/__availability

// #   define _LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format
     // Users can pass -D_LIBCPP_AVAILABILITY_CUSTOM_ASSERTION_HANDLER_PROVIDED
     // to the compiler to tell the library to ignore the fact that the
     // default handler isn't available on their deployment target. Note that
     // defining this macro but failing to define a custom assertion handler
     // will lead to a load-time error on back-deployment targets, so it
     // should be avoided.
 #   define _LIBCPP_AVAILABILITY_DEFAULT_ASSERTION_HANDLER
 
+#   define _LIBCPP_AVAILABILITY_STACKTRACE
+
 #elif defined(__APPLE__)
 
 #   define _LIBCPP_AVAILABILITY_SHARED_MUTEX                                    \
         __attribute__((availability(macos,strict,introduced=10.12)))            \
         __attribute__((availability(ios,strict,introduced=10.0)))               \
         __attribute__((availability(tvos,strict,introduced=10.0)))              \
         __attribute__((availability(watchos,strict,introduced=3.0)))
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \

 #   endif
 
 #   define _LIBCPP_AVAILABILITY_FORMAT                                          \
         __attribute__((unavailable))
 #   define _LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format
 
 #   define _LIBCPP_AVAILABILITY_DEFAULT_ASSERTION_HANDLER                       \
         __attribute__((unavailable))
+
+#define _LIBCPP_AVAILABILITY_STACKTRACE __attribute__((unavailable))
+
 #else
 
 // ...New vendors can add availability markup here...
 
 #   error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
 
 #endif
 

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 #cmakedefine _LIBCPP_HAS_PARALLEL_ALGORITHMS
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
 #cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #cmakedefine _LIBCPP_HAS_NO_INCOMPLETE_FORMAT
 #cmakedefine _LIBCPP_HAS_NO_INCOMPLETE_RANGES
 #cmakedefine01 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT
+#cmakedefine _LIBCPP_UNWINDLIB_LIBUNWIND
+#cmakedefine _LIBCPP_UNWINDLIB_GCC_S
 
 // __USE_MINGW_ANSI_STDIO gets redefined on MinGW
 #ifdef __clang__
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wmacro-redefined"
 #endif
 
 @_LIBCPP_ABI_DEFINES@
 @_LIBCPP_EXTRA_SITE_DEFINES@
 
 #ifdef __clang__
 #  pragma clang diagnostic pop
 #endif
 
 #endif // _LIBCPP___CONFIG_SITE

libcxx/include/__stacktrace/basic_stacktrace.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STACKTRACE_BASIC_STACKTRACE_H
+#define _LIBCPP___STACKTRACE_BASIC_STACKTRACE_H
+
+#include <__availability>
+#include <__config>
+#include <__stacktrace/stacktrace_entry.h>
+#include <algorithm>
+#include <iterator>
+#include <limits>
+#include <string>
+#include <vector>
+
+#include <cassert>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+using __stacktrace_emplace_callback = void(stacktrace_entry&&, void*);
+_LIBCPP_AVAILABILITY_STACKTRACE _LIBCPP_FUNC_VIS
+void __get_stacktrace(size_t __skip, size_t __max_depth, __stacktrace_emplace_callback* __emplace_back, void* __vector);
+
+template <class _Alloc>
+class basic_stacktrace {
+public:
+  using _Vec = vector<stacktrace_entry, _Alloc>;
+  using value_type = stacktrace_entry;
+  using const_reference = const value_type&;
+  using reference = value_type&;
+  using const_iterator = typename _Vec::const_iterator;
+  using iterator = const_iterator;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using difference_type = typename _Vec::difference_type;
+  using size_type = typename _Vec::size_type;
+  using allocator_type = _Alloc;
+
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE
+  basic_stacktrace current(const allocator_type& __alloc = allocator_type()) noexcept {
+    return current(0, __alloc);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE
+  basic_stacktrace current(size_type __skip, const allocator_type& __alloc = allocator_type()) noexcept {
+    return current(__skip, numeric_limits<size_type>::max(), __alloc);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE
+  basic_stacktrace current(size_type __skip, size_type __max_depth,
+                           const allocator_type& __alloc = allocator_type()) noexcept {
+    if (__max_depth == 0)
+      return {};
+    basic_stacktrace __ret(__alloc);
+    std::__get_stacktrace(__skip, __max_depth,
+        [](stacktrace_entry&& __entry, void* __vec) { static_cast<_Vec*>(__vec)->emplace_back(std::move(__entry)); },
+        &__ret.__stack_);
+    return __ret;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>) = default;
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stacktrace(const allocator_type& __alloc) noexcept : __stack_{__alloc} {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_stacktrace(const basic_stacktrace& other) = default;
+  _LIBCPP_HIDE_FROM_ABI basic_stacktrace(basic_stacktrace&& other) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI basic_stacktrace(const basic_stacktrace& __other, const allocator_type& __alloc)
+      : __stack_{__other.__stack_, __alloc} {}
+  _LIBCPP_HIDE_FROM_ABI basic_stacktrace(basic_stacktrace&& __other, const allocator_type& __alloc)
+      : __stack_{std::move(__other.__stack_), __alloc} {}
+  _LIBCPP_HIDE_FROM_ABI basic_stacktrace& operator=(const basic_stacktrace& other) = default;
+  _LIBCPP_HIDE_FROM_ABI basic_stacktrace& operator=(basic_stacktrace&& other) noexcept(
+      allocator_traits<allocator_type>::propagate_on_container_move_assignment::value ||
+      allocator_traits<allocator_type>::is_always_equal::value) = default;
+  _LIBCPP_HIDE_FROM_ABI ~basic_stacktrace() = default;
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __stack_.get_allocator(); }
+
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept { return __stack_.cbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept { return __stack_.cend(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const noexcept { return __stack_.crbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const noexcept { return __stack_.crend(); }
+
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const noexcept { return __stack_.cbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const noexcept { return __stack_.cend(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const noexcept { return __stack_.crbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const noexcept { return __stack_.crend(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() { return __stack_.empty(); }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const noexcept { return __stack_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const noexcept { return __stack_.max_size(); }
+
+  _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __pos) const { return __stack_[__pos]; }
+  _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __pos) const { return __stack_.at(__pos); }
+
+  template <class _Alloc2>
+  _LIBCPP_HIDE_FROM_ABI friend
+  bool operator==(const basic_stacktrace& __lhs, const basic_stacktrace<_Alloc2> __rhs) noexcept {
+    return std::equal(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end());
+  }
+
+  template <class _Alloc2>
+  _LIBCPP_HIDE_FROM_ABI friend
+  strong_ordering operator<=>(const basic_stacktrace& __lhs, const basic_stacktrace<_Alloc2>& __rhs) noexcept {
+    if (__lhs.size() != __rhs.size())
+      return __lhs.size() <=> __rhs.size();
+    // TODO: use std::lexicographical_compare_three_way once available
+    // return std::lexicographical_compare_three_way(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end());
+    return std::strong_ordering::less;
+  }
+
+private:
+  _Vec __stack_{};
+};
+
+using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
+
+template <class _Alloc>
+_LIBCPP_HIDE_FROM_ABI inline string to_string(const basic_stacktrace<_Alloc>& __trace) {
+  constexpr auto __function_name_length = 75;
+  constexpr auto __formatting_character_count = 5;
+  string __ret;
+  __ret.reserve(__trace.size() * (__function_name_length + __formatting_character_count));
+  size_t __counter = 0;
+  for (const auto& __e : __trace) {
+    __ret += ' ';
+    __ret += std::to_string(__counter);
+    __ret += "# ";
+    __ret += std::to_string(__e);
+    __ret += '\n';
+    ++__counter;
+  }
+  return __ret;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif

libcxx/include/__stacktrace/stacktrace_entry.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STACKTRACE_STACKTRACE_ENTRY_H
+#define _LIBCPP___STACKTRACE_STACKTRACE_ENTRY_H
+
+#include <__availability>
+#include <__config>
+#include <array>
+#include <compare>
+#include <string>
+#include <variant>
+
+#pragma push_macro("_U")
+#undef _U
+#define UNW_LOCAL_ONLY
+#ifdef _LIBCPP_UNWINDLIB_LIBUNWIND
+#  include <libunwind.h>
+namespace __stacktrace_types {
+  using native_handle_type = unw_cursor_t;
+} // namespace __stacktrace_types
+#elif defined(_LIBCPP_UNWINDLIB_GCC_S)
+#  include <unwind.h>
+namespace __stacktrace_types {
+  using native_handle_type = uintptr_t;
+} // namespace __stacktrace_types
+#else
+#  error "Could not find an unwind library"
+#endif
+#pragma pop_macro("_U")
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __stacktrace_entry_cursor_ctor_tag {};
+
+class stacktrace_entry {
+
+public:
+  using native_handle_type = __stacktrace_types::native_handle_type;
+
+  // [stacktrace.entry.ctor]
+  _LIBCPP_HIDE_FROM_ABI constexpr stacktrace_entry() noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI stacktrace_entry(__stacktrace_entry_cursor_ctor_tag, native_handle_type __cursor)
+      : __cursor_{__cursor}, __engaged_{true} {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr stacktrace_entry(const stacktrace_entry&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr stacktrace_entry& operator=(const stacktrace_entry&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI ~stacktrace_entry() = default;
+
+  // [stacktrace.entry.obs]
+  _LIBCPP_HIDE_FROM_ABI constexpr native_handle_type native_handle() const noexcept { return __cursor_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept {
+    return __engaged_;
+  }
+
+  // [stacktrace.entry.query]
+  _LIBCPP_HIDE_FROM_ABI string description() const {
+    if (!__engaged_) {
+      std::puts("Not engaged!");
+      return {};
+    }
+    return __unwind_description();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI string source_file() const { return {}; }
+  _LIBCPP_HIDE_FROM_ABI uint_least32_t source_line() const { return {}; }
+
+  // [stacktrace.entry.cmp]
+  _LIBCPP_HIDE_FROM_ABI friend
+  constexpr bool operator==(const stacktrace_entry& __lhs, const stacktrace_entry& __rhs) noexcept {
+    if (!__lhs.__engaged_ && !__rhs.__engaged_)
+      return true;
+    return (__lhs.__engaged_ == __rhs.__engaged_)
+        && ::__builtin_memcmp(&__lhs.__cursor_, &__rhs.__cursor_, sizeof(native_handle_type)) == 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend
+  constexpr strong_ordering operator<=>(const stacktrace_entry& __lhs, const stacktrace_entry& __rhs) noexcept {
+    return ::__builtin_memcmp(&__lhs.__cursor_, &__rhs.__cursor_, sizeof(native_handle_type)) <=> 0;
+  }
+
+private:
+  native_handle_type __cursor_{};
+  bool __engaged_{};
+
+  _LIBCPP_AVAILABILITY_STACKTRACE _LIBCPP_FUNC_VIS string __unwind_description() const;
+};
+
+_LIBCPP_FUNC_VIS string to_string(const stacktrace_entry&);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif

libcxx/include/module.modulemap

module sstream {
     // FIXME: should re-export istream, ostream, ios, streambuf, string?
     export *
   }
   module stack {
     header "stack"
     export initializer_list
     export *
   }
+  module stacktrace {
+    header "stacktrace"
+    export *
+
+    module __stacktrace {
+      module basic_stacktrace { private header "__stacktrace/basic_stacktrace.h" }
+      module stacktrace_entry { private header "__stacktrace/stacktrace_entry.h" }
+    }
+  }
   module stdexcept {
     header "stdexcept"
     export *
   }
   module streambuf {
     header "streambuf"
     export *
   }

libcxx/include/stacktrace

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_STACKTRACE
+#define _LIBCPP_STACKTRACE
+
+/*
+namespace std {
+  // [stacktrace.entry], class stacktrace_entry
+  class stacktrace_entry {
+  public:
+    using native_handle_type = implementation-defined;
+
+    // [stacktrace.entry.ctor], constructors
+    constexpr stacktrace_entry() noexcept;
+    constexpr stacktrace_entry(const stacktrace_entry& other) noexcept;
+    constexpr stacktrace_entry& operator=(const stacktrace_entry& other) noexcept;
+
+    ~stacktrace_entry();
+
+    // [stacktrace.entry.obs], observers
+    constexpr native_handle_type native_handle() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+
+    // [stacktrace.entry.query], query
+    string description() const;
+    string source_file() const;
+    uint_least32_t source_line() const;
+
+    // [stacktrace.entry.cmp], comparison
+    friend constexpr bool operator==(const stacktrace_entry& x,
+                                     const stacktrace_entry& y) noexcept;
+    friend constexpr strong_ordering operator<=>(const stacktrace_entry& x,
+                                                 const stacktrace_entry& y) noexcept;
+  };
+
+  // [stacktrace.basic], class template basic_stacktrace
+  template<class Allocator>
+  class basic_stacktrace {
+  public:
+    using value_type = stacktrace_entry;
+    using const_reference = const value_type&;
+    using reference = value_type&;
+    using const_iterator = implementation-defined;  // see [stacktrace.basic.obs]
+    using iterator = const_iterator;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using difference_type = implementation-defined;
+    using size_type = implementation-defined;
+    using allocator_type = Allocator;
+
+    // [stacktrace.basic.ctor], creation and assignment
+    static basic_stacktrace current(const allocator_type& alloc = allocator_type()) noexcept;
+    static basic_stacktrace current(size_type skip,
+                                    const allocator_type& alloc = allocator_type()) noexcept;
+    static basic_stacktrace current(size_type skip, size_type max_depth,
+                                    const allocator_type& alloc = allocator_type()) noexcept;
+
+    basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
+    explicit basic_stacktrace(const allocator_type& alloc) noexcept;
+
+    basic_stacktrace(const basic_stacktrace& other);
+    basic_stacktrace(basic_stacktrace&& other) noexcept;
+    basic_stacktrace(const basic_stacktrace& other, const allocator_type& alloc);
+    basic_stacktrace(basic_stacktrace&& other, const allocator_type& alloc);
+    basic_stacktrace& operator=(const basic_stacktrace& other);
+    basic_stacktrace& operator=(basic_stacktrace&& other)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+        allocator_traits<Allocator>::is_always_equal::value);
+
+    ~basic_stacktrace();
+
+    // [stacktrace.basic.obs], observers
+    allocator_type get_allocator() const noexcept;
+
+    const_iterator begin() const noexcept;
+    const_iterator end() const noexcept;
+    const_reverse_iterator rbegin() const noexcept;
+    const_reverse_iterator rend() const noexcept;
+
+    const_iterator cbegin() const noexcept;
+    const_iterator cend() const noexcept;
+    const_reverse_iterator crbegin() const noexcept;
+    const_reverse_iterator crend() const noexcept;
+
+    [[nodiscard]] bool empty() const noexcept;
+    size_type size() const noexcept;
+    size_type max_size() const noexcept;
+
+    const_reference operator[](size_type) const;
+    const_reference at(size_type) const;
+
+    // [stacktrace.basic.cmp], comparisons
+    template<class Allocator2>
+    friend bool operator==(const basic_stacktrace& x,
+                           const basic_stacktrace<Allocator2>& y) noexcept;
+    template<class Allocator2>
+    friend strong_ordering operator<=>(const basic_stacktrace& x,
+                                       const basic_stacktrace<Allocator2>& y) noexcept;
+
+    // [stacktrace.basic.mod], modifiers
+    void swap(basic_stacktrace& other)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+        allocator_traits<Allocator>::is_always_equal::value);
+
+  private:
+    vector<value_type, allocator_type> frames_;         // exposition only
+  };
+
+  // basic_stacktrace typedef-names
+  using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
+
+  // [stacktrace.basic.nonmem], non-member functions
+  template<class Allocator>
+    void swap(basic_stacktrace<Allocator>& a, basic_stacktrace<Allocator>& b)
+      noexcept(noexcept(a.swap(b)));
+
+  string to_string(const stacktrace_entry& f);
+
+  template<class Allocator>
+    string to_string(const basic_stacktrace<Allocator>& st);
+
+  template<class charT, class traits>
+    basic_ostream<charT, traits>&
+      operator<<(basic_ostream<charT, traits>& os, const stacktrace_entry& f);
+
+  template<class charT, class traits, class Allocator>
+    basic_ostream<charT, traits>&
+      operator<<(basic_ostream<charT, traits>& os, const basic_stacktrace<Allocator>& st);
+
+  namespace pmr {
+    using stacktrace = basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
+  }
+
+  // [stacktrace.basic.hash], hash support
+  template<class T> struct hash;
+  template<> struct hash<stacktrace_entry>;
+  template<class Allocator> struct hash<basic_stacktrace<Allocator>>;
+}
+*/
+
+#include <__config>
+#include <__stacktrace/basic_stacktrace.h>
+#include <__stacktrace/stacktrace_entry.h>
+
+#endif

libcxx/include/version

 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
 // # define __cpp_lib_ranges_to_container                  202202L
 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
-// # define __cpp_lib_stacktrace                           202011L
+# define __cpp_lib_stacktrace                           202011L
 // # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
 # define __cpp_lib_string_resize_and_overwrite          202110L
 # define __cpp_lib_to_underlying                        202102L
 # define __cpp_lib_unreachable                          202202L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   mutex_destructor.cpp
   new.cpp
   optional.cpp
   random_shuffle.cpp
   ryu/d2fixed.cpp
   ryu/d2s.cpp
   ryu/f2s.cpp
   shared_mutex.cpp
+  stacktrace/basic_stacktrace.cpp
+  stacktrace/stacktrace_entry.cpp
   stdexcept.cpp
   string.cpp
   support/runtime/exception_fallback.ipp
   support/runtime/exception_glibcxx.ipp
   support/runtime/exception_libcxxabi.ipp
   support/runtime/exception_libcxxrt.ipp
   support/runtime/exception_msvc.ipp
   support/runtime/exception_pointer_cxxabi.ipp
PROPERTIES
       OUTPUT_NAME   "c++"
       VERSION       "${LIBCXX_ABI_VERSION}.0"
       SOVERSION     "${LIBCXX_ABI_VERSION}"
       DEFINE_SYMBOL ""
   )
   cxx_add_common_build_flags(cxx_shared)
   cxx_set_common_defines(cxx_shared)
 
+  set(LIBCXX_USE_LIBUNWIND True)
+
   # Link against LLVM libunwind
   if (LIBCXXABI_USE_LLVM_UNWINDER)
     if (NOT LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY AND (TARGET unwind_shared OR HAVE_LIBUNWIND))
       target_link_libraries(cxx_shared PUBLIC unwind_shared)
     elseif (LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY AND (TARGET unwind_static OR HAVE_LIBUNWIND))
       # libunwind is already included in libc++abi
     else()
-      target_link_libraries(cxx_shared PUBLIC unwind)
-    endif()
+      target_link_libraries(cxx_shared PUBLIC gcc_s)
+      set(LIBCXX_USE_LIBUNWIND False)
+    endif()
+    if (${LIBCXX_USE_LIBUNWIND})
+      find_path(LIBCXX_LIBUNWIND_INCLUDES libunwind.h
+        PATHS ${LLVM_MAIN_SRC_DIR}/projects/libunwind/include
+              ${LLVM_MAIN_SRC_DIR}/runtimes/libunwind/include
+              ${LLVM_MAIN_SRC_DIR}/../libunwind/include
+        NO_DEFAULT_PATH
+        NO_CMAKE_FIND_ROOT_PATH
+      )
+    endif()
+  else()
+    target_link_libraries(cxx_shared PUBLIC gcc_s)
+
+  target_link_libraries(cxx_shared PUBLIC dl)
+
+  if (LIBCXX_LIBUNWIND_INCLUDES STREQUAL "LIBCXX_LIBUNWIND_INCLUDES-NOTFOUND")
+    set(LIBCXX_LIBUNWIND_INCLUDES "")
+  endif()
+
+  if (NOT LIBCXX_LIBUNWIND_INCLUDES STREQUAL "")
+    target_include_directories(cxx_shared PRIVATE "${LIBCXX_LIBUNWIND_INCLUDES}")
   endif()
 
   # Link against libc++abi
   if (LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY)
     if (APPLE)
       target_link_libraries(cxx_shared PRIVATE "-Wl,-force_load" "${LIBCXX_CXX_STATIC_ABI_LIBRARY}")
     else()
       target_link_libraries(cxx_shared PRIVATE "-Wl,--whole-archive,-Bstatic" "${LIBCXX_CXX_STATIC_ABI_LIBRARY}" "-Wl,-Bdynamic,--no-whole-archive")

libcxx/src/stacktrace/basic_stacktrace.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 <__config>
+#include <stacktrace>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef _LIBCPP_UNWINDLIB_LIBUNWIND
+_LIBCPP_FUNC_VIS void __get_stacktrace(const size_t skip,
+                                       const size_t max_depth,
+                                       __stacktrace_emplace_callback* const emplace,
+                                       void* const vec) {
+  unw_context_t context;
+  unw_getcontext(&context);
+  unw_cursor_t cursor;
+  unw_init_local(&cursor, &context);
+
+  for (size_t i = 0; i != skip; ++i) {
+    if (unw_step(&cursor) < 0) {
+      return;
+    }
+  }
+
+  for (size_t i = 0; i != max_depth; ++i) {
+    if (const auto ret = unw_step(&cursor); ret <= 0) {
+      return;
+    }
+    try {
+      emplace({__stacktrace_entry_cursor_ctor_tag{}, cursor}, vec);
+    } catch (...) {
+      return;
+    }
+  }
+}
+#elif defined(_LIBCPP_UNWINDLIB_GCC_S)
+namespace {
+  struct TraceData {
+    size_t skip;
+    size_t max_depth;
+    __stacktrace_emplace_callback* emplace_back;
+    void* vector;
+  };
+
+  _Unwind_Reason_Code unwind_cb(_Unwind_Context* context, void* trace_data_) {
+    auto& trace_data = *static_cast<TraceData*>(trace_data_);
+
+    if (trace_data.max_depth-- == 0)
+      return _URC_END_OF_STACK;
+
+    if (trace_data.skip != 0) {
+      --trace_data.skip;
+      return _URC_NO_REASON;
+    }
+
+    auto pc = _Unwind_GetIP(context);
+    try {
+    trace_data.emplace_back({__stacktrace_entry_cursor_ctor_tag{}, pc}, trace_data.vector);
+    } catch(...) {
+      return _URC_END_OF_STACK;
+    }
+    return _URC_NO_REASON;
+  }
+} // namespace
+
+_LIBCPP_FUNC_VIS void __get_stacktrace(const size_t skip,
+                                       const size_t max_depth,
+                                       __stacktrace_emplace_callback* const emplace_back,
+                                       void* const vector) {
+  TraceData data {
+    .skip = skip,
+    .max_depth = max_depth,
+    .emplace_back = emplace_back,
+    .vector = vector,
+  };
+  _Unwind_Backtrace(unwind_cb, static_cast<void*>(&data));
+}
+#endif
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/src/stacktrace/stacktrace_entry.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 <array>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <cxxabi.h>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <ranges>
+#include <stacktrace>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+#ifdef _LIBCPP_UNWINDLIB_GCC_S
+#  include <dlfcn.h>
+#endif
+
+#ifdef __linux__
+#  include <dwarf.h>
+#  include <elf.h>
+#  include <link.h>
+#  include <unistd.h>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace {
+string shorten_name(string str, string_view search, string_view replace) {
+  std::string::iterator p;
+  while (true) {
+    p = std::search(str.begin(), str.end(), search.begin(), search.end());
+    if (p == str.end())
+      return str;
+    str.replace(p, p + search.size(), replace);
+  }
+
+}
+
+static constexpr pair<string_view, string_view> rename[] = {
+  {"std::" _LIBCPP_TOSTRING(_LIBCPP_ABI_NAMESPACE), "std"},
+  {"> >", ">>"},
+  {"std::basic_string<char, std::char_traits<char>, std::allocator<char>>", "std::string"},
+  {"std::basic_string_view<char, std::char_traits<char>>", "std::string_view"},
+  {"std::integral_constant<bool, false>", "std::false_type"},
+  {"std::integral_constant<bool, true>", "std::true_type"},
+  {"std::basic_stacktrace<std::allocator<std::stacktrace_entry>>", "std::stacktrace"},
+};
+
+string shorten_name(string str) {
+  for (const auto& e : rename)
+    str = shorten_name(str, e.first, e.second);
+
+  return str;
+}
+
+string try_demangle(const char* const mangled_name) {
+  int status;
+  unique_ptr<char, decltype(std::free)*> demangeled_name =
+      {abi::__cxa_demangle(mangled_name, nullptr, 0, &status), std::free};
+
+  if (demangeled_name == nullptr)
+    return {mangled_name, strlen(mangled_name)};
+
+  string ret{demangeled_name.get(), strlen(demangeled_name.get())};
+  return shorten_name(ret);
+
+}
+
+string get_function_name_from_dladdr(uintptr_t address) {
+  Dl_info info;
+  if (dladdr(reinterpret_cast<void*>(address), &info) == 0)
+    return {};
+  if (info.dli_sname != nullptr)
+    return try_demangle(info.dli_sname);
+  return {};
+}
+
+string get_exe_path() {
+  return std::filesystem::read_symlink("/proc/self/exe");
+}
+
+string read_executable(string path) {
+  std::ifstream file(path, std::ios::in | std::ios::binary);
+  auto size = std::filesystem::file_size(path);
+  std::string str;
+  str.resize(size);
+  file.read(str.data(), str.size());
+  return str;
+}
+
+#if __SIZEOF_SIZE_T__ == 8
+using ElfHeader = Elf64_Ehdr;
+using ElfSectionHeader = Elf64_Shdr;
+#else
+using ElfHeader = Elf32_Ehdr;
+using ElfSectionHeader = Elf32_Shdr;
+#endif
+
+ElfSectionHeader getSectionHeader(string_view file, size_t offset, size_t index) {
+  ElfSectionHeader sectionHeader;
+  std::memcpy(&sectionHeader, file.data() + offset + index * sizeof(ElfSectionHeader), sizeof(ElfSectionHeader));
+  return sectionHeader;
+}
+
+struct DWARF_Data {
+  std::unique_ptr<char[]> data;
+  const char* debug_info;
+  const char* debug_abbrev;
+  const char* debug_str;
+  const char* debug_str_offsets;
+  const char* debug_addr;
+};
+
+DWARF_Data find_dwarf_data(string elf) {
+  ElfHeader header;
+
+  if (elf.size() < sizeof(header))
+    return {};
+
+  std::memcpy(&header, elf.data(), sizeof(header));
+
+  if (header.e_ident[EI_MAG0] != 0x7f
+   || header.e_ident[EI_MAG1] != 'E'
+   || header.e_ident[EI_MAG2] != 'L'
+   || header.e_ident[EI_MAG3] != 'F')
+    return {};
+
+#if __SIZEOF_SIZE_T__ == 8
+  if (header.e_ident[EI_CLASS] != ELFCLASS64)
+    return {};
+#else
+  if (header.e_ident[EI_CLASS] != ELFCLASS32)
+    return {};
+#endif
+
+  // std::cout << std::boolalpha;
+  // std::cout << "Is executable:              " << (header.e_type == ET_EXEC) << '\n'
+  //           << "Is AMD64:                   " << (header.e_machine == EM_X86_64) << '\n'
+  //           << "Is current version:         " << (header.e_version == EV_CURRENT) << '\n'
+  //           << "Header size:                " << header.e_ehsize << '\n'
+  //           << "Section header size:        " << header.e_shentsize << '\n'
+  //           << "Section header count:       " << header.e_shnum << '\n'
+  //           << "Section header offset:      " << header.e_shoff << '\n'
+  //           << "Section name header offset: " << header.e_shstrndx << '\n'
+  //           << '\n';
+  ElfSectionHeader stringSectionHeader = getSectionHeader(elf, header.e_shoff, header.e_shstrndx);
+  // std::cout << "Is String table: " << (stringSectionHeader.sh_type == SHT_STRTAB) << '\n'
+  //           << "table offset:    " << stringSectionHeader.sh_offset << '\n'
+  //           << "table size:      " << stringSectionHeader.sh_size << '\n'
+  //           << '\n';
+
+  // std::cout << "String section content: ";
+  // for (size_t i = 0; i != stringSectionHeader.sh_size; ++i) {
+  //
+  //   std::cout << (char)((elf.data() + stringSectionHeader.sh_offset)[i] ?: '-');
+  // }
+  // std::cout << '\n';
+
+  ElfSectionHeader debug_info {};
+  ElfSectionHeader debug_str {};
+  ElfSectionHeader debug_abbrev {};
+  ElfSectionHeader debug_str_offsets {};
+  ElfSectionHeader debug_addr {};
+
+
+  for (size_t i = 0; i != header.e_shnum; ++i) {
+    ElfSectionHeader sectionHeader = getSectionHeader(elf, header.e_shoff, i);
+    string_view headerName = (elf.data() + stringSectionHeader.sh_offset + sectionHeader.sh_name);
+
+    if (headerName == ".debug_info")
+      debug_info = sectionHeader;
+    else if (headerName == ".debug_str")
+      debug_str = sectionHeader;
+    else if (headerName == ".debug_abbrev")
+      debug_abbrev = sectionHeader;
+    else if (headerName == ".debug_str_offsets")
+      debug_str_offsets = sectionHeader;
+    else if (headerName == ".debug_addr")
+      debug_addr = sectionHeader;
+  }
+
+  DWARF_Data dwarf_data;
+
+  const auto copy_section = [&](ElfSectionHeader section, char* out) {
+    return std::copy_n(elf.data() + section.sh_offset, section.sh_size, out);
+  };
+
+  dwarf_data.data = std::make_unique<char[]>(debug_info.sh_size
+                                           + debug_abbrev.sh_size
+                                           + debug_str.sh_size
+                                           + debug_str_offsets.sh_size
+                                           + debug_addr.sh_size);
+
+  dwarf_data.debug_info = dwarf_data.data.get();
+  auto* debug_abbrev_ptr = copy_section(debug_info, dwarf_data.data.get());
+
+  dwarf_data.debug_abbrev = debug_abbrev_ptr;
+  auto* debug_str_ptr = copy_section(debug_abbrev, debug_abbrev_ptr);
+
+  dwarf_data.debug_str = debug_str_ptr;
+  auto* debug_str_offsets_ptr = copy_section(debug_str, debug_str_ptr);
+
+  dwarf_data.debug_str_offsets = debug_str_offsets_ptr;
+  auto* debug_addr_ptr = copy_section(debug_str_offsets, debug_str_offsets_ptr);
+
+  dwarf_data.debug_addr = debug_addr_ptr;
+  copy_section(debug_addr, debug_addr_ptr);
+
+  return dwarf_data;
+}
+
+struct DWARF4_CUHeader {
+  uint32_t size;
+  uint16_t version;
+  uint32_t abbreviation_offset;
+  uint8_t address_size;
+} __attribute__((packed));
+
+struct DWARF5_32bit_CUHeader {
+  uint32_t size;
+  uint16_t version;
+  uint8_t type;
+  uint8_t address_size;
+  uint32_t abbreviation_offset;
+} __attribute__((packed));
+
+struct DWARF5_64bit_CUHeader {
+  uint32_t useless_size;
+  uint64_t size;
+  uint16_t version;
+  uint8_t type;
+  uint64_t abbreviation_offset;
+} __attribute__((packed));
+
+union DWARF_CUHeader {
+  DWARF4_CUHeader dwarf4;
+  DWARF5_32bit_CUHeader dwarf5_32bit;
+  DWARF5_64bit_CUHeader dwarf5_64bit;
+};
+
+size_t consumeNextULEB128(const char*& d) {
+  size_t number {};
+  size_t shift {};
+  while (true) {
+    auto num = *d++;
+    number |= num & ~0x80 << shift;
+    if ((num & 0x80) == 0)
+      break;
+    shift += 7;
+  }
+  return number;
+}
+
+ssize_t consumeNextSLEB128(const char*& d) {
+  ssize_t number {};
+  size_t shift {};
+  char num;
+  do {
+    num = *d++;
+    number |= (num & ~0x80) << shift;
+    shift += 7;
+  } while ((num & 0x80) != 0);
+
+  if (shift < sizeof(ssize_t) * CHAR_BIT && (num & 0x40))
+    number |= (~static_cast<ssize_t>(0) << shift);
+
+  return number;
+}
+
+struct DWARF_Attribute {
+  uint64_t name;
+  uint64_t form;
+};
+
+struct DWARF_Abbreviation {
+  uint32_t tag {};
+  uint8_t has_child_entries {};
+  std::vector<DWARF_Attribute> attributes;
+};
+
+void print_data(const char* data, size_t count) {
+  std::cerr << std::hex << std::left;
+  for (size_t i = 0; i != count; ++i) {
+    if (i % 8 == 0)
+      std::cerr << '\n';
+    std::cerr << (static_cast<uint32_t>(data[i]) & 0xFF) << ' ';
+  }
+  std::cerr << '\n';
+}
+
+using DWARF_AbbreviationTable = unordered_map<uint32_t, DWARF_Abbreviation>;
+
+auto parse_abbreviation_table(const char* table) {
+  DWARF_AbbreviationTable abbreviations;
+
+  while (true) {
+    uint64_t code = consumeNextULEB128(table);
+    if (code == 0)
+      break;
+    DWARF_Abbreviation abbrev;
+
+    abbrev.tag = consumeNextULEB128(table);
+    abbrev.has_child_entries = *table++ == DW_CHILDREN_yes;
+
+    while (true) {
+      DWARF_Attribute attr {
+        .name = consumeNextULEB128(table),
+        .form = consumeNextULEB128(table),
+      };
+      if (attr.name == 0 && attr.form == 0)
+        break;
+      abbrev.attributes.emplace_back(attr);
+
+      if (attr.form == DW_FORM_implicit_const)
+        consumeNextULEB128(table);
+    }
+    abbreviations[code] = abbrev;
+  }
+
+  abbreviations[0] = {};
+
+  return abbreviations;
+}
+
+void consume_attribute(DWARF_Attribute attribute, const char*& data) {
+  switch (attribute.form) {
+    case DW_FORM_flag_present:
+    case DW_FORM_implicit_const:
+      break;
+
+    case DW_FORM_flag:
+    case DW_FORM_strx1:
+    case DW_FORM_data1:
+      data += 1;
+      break;
+
+    case DW_FORM_strx2:
+    case DW_FORM_data2:
+      data += 2;
+      break;
+
+    case DW_FORM_ref4:
+    case DW_FORM_data4:
+    case DW_FORM_sec_offset: // TODO: Make that depend on the dwarf type size
+    case DW_FORM_strp: // TODO: Make that depend on the dwarf type size
+    case DW_FORM_line_strp: // TODO: Make that depend on the dwarf type size
+      data += 4;
+      break;
+
+    case DW_FORM_addr: // TODO: Make that depend on the pointer size
+      data += 8;
+      break;
+
+    case DW_FORM_udata:
+    case DW_FORM_rnglistx:
+    case DW_FORM_addrx:
+      consumeNextULEB128(data);
+      break;
+
+    case DW_FORM_sdata:
+      consumeNextSLEB128(data);
+      break;
+
+    case DW_FORM_exprloc:
+      data += consumeNextULEB128(data);
+      break;
+
+  default:
+    throw std::runtime_error(string("Unknown DWARF attribute form: ") + to_string(attribute.form));
+  }
+}
+
+void consume_tag(const DWARF_Abbreviation& entry, const char*& data) {
+  for (const auto& e : entry.attributes)
+    consume_attribute(e, data);
+}
+
+struct CompileUnitInfo {
+  uint32_t address_offset;
+  uint32_t string_offsets_offset;
+};
+
+string_view read_string(CompileUnitInfo cu_info, DWARF_Attribute attr, const DWARF_Data& data) {
+  switch (attr.form) {
+    case DW_FORM_strx1: {
+      uint32_t str_offset;
+      std::memcpy(&str_offset,
+                  data.debug_str_offsets + cu_info.string_offsets_offset + static_cast<unsigned char>(*data.debug_info) * 4,
+                  sizeof(str_offset));
+      return data.debug_str + str_offset;
+    }
+
+    case DW_FORM_strx2: {
+      uint16_t offset;
+      std::memcpy(&offset, data.debug_info, sizeof(offset));
+      uint32_t str_offset;
+      std::memcpy(&str_offset, data.debug_str_offsets + cu_info.string_offsets_offset + 4 * offset, sizeof(str_offset));
+      return data.debug_str + str_offset;
+    }
+
+    default:
+      throw std::runtime_error("Unknown string FORM: " + to_string(attr.form));
+  }
+}
+
+size_t read_low_pc(uint32_t addr_offset, DWARF_Attribute attr, const DWARF_Data& data) {
+  switch (attr.form) {
+
+    case DW_FORM_addrx: {
+      const char* debug_info = data.debug_info;
+      return consumeNextULEB128(debug_info);
+    }
+
+    default:
+      throw std::runtime_error("Unkown low PC FORM: " + to_string(attr.form));
+  }
+}
+
+pair<bool, uint32_t> read_high_pc(DWARF_Attribute attr, const DWARF_Data& data) {
+  switch (attr.form) {
+
+    case DW_FORM_data4: {
+      uint32_t pc {};
+      std::memcpy(&pc, data.debug_info, 4);
+      return {true, pc};
+    }
+
+    default:
+      throw std::runtime_error("Unknown high PC FORM: " + to_string(attr.form));
+  }
+}
+
+struct Function {
+  string name {};
+  uintptr_t low_pc {};
+  uintptr_t high_pc {};
+};
+
+void parse_subprogram(CompileUnitInfo cu_info,
+                      const DWARF_Abbreviation& abbrev_entry,
+                      DWARF_Data& data,
+                      vector<Function>& functions) {
+  Function func {};
+  bool is_relative_high_address {};
+  bool ignore_func = false;
+
+  for (const auto& attr : abbrev_entry.attributes) {
+    switch (attr.name) {
+      case DW_AT_linkage_name:
+        func.name = read_string(cu_info, attr, data);
+        break;
+
+      case DW_AT_name:
+        if (func.name.empty())
+          func.name = read_string(cu_info, attr, data);
+        break;
+
+      case DW_AT_low_pc:
+        func.low_pc = read_low_pc(cu_info.address_offset, attr, data);
+        break;
+
+      case DW_AT_high_pc: {
+        auto [is_relative, high_pc] = read_high_pc(attr, data);
+        func.high_pc = high_pc;
+        is_relative_high_address = is_relative;
+        break;
+      }
+
+      case DW_AT_ranges:
+        throw std::runtime_error("Found DW_AT_ranges");
+
+      case DW_AT_specification:
+      case DW_AT_object_pointer:
+      case DW_AT_frame_base:
+      case DW_AT_accessibility:
+      case DW_AT_external:
+      case DW_AT_type:
+      case DW_AT_containing_type:
+      case DW_AT_vtable_elem_location:
+      case DW_AT_virtuality:
+      case DW_AT_explicit:
+        break;
+
+      case DW_AT_decl_line:
+      case DW_AT_decl_file:
+      case DW_AT_inline:
+        break;
+
+      case DW_AT_declaration:
+      case DW_AT_artificial:
+        ignore_func = true;
+        break;
+    }
+    consume_attribute(attr, data.debug_info);
+  }
+
+  uintptr_t low_pc;
+  std::memcpy(&low_pc, data.debug_addr + cu_info.address_offset + func.low_pc * sizeof(uintptr_t), sizeof(uintptr_t));
+  func.low_pc = low_pc;
+  func.high_pc += low_pc;
+
+  if (!ignore_func && !func.name.empty())
+    functions.emplace_back(func);
+}
+
+CompileUnitInfo parse_compile_unit(const DWARF_Abbreviation& entry, DWARF_Data& data) {
+  CompileUnitInfo info {};
+  for (const auto& attr : entry.attributes) {
+    switch (attr.name) {
+    case DW_AT_addr_base:
+      std::memcpy(&info.address_offset, data.debug_info, sizeof(uint32_t));
+      break;
+
+    case DW_AT_str_offsets_base: // TODO: Don't assume 32 bits
+      std::memcpy(&info.string_offsets_offset, data.debug_info, sizeof(uint32_t));
+      break;
+    }
+
+    consume_attribute(attr, data.debug_info);
+  }
+  return info;
+}
+
+struct TextOffset {
+  const char* name;
+  uintptr_t text_begin;
+  uintptr_t text_end;
+};
+
+int exe_load_ptr_cb(dl_phdr_info* info, size_t size, void* data) {
+  if (size != sizeof(dl_phdr_info)) {
+    std::cout << "Error: size != sizeof(dl_phdr_info)\n";
+    return 1;
+  }
+
+  // std::cout << "Address:          " << info->dlpi_addr << '\n'
+  //           << "Name:             " << info->dlpi_name << '\n'
+  //           << "Elf header count: " << info->dlpi_phnum << '\n';
+
+  if (std::strcmp(info->dlpi_name, "") != 0)
+    return 0;
+
+  auto& offset = *static_cast<TextOffset*>(data);
+  offset.name = info->dlpi_name;
+  offset.text_begin = info->dlpi_addr;
+  return 1;
+}
+
+auto get_exe_load_ptr() {
+  TextOffset offset {};
+  dl_iterate_phdr(exe_load_ptr_cb, static_cast<void*>(&offset));
+  return offset;
+}
+
+struct DWARF_32bit_AddressTableHeader {
+  uint32_t size;
+  uint16_t version;
+  uint8_t address_size;
+  uint8_t segment_selector_size;
+} __attribute__((packed));
+
+struct DWARF_64bit_AddressTableHeader {
+  uint32_t useless_size;
+  uint64_t size;
+  uint16_t version;
+  uint8_t address_size;
+  uint8_t segment_selector_size;
+} __attribute__((packed));
+
+
+union DWARF_AddressTableHeader {
+  DWARF_32bit_AddressTableHeader dwarf_32bit;
+  DWARF_64bit_AddressTableHeader dwarf_64bit;
+} __attribute__((packed));
+
+vector<uintptr_t> parse_address_table(const char* address_table) {
+  vector<uintptr_t> offsets;
+
+  DWARF_AddressTableHeader header;
+  std::memcpy(&header, address_table, sizeof(DWARF_32bit_AddressTableHeader));
+
+  // std::cerr << "Size:                  " << header.dwarf_32bit.size << '\n'
+  //           << "Address size:          " << int(header.dwarf_32bit.address_size) << '\n'
+  //           << "Segment selector size: " << int(header.dwarf_32bit.segment_selector_size) << '\n'
+  //           << "version:               " << header.dwarf_32bit.version << '\n';
+
+  for (size_t i = 0; i != header.dwarf_32bit.size / 8; ++i) {
+    auto addr = address_table + sizeof(DWARF_32bit_AddressTableHeader) + i * 8;
+    uintptr_t ptr;
+    std::memcpy(&ptr, addr, sizeof(uintptr_t));
+    // std::cout << "Address: " << ptr << '\n';
+  }
+
+  return offsets;
+}
+
+vector<Function> parse_dwarf(DWARF_Data data) {
+  DWARF_CUHeader header;
+  std::memcpy(&header, data.debug_info, sizeof(header));
+  // std::cout << "Unit Size:           " << header.dwarf5_32bit.size << '\n'
+  //           << "Version:             " << header.dwarf5_32bit.version << '\n'
+  //           << "Abbreviation offset: " << header.dwarf5_32bit.abbreviation_offset << '\n'
+  //           << "Address size:        " << static_cast<int>(header.dwarf5_32bit.address_size) << '\n'
+  //           << '\n';
+  if (header.dwarf5_32bit.size >= 0xfffffff0)
+    throw std::runtime_error("It's a 64-bit Unit!");
+  if (header.dwarf5_32bit.type != DW_UT_compile)
+    throw std::runtime_error("Unit type isn't DW_UT_compile; it's " + std::to_string(header.dwarf5_32bit.type));
+  data.debug_info += sizeof(DWARF5_32bit_CUHeader);
+  const auto abbrev_table = parse_abbreviation_table(data.debug_abbrev);
+  vector<uintptr_t> address_table;
+
+  vector<Function> functions;
+
+  size_t child_count {};
+  bool new_subchild = false;
+  CompileUnitInfo cu_info;
+  auto memory_area = get_exe_load_ptr();
+  if (memory_area.name == nullptr)
+    std::cerr << "Memory area not found";
+
+  do {
+    auto val = consumeNextULEB128(data.debug_info);
+    const auto& abbrev_entry = abbrev_table.at(val);
+
+    switch (abbrev_entry.tag) {
+
+      case DW_TAG_compile_unit: {
+        cu_info = parse_compile_unit(abbrev_entry, data);
+        address_table = parse_address_table(data.debug_addr
+                                          + cu_info.address_offset
+                                          - sizeof(DWARF_32bit_AddressTableHeader));
+        break;
+      }
+
+      case DW_TAG_subprogram:
+        parse_subprogram(cu_info, abbrev_entry, data, functions);
+        break;
+
+      default:
+        consume_tag(abbrev_entry, data.debug_info);
+    }
+
+    if (abbrev_entry.has_child_entries) {
+      ++child_count;
+      new_subchild = true;
+    } else {
+      if (!new_subchild && abbrev_entry.tag == 0)
+        --child_count;
+      new_subchild = false;
+    }
+  } while(child_count != 0);
+
+  // for (const auto& func : functions)
+  //   std::cout << "Low PC:  " << func.low_pc << '\n'
+  //             << "High PC: " << func.high_pc << '\n'
+  //             << "Name:    " << try_demangle(func.name.c_str()) << '\n'
+  //             << '\n';
+
+  return functions;
+}
+
+} // namespace
+
+#ifdef _LIBCPP_UNWINDLIB_LIBUNWIND
+_LIBCPP_FUNC_VIS string stacktrace_entry::__unwind_description() const {
+  constexpr auto initial_buffer_size = 128;
+  auto mangled_name = std::make_unique<char[]>(initial_buffer_size);
+  size_t alloc_size = initial_buffer_size * 2;
+  unw_word_t off;
+  auto cursor = __cursor_;
+
+  if (int ret_val = unw_get_proc_name(&cursor, mangled_name.get(), initial_buffer_size, &off); ret_val != 0) {
+    while (ret_val == UNW_ENOMEM) {
+      mangled_name = std::make_unique<char[]>(alloc_size);
+      alloc_size *= 2;
+      ret_val = unw_get_proc_name(&cursor, mangled_name.get(), alloc_size, &off);
+    }
+    if (ret_val != 0) {
+      unw_proc_info_t proc_info;
+      unw_get_proc_info(&cursor, &proc_info);
+      return get_function_name_from_dladdr(proc_info.start_ip);
+    }
+  }
+
+  return try_demangle(mangled_name.get());
+}
+#elif defined(_LIBCPP_UNWINDLIB_GCC_S)
+
+_LIBCPP_FUNC_VIS string stacktrace_entry::__unwind_description() const {
+  std::cout << std::hex;
+  std::cerr << std::hex;
+  try {
+    auto exe = read_executable(get_exe_path());
+    auto data = find_dwarf_data(std::move(exe));
+    auto functions = parse_dwarf(std::move(data));
+
+    for (const auto& func : functions) {
+      if (func.low_pc <= __cursor_ && __cursor_ < func.high_pc)
+        return try_demangle(func.name.c_str());
+    }
+  } catch (const std::runtime_error& err) { std::cout << "Error: " << err.what() << '\n'; } catch (...) {}
+
+  auto name = get_function_name_from_dladdr(__cursor_);
+  if (name.empty())
+    return std::format("0x{:x}", __cursor_);
+  return name;
+}
+#endif
+
+_LIBCPP_FUNC_VIS string to_string(const stacktrace_entry& entry) {
+  return entry.description();
+}
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/test/libcxx/assertions/headers_declare_assertion_handler.sh.cpp

 #endif
 
 // RUN: %{build} -DTEST_89
 #if defined(TEST_89)
 #   include <stack>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_92
-#if defined(TEST_92)
-#   include <stdexcept>
+// RUN: %{build} -DTEST_90
+#if defined(TEST_90)
+#   include <stacktrace>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_96
-#if defined(TEST_96) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <streambuf>
+// RUN: %{build} -DTEST_93
+#if defined(TEST_93)
+#   include <stdexcept>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_97
-#if defined(TEST_97)
-#   include <string>
+#if defined(TEST_97) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <streambuf>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_99
-#if defined(TEST_99)
-#   include <string_view>
+// RUN: %{build} -DTEST_98
+#if defined(TEST_98)
+#   include <string>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_100
-#if defined(TEST_100) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <strstream>
+#if defined(TEST_100)
+#   include <string_view>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_101
-#if defined(TEST_101)
-#   include <system_error>
+#if defined(TEST_101) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <strstream>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_103
-#if defined(TEST_103) && !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <thread>
+// RUN: %{build} -DTEST_102
+#if defined(TEST_102)
+#   include <system_error>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_104
-#if defined(TEST_104)
-#   include <tuple>
+#if defined(TEST_104) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <thread>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_105
 #if defined(TEST_105)
-#   include <type_traits>
+#   include <tuple>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_106
 #if defined(TEST_106)
-#   include <typeindex>
+#   include <type_traits>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_107
 #if defined(TEST_107)
-#   include <typeinfo>
+#   include <typeindex>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_109
-#if defined(TEST_109)
-#   include <unordered_map>
+// RUN: %{build} -DTEST_108
+#if defined(TEST_108)
+#   include <typeinfo>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_110
 #if defined(TEST_110)
-#   include <unordered_set>
+#   include <unordered_map>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_111
 #if defined(TEST_111)
-#   include <utility>
+#   include <unordered_set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_112
 #if defined(TEST_112)
-#   include <valarray>
+#   include <utility>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_113
 #if defined(TEST_113)
-#   include <variant>
+#   include <valarray>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_114
 #if defined(TEST_114)
-#   include <vector>
+#   include <variant>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_115
 #if defined(TEST_115)
-#   include <version>
+#   include <vector>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_118
-#if defined(TEST_118)
-#   include <experimental/algorithm>
+// RUN: %{build} -DTEST_116
+#if defined(TEST_116)
+#   include <version>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_119
-#if defined(TEST_119) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
+#if defined(TEST_119)
+#   include <experimental/algorithm>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_120
-#if defined(TEST_120) && __cplusplus >= 201103L
-#   include <experimental/deque>
+#if defined(TEST_120) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
+#   include <experimental/coroutine>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_121
 #if defined(TEST_121) && __cplusplus >= 201103L
-#   include <experimental/forward_list>
+#   include <experimental/deque>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_122
-#if defined(TEST_122)
-#   include <experimental/functional>
+#if defined(TEST_122) && __cplusplus >= 201103L
+#   include <experimental/forward_list>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_123
 #if defined(TEST_123)
-#   include <experimental/iterator>
+#   include <experimental/functional>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_124
-#if defined(TEST_124) && __cplusplus >= 201103L
-#   include <experimental/list>
+#if defined(TEST_124)
+#   include <experimental/iterator>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_125
 #if defined(TEST_125) && __cplusplus >= 201103L
-#   include <experimental/map>
+#   include <experimental/list>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_126
 #if defined(TEST_126) && __cplusplus >= 201103L
-#   include <experimental/memory_resource>
+#   include <experimental/map>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_127
-#if defined(TEST_127)
-#   include <experimental/propagate_const>
+#if defined(TEST_127) && __cplusplus >= 201103L
+#   include <experimental/memory_resource>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_128
-#if defined(TEST_128) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
-#   include <experimental/regex>
+#if defined(TEST_128)
+#   include <experimental/propagate_const>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_129
-#if defined(TEST_129) && __cplusplus >= 201103L
-#   include <experimental/set>
+#if defined(TEST_129) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
+#   include <experimental/regex>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_130
-#if defined(TEST_130)
-#   include <experimental/simd>
+#if defined(TEST_130) && __cplusplus >= 201103L
+#   include <experimental/set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_131
-#if defined(TEST_131) && __cplusplus >= 201103L
-#   include <experimental/string>
+#if defined(TEST_131)
+#   include <experimental/simd>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_132
-#if defined(TEST_132)
-#   include <experimental/type_traits>
+#if defined(TEST_132) && __cplusplus >= 201103L
+#   include <experimental/string>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_133
-#if defined(TEST_133) && __cplusplus >= 201103L
-#   include <experimental/unordered_map>
+#if defined(TEST_133)
+#   include <experimental/type_traits>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_134
 #if defined(TEST_134) && __cplusplus >= 201103L
-#   include <experimental/unordered_set>
+#   include <experimental/unordered_map>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_135
-#if defined(TEST_135)
-#   include <experimental/utility>
+#if defined(TEST_135) && __cplusplus >= 201103L
+#   include <experimental/unordered_set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_136
-#if defined(TEST_136) && __cplusplus >= 201103L
-#   include <experimental/vector>
+#if defined(TEST_136)
+#   include <experimental/utility>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_137
-#if defined(TEST_137)
-#   include <ext/hash_map>
+#if defined(TEST_137) && __cplusplus >= 201103L
+#   include <experimental/vector>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_138
 #if defined(TEST_138)
+#   include <ext/hash_map>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_139
+#if defined(TEST_139)
 #   include <ext/hash_set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // GENERATED-MARKER

libcxx/test/libcxx/clang_tidy.sh.cpp

 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <shared_mutex>
 #endif
 #include <span>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream>
 #endif
 #include <stack>
+#include <stacktrace>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>

libcxx/test/libcxx/double_include.sh.cpp

 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <shared_mutex>
 #endif
 #include <span>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream>
 #endif
 #include <stack>
+#include <stacktrace>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #include <span>
 TEST_MACROS();
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream>
 TEST_MACROS();
 #endif
 #include <stack>
 TEST_MACROS();
+#include <stacktrace>
+TEST_MACROS();
 #include <stdbool.h>
 TEST_MACROS();
 #include <stddef.h>
 TEST_MACROS();
 #include <stdexcept>
 TEST_MACROS();
 #include <stdint.h>
 TEST_MACROS();

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <shared_mutex>
 #endif
 #include <span>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream>
 #endif
 #include <stack>
+#include <stacktrace>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <shared_mutex>
 #endif
 #include <span>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream>
 #endif
 #include <stack>
+#include <stacktrace>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/size.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/size.h'}}
 #include <__ranges/subrange.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/subrange.h'}}
 #include <__ranges/take_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_view.h'}}
 #include <__ranges/transform_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/transform_view.h'}}
 #include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
 #include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
 #include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
+#include <__stacktrace/basic_stacktrace.h> // expected-error@*:* {{use of private header from outside its module: '__stacktrace/basic_stacktrace.h'}}
+#include <__stacktrace/stacktrace_entry.h> // expected-error@*:* {{use of private header from outside its module: '__stacktrace/stacktrace_entry.h'}}
 #include <__std_stream> // expected-error@*:* {{use of private header from outside its module: '__std_stream'}}
 #include <__string> // expected-error@*:* {{use of private header from outside its module: '__string'}}
 #include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
 #include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
 #include <__tuple> // expected-error@*:* {{use of private header from outside its module: '__tuple'}}
 #include <__type_traits/integral_constant.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/integral_constant.h'}}
 #include <__type_traits/is_callable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_callable.h'}}
 #include <__utility/as_const.h> // expected-error@*:* {{use of private header from outside its module: '__utility/as_const.h'}}

libcxx/test/std/language.support/support.limits/support.limits.general/stacktrace.version.compile.pass.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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// <stacktrace>
+
+// Test the feature test macros defined by <stacktrace>
+
+/*  Constant                Value
+    __cpp_lib_stacktrace    202011L [C++2b]
+*/
+
+#include <stacktrace>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER > 20
+
+# ifndef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should be defined in c++2b"
+# endif
+# if __cpp_lib_stacktrace != 202011L
+#   error "__cpp_lib_stacktrace should have the value 202011L in c++2b"
+# endif
+
+#endif // TEST_STD_VER > 20
+

libcxx/test/std/language.support/support.limits/support.limits.general/stacktrace.version.pass.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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// <stacktrace>
+
+// Test the feature test macros defined by <stacktrace>
+
+/*  Constant                Value
+    __cpp_lib_stacktrace    202011L [C++2b]
+*/
+
+#include <stacktrace>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# ifdef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER > 20
+
+# ifndef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should be defined in c++2b"
+# endif
+# if __cpp_lib_stacktrace != 202011L
+#   error "__cpp_lib_stacktrace should have the value 202011L in c++2b"
+# endif
+
+#endif // TEST_STD_VER > 20
+
+int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

 
 # ifndef __cpp_lib_ssize
 #   error "__cpp_lib_ssize should be defined in c++2b"
 # endif
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_stacktrace
-#     error "__cpp_lib_stacktrace should be defined in c++2b"
-#   endif
-#   if __cpp_lib_stacktrace != 202011L
-#     error "__cpp_lib_stacktrace should have the value 202011L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_stacktrace
-#     error "__cpp_lib_stacktrace should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_stacktrace
+#   error "__cpp_lib_stacktrace should be defined in c++2b"
+# endif
+# if __cpp_lib_stacktrace != 202011L
+#   error "__cpp_lib_stacktrace should have the value 202011L in c++2b"
+# endif
 
 # ifndef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should be defined in c++2b"
 # endif
 # if __cpp_lib_starts_ends_with != 201711L
 #   error "__cpp_lib_starts_ends_with should have the value 201711L in c++2b"
 # endif
 

libcxx/test/std/utilities/stacktrace/basic_stacktrace/assignment.pass.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 <cassert>
+#include <stacktrace>
+
+#include "test_allocator.h"
+
+static_assert(std::is_nothrow_assignable_v<std::stacktrace, std::stacktrace>);
+static_assert(!std::is_nothrow_assignable_v<std::basic_stacktrace<test_allocator<std::stacktrace_entry>>,
+                                            std::basic_stacktrace<test_allocator<std::stacktrace_entry>>>);
+
+int main(int, char**) {
+  { // (const basic_stacktrace&)
+    std::stacktrace tr = std::stacktrace::current();
+    std::stacktrace tr2;
+    assert(tr != tr2);
+    tr2 = tr;
+    assert(tr == tr2);
+  }
+  { // (basic_stacktrace&&)
+    std::stacktrace tr = std::stacktrace::current();
+    std::stacktrace tr2;
+    assert(tr != tr2);
+    tr2 = std::move(tr);
+    LIBCPP_ASSERT(tr.empty());
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/stacktrace/basic_stacktrace/ctors.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <stacktrace>
+#include <type_traits>
+
+#include "test_allocator.h"
+
+static_assert(std::is_nothrow_default_constructible_v<std::stacktrace>);
+static_assert(!std::is_nothrow_default_constructible_v<std::basic_stacktrace<other_allocator<std::stacktrace_entry>>>);
+
+template <class Alloc>
+void test() {
+  using ST = std::basic_stacktrace<Alloc>;
+  { // ()
+    ST st;
+    assert(st.empty());
+  }
+
+  { // (const basic_stacktrace&)
+    ST st = ST::current();
+    ST st2 = st;
+    assert(st.size() == st2.size());;
+    for (size_t i = 0; i != st.size(); ++i) {
+      assert(st[i] == st2[i]);
+    }
+  }
+
+  { // (basic_stacktrace&&)
+    ST st = ST::current();
+    ST st2 = std::move(st);
+    LIBCPP_ASSERT(st.empty());
+  }
+}
+
+int main(int, char**) {
+  test<std::allocator<std::stacktrace_entry>>();
+  test<test_allocator<std::stacktrace_entry>>();
+  using Alloc = test_allocator<std::stacktrace_entry>;
+  using ST = std::basic_stacktrace<Alloc>;
+  { // (const allocator_type&)
+    test_allocator_statistics stats;
+    ST st{Alloc(&stats)};
+    assert(st.get_allocator().get_stats() == &stats);
+  }
+  { // (const basic_stacktrace&, const allocator_type&)
+    test_allocator_statistics stats;
+    ST st = ST::current();
+    ST st2 = {st, Alloc(&stats)};
+    assert(st2.get_allocator().get_stats() == &stats);
+    assert(st.get_allocator().get_stats() == nullptr);
+  }
+  { // (basic_stacktrace&&, const allocator_type&)
+    test_allocator_statistics stats;
+    ST st = ST::current();
+    ST st2 = {std::move(st), Alloc(&stats)};
+    assert(st2.get_allocator().get_stats() == &stats);
+  }
+}

libcxx/test/std/utilities/stacktrace/basic_stacktrace/current.pass.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 <algorithm>
+#include <cassert>
+#include <iostream>
+#include <stacktrace>
+
+template <class Alloc>
+void test() {
+  using ST = std::basic_stacktrace<Alloc>;
+  {
+    auto st = ST::current();
+    assert(std::all_of(st.begin(), st.end(), [](auto& e) { return bool(e); }));
+  }
+  {
+    auto st = ST::current(0);
+    assert(std::all_of(st.begin(), st.end(), [](auto& e) { return bool(e); }));
+  }
+  {
+    auto st = ST::current(0, 0);
+    assert(st.empty());
+  }
+  {
+    auto st = ST::current(0, 1);
+    assert(st.size() <= 1);
+    if (!st.empty())
+      assert(st[0]);
+  }
+}
+
+int main(int, char**) {
+}

libcxx/test/std/utilities/stacktrace/basic_stacktrace/member_types.compile.pass.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 <stacktrace>
+
+#include "test_allocator.h"
+
+namespace N1 {
+  using ST = std::stacktrace;
+  static_assert(std::is_same_v<ST::value_type, std::stacktrace_entry>);
+  static_assert(std::is_same_v<ST::const_reference, const std::stacktrace_entry&>);
+  static_assert(std::is_same_v<ST::reference, std::stacktrace_entry&>);
+  static_assert(std::is_same_v<ST::iterator, ST::const_iterator>);
+  static_assert(std::is_same_v<ST::reverse_iterator, std::reverse_iterator<ST::iterator>>);
+  static_assert(std::is_same_v<ST::const_reverse_iterator, std::reverse_iterator<ST::const_iterator>>);
+  static_assert(std::is_same_v<ST::size_type, std::size_t>);
+  static_assert(std::is_same_v<ST::difference_type, std::ptrdiff_t>);
+  static_assert(std::is_same_v<ST::allocator_type, std::allocator<std::stacktrace_entry>>);
+} // namespace N1
+
+namespace N2 {
+  using ST = std::basic_stacktrace<test_allocator<std::stacktrace_entry>>;
+  static_assert(std::is_same_v<ST::value_type, std::stacktrace_entry>);
+  static_assert(std::is_same_v<ST::const_reference, const std::stacktrace_entry&>);
+  static_assert(std::is_same_v<ST::reference, std::stacktrace_entry&>);
+  static_assert(std::is_same_v<ST::iterator, ST::const_iterator>);
+  static_assert(std::is_same_v<ST::reverse_iterator, std::reverse_iterator<ST::iterator>>);
+  static_assert(std::is_same_v<ST::const_reverse_iterator, std::reverse_iterator<ST::const_iterator>>);
+  static_assert(std::is_same_v<ST::size_type, unsigned>);
+  static_assert(std::is_same_v<ST::difference_type, int>);
+  static_assert(std::is_same_v<ST::allocator_type, test_allocator<std::stacktrace_entry>>);
+} // namespace N2

libcxx/test/std/utilities/stacktrace/basic_stacktrace/to_string.pass.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 <cassert>
+#include <stacktrace>
+#include <string>
+
+#include <iostream>
+
+void func() {
+  std::cerr << std::to_string(std::stacktrace::current());
+}
+
+int main(int, char**) {
+  // auto stacktrace = std::stacktrace::current();
+  // if (!stacktrace.empty()) {
+  //   assert(!std::to_string(stacktrace).empty());
+  // } else {
+  //   assert(std::to_string(stacktrace).empty());
+  // }
+
+  // assert(stacktrace[0]);
+  func();
+  assert(false);
+
+  return 0;
+}

libcxx/test/std/utilities/stacktrace/stacktrace_entry/assignment.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <stacktrace>
+
+// constexpr stacktrace_entry& operator=(const stacktrace_entry& other) noexcept;
+
+#include <cassert>
+#include <stacktrace>
+
+constexpr bool test_constexpr() {
+  std::stacktrace_entry entry;
+  assert(!entry);
+  std::stacktrace_entry entry2;
+  entry2 = entry;
+  assert(!entry2);
+
+  return true;
+}
+
+void test() {
+  std::stacktrace trace = std::stacktrace::current();
+  if (!trace.empty()) {
+    auto entry = trace[0];
+    std::stacktrace_entry entry2;
+    assert(!entry2);
+    assert(entry != entry2);
+    entry2 = entry;
+    assert(entry2);
+    assert(entry == entry2);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_constexpr();
+  static_assert(test_constexpr());
+}

libcxx/test/std/utilities/stacktrace/stacktrace_entry/compare.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <stacktrace>
+
+// string source_file() const;
+
+#include <cassert>
+#include <compare>
+#include <stacktrace>
+
+constexpr bool test_constexpr() {
+  std::stacktrace_entry entry;
+  std::stacktrace_entry entry2;
+
+  assert(entry == entry2);
+  assert(entry <=> entry2 == std::strong_ordering::equal);
+
+  return true;
+}
+
+void test() {
+  std::stacktrace trace = std::stacktrace::current();
+  if (trace.size() >= 2) {
+    assert(trace[0] != trace[1]);
+    assert(trace[0] <=> trace[1] != std::strong_ordering::equal);
+
+    assert(trace[0] == trace[0]);
+    assert(trace[0] <=> trace[0] == std::strong_ordering::equal);
+  }
+}
+
+int main(int, char**) {
+  test();
+}

libcxx/test/std/utilities/stacktrace/stacktrace_entry/ctors.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <stacktrace>
+
+// constexpr stacktrace_entry() noexcept;
+// constexpr stacktrace_entry(const stacktrace_entry& other) noexcept;
+
+#include <cassert>
+#include <stacktrace>
+
+constexpr bool test_constexpr() {
+  std::stacktrace_entry entry;
+  assert(!entry);
+  auto entry2 = entry;
+  assert(!entry2);
+
+  return true;
+}
+
+int main(int, char**) {
+  test_constexpr();
+  static_assert(test_constexpr());
+}

libcxx/test/std/utilities/stacktrace/stacktrace_entry/description.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <stacktrace>
+
+// string description() const;
+
+#include <cassert>
+#include <stacktrace>
+#include <string>
+#include <type_traits>
+
+void test() {
+  std::stacktrace trace = std::stacktrace::current();
+  if (!trace.empty()) {
+    auto entry = trace[0];
+    const std::stacktrace_entry entry2 = entry;
+    static_assert(std::is_same_v<decltype(entry.description()), std::string>);
+    assert(entry.description() == entry2.description());
+  }
+}
+
+int main(int, char**) {
+  test();
+}

libcxx/test/std/utilities/stacktrace/stacktrace_entry/native_handle.compile.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <stacktrace>
+
+// constexpr native_handle_type native_handle() const noexcept;
+
+#include <stacktrace>
+#include <type_traits>
+
+static_assert(std::is_same_v<decltype(std::declval<std::stacktrace_entry>().native_handle()),
+                             std::stacktrace_entry::native_handle_type>);

libcxx/test/std/utilities/stacktrace/stacktrace_entry/source_file.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <stacktrace>
+
+// string source_file() const;
+
+#include <cassert>
+#include <stacktrace>
+#include <string>
+#include <type_traits>
+
+void test() {
+  std::stacktrace trace = std::stacktrace::current();
+  if (!trace.empty()) {
+    auto entry = trace[0];
+    const std::stacktrace_entry entry2 = entry;
+    static_assert(std::is_same_v<decltype(entry.source_file()), std::string>);
+    assert(entry.source_file() == entry2.source_file());
+  }
+}
+
+int main(int, char**) {
+  test();
+}

libcxx/test/std/utilities/stacktrace/stacktrace_entry/source_line.pass.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <stacktrace>
+
+// uint_least32_t source_line() const;
+
+#include <cassert>
+#include <cstdint>
+#include <stacktrace>
+#include <type_traits>
+
+void test() {
+  std::stacktrace trace = std::stacktrace::current();
+  if (!trace.empty()) {
+    auto entry = trace[0];
+    const std::stacktrace_entry entry2 = entry;
+    static_assert(std::is_same_v<decltype(entry.source_line()), std::uint_least32_t>);
+    assert(entry.source_line() == entry2.source_line());
+  }
+}
+
+int main(int, char**) {
+  test();
+}

libcxx/test/support/test_allocator.h

#else
   }
 #endif
   TEST_CONSTEXPR_CXX14 void destroy(pointer p) { p->~T(); }
   TEST_CONSTEXPR friend bool operator==(const test_allocator& x, const test_allocator& y) { return x.data_ == y.data_; }
   TEST_CONSTEXPR friend bool operator!=(const test_allocator& x, const test_allocator& y) { return !(x == y); }
 
   TEST_CONSTEXPR int get_data() const { return data_; }
   TEST_CONSTEXPR int get_id() const { return id_; }
+  TEST_CONSTEXPR test_allocator_statistics* get_stats() { return stats_; };
 };
 
 template <class T>
 class non_default_test_allocator {
   int data_ = 0;
   test_allocator_statistics* stats_ = nullptr;
 
   template <class U>

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_ssize",
     "values": { "c++20": 201902 },
     "headers": ["iterator"],
   }, {
     "name": "__cpp_lib_stacktrace",
     "values": { "c++2b": 202011 },
     "headers": ["stacktrace"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_starts_ends_with",
     "values": { "c++20": 201711 },
     "headers": ["string", "string_view"],
   }, {
     "name": "__cpp_lib_stdatomic_h",
     "values": { "c++2b": 202011 },
     "headers": ["stdatomic.h"],