[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

23

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

libcxx/src/stacktrace/stacktrace_entry.cpp

40

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

40

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

# all libraries but c++ have to be added in manually.
   elseif (LIBCXX_HAS_GCC_S_LIB)
     target_link_libraries(${target} PRIVATE gcc_s)
   endif()
 
   if (LIBCXX_HAS_ATOMIC_LIB)
     target_link_libraries(${target} PRIVATE atomic)
   endif()
 
+  target_link_libraries(${target} PRIVATE unwind)
+
   if (MINGW)
     target_link_libraries(${target} PRIVATE "${MINGW_LIBRARIES}")
   endif()
 
   if (LIBCXX_TARGETING_MSVC)
     if (LIBCXX_DEBUG_BUILD)
       set(LIB_SUFFIX "d")
     else()

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/subrange.h
   __ranges/take_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __ranges/views.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/__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 <algorithm>
+#include <__stacktrace/stacktrace_entry.h>
+#include <__config>
+#include <iterator>
+#include <limits>
+#include <vector>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+using __stacktrace_emplace_callback = void(stacktrace_entry&&, void*);
+_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 = 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 basic_stacktrace current(const allocator_type& __alloc = allocator_type()) noexcept {
+    return current(0, __alloc);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI 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 basic_stacktrace current(size_type __skip, size_type __max_depth,
+                                                        const allocator_type& __alloc = allocator_type()) noexcept {
+    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>
+  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 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

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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 <__config>
+#include <array>
+#include <string>
+#include <compare>
+#include <variant>
+
+#pragma push_macro("_U")
+#undef _U
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+#pragma pop_macro("_U")
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __stacktrace_entry_cursor_ctor_tag {};
+
+class stacktrace_entry {
+public:
+  using native_handle_type = unw_cursor_t;
+
+  // [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]
+  string description() const;
+
+  string source_file() const;
+  uint_least32_t source_line() const;
+
+  // [stacktrace.entry.cmp]
+  friend constexpr bool operator==(const stacktrace_entry& __lhs, const stacktrace_entry& __rhs) noexcept {
+    if (!__lhs.__engaged_ && !__rhs.__engaged_)
+      return false;
+    return (__lhs.__engaged_ == __rhs.__engaged_)
+        && ::__builtin_memcmp(&__lhs.__cursor_, &__rhs.__cursor_, sizeof(native_handle_type)) == 0;
+  }
+
+  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_FUNC_VIS string to_string(const stacktrace_entry&);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif

libcxx/include/stacktrace

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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/stacktrace_entry.h>
+#include <__stacktrace/basic_stacktrace.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

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>
+
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_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;
+    emplace({__stacktrace_entry_cursor_ctor_tag{}, cursor}, vec);
+  }
+}
+
+_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 <cstring>
+#include <cxxabi.h>
+#include <cstdlib>
+#include <stacktrace>
+#include <string>
+
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace {
+string description(unw_cursor_t __cursor) {
+  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;
+
+  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)
+      return {};
+  }
+
+  int status;
+  char* const demangeled_name = __cxxabiv1::__cxa_demangle(mangled_name.get(), nullptr, 0, &status);
+
+  if (demangeled_name == nullptr)
+    return {mangled_name.get(), strlen(mangled_name.get())};
+
+  string __ret{demangeled_name, strlen(demangeled_name)};
+  free(demangeled_name);
+  return __ret;
+}
+
+string source_file(unw_cursor_t __cursor) { return {}; }
+uint_least32_t source_line(unw_cursor_t __cursor) { return {}; }
+} // namespace
+
+string stacktrace_entry::description() const {
+  if (!__engaged_)
+    return {};
+  return std::description(__cursor_);
+}
+
+string stacktrace_entry::source_file() const {
+  if (!__engaged_)
+    return {};
+  return std::source_file(__cursor_);
+}
+uint_least32_t stacktrace_entry::source_line() const {
+  if (!__engaged_)
+    return {};
+  return std::source_line(__cursor_);
+}
+
+_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/single_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/single_view.h'}}
 #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 <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
+#include <__stacktrace/.basic_stacktrace.h.swp> // expected-error@*:* {{use of private header from outside its module: '__stacktrace/.basic_stacktrace.h.swp'}}
+#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 <__utility/as_const.h> // expected-error@*:* {{use of private header from outside its module: '__utility/as_const.h'}}
 #include <__utility/auto_cast.h> // expected-error@*:* {{use of private header from outside its module: '__utility/auto_cast.h'}}
 #include <__utility/cmp.h> // expected-error@*:* {{use of private header from outside its module: '__utility/cmp.h'}}

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.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
+//
+//===----------------------------------------------------------------------===//
+
+#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 <cassert>
+#include <iostream>
+#include <stacktrace>
+
+int main(int, char**) {
+  auto stacktrace = std::stacktrace::current();
+  for (const auto& e : stacktrace) {
+    assert(e);
+  }
+}

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>
+
+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());
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/stacktrace/stacktrace_entry/ctors.pass.cpp

+
+int main() {}

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"],