refactor; rework alloc/dealloc, strings; don't use pmr

Author: elsteveogrande

libcxx/include/CMakeLists.txt

@@ -727,9 +727,13 @@ set(files
   __ranges/views.h
   __ranges/zip_view.h
   __split_buffer
-  __stacktrace/basic_stacktrace.h
-  __stacktrace/impl.h
-  __stacktrace/stacktrace_entry.h
+  __stacktrace/base.h
+  __stacktrace/basic.h
+  __stacktrace/entry.h
+  __stacktrace/format.h
+  __stacktrace/hash.h
+  __stacktrace/nonmem.h
+  __stacktrace/to_string.h
   __std_mbstate_t.h
   __stop_token/atomic_unique_lock.h
   __stop_token/intrusive_list_view.h

libcxx/include/__stacktrace/base.h

@@ -0,0 +1,131 @@
+// -*- 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_BUILDER
+#define _LIBCPP_STACKTRACE_BUILDER
+
+#include <__config>
+#include <__cstddef/byte.h>
+#include <__cstddef/size_t.h>
+#include <__functional/function.h>
+#include <__fwd/format.h>
+#include <__fwd/ostream.h>
+#include <__memory/allocator_traits.h>
+#include <__vector/vector.h>
+#include <cstddef>
+#include <cstdint>
+#include <list>
+#include <optional>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class stacktrace_entry;
+
+namespace __stacktrace {
+
+struct _LIBCPP_HIDE_FROM_ABI alloc final {
+  function<byte*(size_t)> __alloc_bytes_;
+  function<void(byte*, size_t)> __dealloc_bytes_;
+
+  template <class _Allocator>
+  alloc(_Allocator __alloc) {
+    using _AT        = allocator_traits<_Allocator>;
+    using _BA        = typename _AT::template rebind_alloc<byte>;
+    auto __ba        = _BA(__alloc);
+    __alloc_bytes_   = [__ba](size_t __sz) mutable { return __ba.allocate(__sz); };
+    __dealloc_bytes_ = [__ba](void* __ptr, size_t __sz) mutable { __ba.deallocate((byte*)__ptr, __sz); };
+  }
+
+  template <typename _Tp>
+  struct Alloc {
+    function<byte*(size_t)> __alloc_bytes_;
+    function<void(byte*, size_t)> __dealloc_bytes_;
+
+    Alloc(function<byte*(size_t)> __alloc_bytes, function<void(byte*, size_t)> __dealloc_bytes)
+        : __alloc_bytes_(__alloc_bytes), __dealloc_bytes_(__dealloc_bytes) {}
+
+    template <typename _T2 = _Tp>
+    Alloc(Alloc<_T2> const& __rhs) : Alloc(__rhs.__alloc_bytes_, __rhs.__dealloc_bytes_) {}
+
+    using value_type = _Tp;
+    [[nodiscard]] _Tp* allocate(size_t __sz) { return (_Tp*)__alloc_bytes_(__sz * sizeof(_Tp)); }
+    void deallocate(_Tp* __ptr, size_t __sz) { __dealloc_bytes_((byte*)__ptr, __sz * sizeof(_Tp)); }
+
+    template <typename _A2>
+    bool operator==(_A2 const& __rhs) const {
+      return &__rhs == this;
+    }
+  };
+
+  template <typename _Tp>
+  Alloc<_Tp> make_alloc() {
+    return {__alloc_bytes_, __dealloc_bytes_};
+  }
+
+  using str = basic_string<char, char_traits<char>, Alloc<char>>;
+
+  template <typename... _Args>
+  str make_str(_Args... __args) {
+    return str(std::forward<_Args>(__args)..., make_alloc<char>());
+  }
+
+  template <typename _Tp>
+  using vec = vector<_Tp, Alloc<_Tp>>;
+
+  template <typename _Tp, typename... _Args>
+  vec<_Tp> make_vec(_Args... __args) {
+    return vec(std::forward<_Args>(__args)..., make_alloc<_Tp>());
+  }
+
+  template <typename _Tp>
+  using list = ::std::list<_Tp, Alloc<_Tp>>;
+
+  template <typename _Tp, typename... _Args>
+  list<_Tp> make_list(_Args... __args) {
+    return list(std::forward<_Args>(__args)..., make_alloc<_Tp>());
+  }
+};
+
+struct _LIBCPP_HIDE_FROM_ABI entry_base {
+  uintptr_t __addr_actual_{};                   // this address, as observed in this current process
+  uintptr_t __addr_unslid_{};                   // address adjusted for ASLR
+  optional<__stacktrace::alloc::str> __desc_{}; // uses wrapped _Allocator from caller
+  optional<__stacktrace::alloc::str> __file_{}; // uses wrapped _Allocator from caller
+  uint_least32_t __line_{};
+
+  stacktrace_entry to_stacktrace_entry() const;
+};
+
+struct _LIBCPP_HIDE_FROM_ABI builder final {
+  alloc __alloc_; // wraps the caller-provided allocator
+  alloc::vec<entry_base> __entries_;
+  alloc::str __main_prog_path_;
+
+  template <class _Allocator>
+  explicit builder(_Allocator __alloc)
+      : __alloc_(__alloc), __entries_(__alloc_.make_vec<entry_base>()), __main_prog_path_(__alloc_.make_str()) {}
+
+  _LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE _LIBCPP_EXPORTED_FROM_ABI void
+  build_stacktrace(size_t __skip, size_t __max_depth);
+};
+
+} // namespace __stacktrace
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_STACKTRACE_BUILDER

libcxx/include/__stacktrace/basic_stacktrace.h renamed to libcxx/include/__stacktrace/basic.h

@@ -10,30 +10,19 @@
 #ifndef _LIBCPP_BASIC_STACKTRACE
 #define _LIBCPP_BASIC_STACKTRACE
 
-#include <__stacktrace/impl.h>
-#include <__stacktrace/stacktrace_entry.h>
-
 #include <__config>
-#include <__format/formatter.h>
-#include <__functional/function.h>
 #include <__functional/hash.h>
 #include <__fwd/format.h>
-#include <__fwd/sstream.h>
 #include <__iterator/iterator.h>
-#include <__iterator/iterator_traits.h>
-#include <__iterator/reverse_access.h>
 #include <__iterator/reverse_iterator.h>
-#include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
-#include <__memory_resource/memory_resource.h>
 #include <__memory_resource/polymorphic_allocator.h>
-#include <__ostream/basic_ostream.h>
-#include <__utility/move.h>
-#include <__vector/pmr.h>
-#include <__vector/swap.h>
+#include <__stacktrace/base.h>
+#include <__stacktrace/entry.h>
+#include <__stacktrace/to_string.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__vector/vector.h>
-#include <cstddef>
-#include <memory>
+#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -63,12 +52,10 @@ class _LIBCPP_EXPORTED_FROM_ABI basic_stacktrace {
   constexpr static bool __kNoThrowAlloc =
       noexcept(noexcept(_Allocator().allocate(1)) && noexcept(_Allocator().allocate_at_least(1)));
 
-  using __entry_vec _LIBCPP_NODEBUG = vector<stacktrace_entry, _Allocator>;
-
   [[no_unique_address]] _Allocator __alloc_;
-  __entry_vec __entries_;
 
-  // _LIBCPP_HIDE_FROM_ABI basic_stacktrace(const _Allocator& __alloc, std::pmr::list<stacktrace_entry>&& __vec);
+  using __entry_vec = vector<stacktrace_entry, _Allocator>;
+  __entry_vec __entries_;
 
 public:
   // (19.6.4.1)
@@ -80,7 +67,7 @@ class _LIBCPP_EXPORTED_FROM_ABI basic_stacktrace {
   using difference_type = ptrdiff_t;
   using size_type       = size_t;
   using allocator_type  = _Allocator;
-  using const_iterator  = decltype(__entries_)::const_iterator;
+  using const_iterator  = __entry_vec::const_iterator;
   using iterator        = const_iterator;
 
   using reverse_iterator       = std::reverse_iterator<basic_stacktrace::iterator>;
@@ -103,13 +90,13 @@ class _LIBCPP_EXPORTED_FROM_ABI basic_stacktrace {
   current(size_type __skip,
           size_type __max_depth,
           const allocator_type& __caller_alloc = allocator_type()) noexcept(__kNoThrowAlloc) {
+    __stacktrace::builder __builder(__caller_alloc);
+    __builder.build_stacktrace(__skip + 1, __max_depth);
     basic_stacktrace<_Allocator> __ret{__caller_alloc};
-    __stacktrace::alloc __alloc(__caller_alloc);
-    auto __resize = [&__ret](size_t __sz) { __ret.__entries_.resize(__sz); };
-    auto __assign = [&__ret](size_t __index, stacktrace_entry&& __entry) {
-      __ret.__entries_.at(__index) = std::move(__entry);
-    };
-    __stacktrace::__impl(__skip + 1, __max_depth, __alloc, __resize, __assign);
+    __ret.__entries_.reserve(__builder.__entries_.size());
+    for (auto& __base : __builder.__entries_) {
+      __ret.__entries_.emplace_back(__base.to_stacktrace_entry());
+    }
     return __ret;
   }
 
@@ -252,48 +239,6 @@ namespace pmr {
 using stacktrace = basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
 } // namespace pmr
 
-// (19.6.4.6)
-// Non-member functions [stacktrace.basic.nonmem]
-
-template <class _Allocator>
-_LIBCPP_EXPORTED_FROM_ABI inline void
-swap(basic_stacktrace<_Allocator>& __a, basic_stacktrace<_Allocator>& __b) noexcept(noexcept(__a.swap(__b))) {
-  __a.swap(__b);
-}
-
-template <class _Allocator>
-_LIBCPP_EXPORTED_FROM_ABI inline string to_string(const basic_stacktrace<_Allocator>& __stacktrace) {
-  return __stacktrace::__to_string()(__stacktrace);
-}
-
-template <class _Allocator>
-_LIBCPP_EXPORTED_FROM_ABI inline ostream& operator<<(ostream& __os, const basic_stacktrace<_Allocator>& __stacktrace) {
-  auto __str = __stacktrace::__to_string()(__stacktrace);
-  return __os << __str;
-}
-
-// (19.6.5)
-// Formatting support [stacktrace.format]
-
-// TODO: stacktrace formatter: https://github.com/llvm/llvm-project/issues/105257
-template <class _Allocator>
-struct _LIBCPP_EXPORTED_FROM_ABI formatter<basic_stacktrace<_Allocator>>;
-
-// (19.6.6)
-// Hash support [stacktrace.basic.hash]
-
-template <class _Allocator>
-struct _LIBCPP_EXPORTED_FROM_ABI hash<basic_stacktrace<_Allocator>> {
-  [[nodiscard]] size_t operator()(basic_stacktrace<_Allocator> const& __context) const noexcept {
-    size_t __ret = 1;
-    for (auto const& __entry : __context.__entries_) {
-      __ret += hash<uintptr_t>()(__entry.native_handle());
-      __ret *= 3001;
-    }
-    return __ret;
-  }
-};
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/include/__stacktrace/stacktrace_entry.h renamed to libcxx/include/__stacktrace/entry.h

@@ -10,29 +10,16 @@
 #ifndef _LIBCPP_STACKTRACE_ENTRY
 #define _LIBCPP_STACKTRACE_ENTRY
 
-#include <__cstddef/byte.h>
-#include <__cstddef/ptrdiff_t.h>
-#include <__cstddef/size_t.h>
-#include <__format/formatter.h>
-#include <__functional/function.h>
-#include <__functional/hash.h>
+#include <__config>
 #include <__fwd/format.h>
 #include <__fwd/ostream.h>
-#include <__fwd/sstream.h>
-#include <__fwd/vector.h>
-#include <__iterator/iterator.h>
-#include <__iterator/iterator_traits.h>
-#include <__iterator/reverse_access.h>
-#include <__iterator/reverse_iterator.h>
-#include <__memory/allocator.h>
-#include <__memory/allocator_traits.h>
-#include <__utility/move.h>
-#include <__vector/pmr.h>
-#include <__vector/swap.h>
-#include <__vector/vector.h>
+#include <cstddef>
 #include <cstdint>
+#include <optional>
 #include <string>
 
+#include <__stacktrace/base.h>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
@@ -42,11 +29,10 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace __stacktrace {
-struct entry;
-} // namespace __stacktrace
+class _LIBCPP_EXPORTED_FROM_ABI stacktrace_entry : private __stacktrace::entry_base {
+  friend struct __stacktrace::entry_base;
+  stacktrace_entry(entry_base const& __base) : entry_base(__base) {}
 
-class _LIBCPP_EXPORTED_FROM_ABI stacktrace_entry {
 public:
   // (19.6.3.1) Overview [stacktrace.entry.overview]
   using native_handle_type = uintptr_t;
@@ -59,15 +45,25 @@ class _LIBCPP_EXPORTED_FROM_ABI stacktrace_entry {
 
   // (19.6.3.3) [stacktrace.entry.obs], observers
   [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI constexpr native_handle_type native_handle() const noexcept {
-    return __addr_;
+    return __addr_actual_;
   }
   [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI constexpr explicit operator bool() const noexcept {
     return native_handle() != 0;
   }
 
   // (19.6.3.4) [stacktrace.entry.query], query
-  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI string description() const { return __desc_; }
-  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI string source_file() const { return __file_; }
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI string description() const {
+    if (__desc_->empty()) {
+      return "";
+    }
+    return {__desc_->data(), __desc_->size()};
+  }
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI string source_file() const {
+    if (__desc_->empty()) {
+      return "";
+    }
+    return {__file_->data(), __file_->size()};
+  }
   [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI uint_least32_t source_line() const { return __line_; }
 
   // (19.6.3.5) [stacktrace.entry.cmp], comparison
@@ -80,20 +76,12 @@ class _LIBCPP_EXPORTED_FROM_ABI stacktrace_entry {
   operator<=>(const stacktrace_entry& __x, const stacktrace_entry& __y) noexcept {
     return __x.native_handle() <=> __y.native_handle();
   }
-
-private:
-  friend struct __stacktrace::entry;
-
-  uintptr_t __addr_{};
-  std::string __desc_{};
-  std::string __file_{};
-  uint_least32_t __line_{};
 };
 
 // (19.6.4.6)
 // Non-member functions [stacktrace.basic.nonmem]
 
-_LIBCPP_EXPORTED_FROM_ABI string to_string(const stacktrace_entry& __entry);
+[[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI string to_string(const stacktrace_entry& __entry);
 _LIBCPP_EXPORTED_FROM_ABI ostream& operator<<(ostream& __os, const stacktrace_entry& __entry);
 
 // (19.6.5)
@@ -114,6 +102,10 @@ struct _LIBCPP_EXPORTED_FROM_ABI hash<stacktrace_entry> {
   }
 };
 
+namespace __stacktrace {
+inline stacktrace_entry entry_base::to_stacktrace_entry() const { return {*this}; }
+} // namespace __stacktrace
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS