Misc fixes so things build

Author: elsteveogrande

libcxx/include/__stacktrace/images.h

@@ -20,15 +20,13 @@ struct image;
 struct images;
 
 struct image {
-  constexpr static size_t __max_string_len = 1024;
-
   uintptr_t loaded_at_{};
   uintptr_t slide_{};
-  fixed_str<__max_string_len> name_{};
+  fixed_str<PATH_MAX> name_{};
   bool is_main_prog_{};
 
   bool operator<(image const& __rhs) const { return loaded_at_ < __rhs.loaded_at_; }
-  operator bool() const { return name_[0]; }
+  operator bool() const { return !name_.empty(); }
 };
 
 /**

libcxx/include/__stacktrace/memory.h

@@ -38,60 +38,59 @@ A few memory-related utilities:
     Uses the caller's provided allocator, so none of these involve heap allocations
     "outside of" the caller-provided allocator.
   * A `str` class, inheriting from `std::string`, ensuring allocations happen via `arena`
-  * A `fixed_str` class, not related to the arena, but instead backed by a `char[n]`
-    array within that same struct, so it doesn't perform any [de]allocations; it only
-    uses its own character array.
 
 A small amount of glue / hacks are done here to allow the rest of the stacktrace-related
 code to use familiar string etc. operations, while encapsulating away the details of where
 memory might come from, since we need to be careful about unexpected allocations.
 */
 
-// clang-format off
-
 struct byte_pool final {
   byte* ptr_;
   function<void()> destroy_;
   byte_pool* link_;
   byte* end_;
 
-  byte_pool(byte* __bytes,
-            size_t __size,
-            function<void()> __destroy = [] {},
-            byte_pool* __link = nullptr) noexcept
-    : ptr_(__bytes), destroy_(__destroy), link_(__link), end_(__bytes + __size) {}
+  byte_pool(
+      byte* __bytes, size_t __size, function<void()> __destroy = [] {}, byte_pool* __link = nullptr) noexcept
+      : ptr_(__bytes), destroy_(__destroy), link_(__link), end_(__bytes + __size) {}
 
   byte* operator()(size_t __sz, size_t __align) noexcept {
-    auto __ptr = uintptr_t(ptr_);                         // convert curr ptr to integer, to do math
-    auto __misalign = __ptr % __align;                    // if current ptr not aligned,
-    if (__misalign) { __ptr += (__align - __misalign); }  // waste a few bytes to ensure alignment
-    auto __ret = __ptr;                                   // we would return this aligned position
-    __ptr += __sz;                                        // next object will start here
-    if (__ptr > uintptr_t(end_)) { return nullptr; }      // if this exceeds our space, then fail
-    ptr_ = (byte*) __ptr;                                 // otherwise update current position
-    return (byte*) __ret;                                 // returned aligned position as byte ptr
+    auto __ptr      = uintptr_t(ptr_); // convert curr ptr to integer, to do math
+    auto __misalign = __ptr % __align; // if current ptr not aligned,
+    if (__misalign) {
+      __ptr += (__align - __misalign);
+    } // waste a few bytes to ensure alignment
+    auto __ret = __ptr; // we would return this aligned position
+    __ptr += __sz;      // next object will start here
+    if (__ptr > uintptr_t(end_)) {
+      return nullptr;
+    } // if this exceeds our space, then fail
+    ptr_ = (byte*)__ptr; // otherwise update current position
+    return (byte*)__ret; // returned aligned position as byte ptr
   }
 };
 
 template <size_t _Sz>
 struct stack_bytes final {
   byte bytes_[_Sz];
 
-  ~stack_bytes() = default;
-  stack_bytes() noexcept = default;
+  ~stack_bytes()                  = default;
+  stack_bytes() noexcept          = default;
   stack_bytes(const stack_bytes&) = delete;
-  stack_bytes(stack_bytes&&) = delete;
+  stack_bytes(stack_bytes&&)      = delete;
 
-  byte_pool pool() { return {bytes_, _Sz, []{}, nullptr}; }
+  byte_pool pool() {
+    return {bytes_, _Sz, [] {}, nullptr};
+  }
 };
 
 struct arena {
-  function<byte*(size_t)> new_bytes_;         // new byte-array factory
-  function<void(void*, size_t)> del_bytes_;   // byte-array destroyer
-  byte_pool* curr_pool_;                      // byte pool currently "in effect"
-  byte_pool* next_pool_;                      // allocated (from curr_pool_) but not initialized
-  size_t allocs_ {};                          // number of successful allocations
-  size_t deallocs_ {};                        // incremented on each dealloc; dtor ensures these are equal!
+  function<byte*(size_t)> new_bytes_;       // new byte-array factory
+  function<void(void*, size_t)> del_bytes_; // byte-array destroyer
+  byte_pool* curr_pool_;                    // byte pool currently "in effect"
+  byte_pool* next_pool_;                    // allocated (from curr_pool_) but not initialized
+  size_t allocs_{};                         // number of successful allocations
+  size_t deallocs_{};                       // incremented on each dealloc; dtor ensures these are equal!
 
   // An arena is scoped to a `basic_stacktrace::current` invocation, so this is usable by only one thread.
   // Additionally, it's used internally throughout many function calls, so for convenience, store it here.
@@ -108,11 +107,14 @@ struct arena {
     _LIBCPP_ASSERT(active_arena_ptr_ == this, "different arena unexpectively set as the active one");
     active_arena_ptr_ = nullptr;
     _LIBCPP_ASSERT(deallocs_ == allocs_, "destructed arena still has live objects");
-    while (curr_pool_) { curr_pool_->destroy_(); curr_pool_ = curr_pool_->link_; }
+    while (curr_pool_) {
+      curr_pool_->destroy_();
+      curr_pool_ = curr_pool_->link_;
+    }
   }
 
   arena(auto&& __new_bytes, auto&& __del_bytes, byte_pool& __initial_pool) noexcept
-    : new_bytes_(__new_bytes), del_bytes_(__del_bytes), curr_pool_(&__initial_pool) {
+      : new_bytes_(__new_bytes), del_bytes_(__del_bytes), curr_pool_(&__initial_pool) {
     prep_next_pool();
     _LIBCPP_ASSERT(!active_arena_ptr_, "already an active arena");
     active_arena_ptr_ = this;
@@ -125,24 +127,25 @@ struct arena {
 
   template <class _UA>
   arena(byte_pool& __initial_pool, _UA const& __user_alloc)
-    : arena(
-      [&__user_alloc] (size_t __sz) { return as_byte_alloc(__user_alloc).allocate(__sz); },
-      [&__user_alloc] (void* __ptr, size_t __sz) { return as_byte_alloc(__user_alloc).deallocate((byte*)__ptr, __sz); },
-      __initial_pool) {}
+      : arena([&__user_alloc](size_t __sz) { return as_byte_alloc(__user_alloc).allocate(__sz); },
+              [&__user_alloc](void* __ptr, size_t __sz) {
+                return as_byte_alloc(__user_alloc).deallocate((byte*)__ptr, __sz);
+              },
+              __initial_pool) {}
 
   arena(arena const&)            = delete;
   arena& operator=(arena const&) = delete;
 
   void prep_next_pool() noexcept {
     // Allocate (via current pool) a new byte_pool record, while we have enough space.
     // When the current pool runs out of space, this one will be ready to use.
-    next_pool_ = (byte_pool*) (*curr_pool_)(sizeof(byte_pool), alignof(byte_pool));
+    next_pool_ = (byte_pool*)(*curr_pool_)(sizeof(byte_pool), alignof(byte_pool));
     _LIBCPP_ASSERT(next_pool_, "could not allocate next pool");
   }
 
   void expand(size_t __atleast) noexcept {
     constexpr static size_t __k_default_new_pool = 1 << 12;
-    auto __size = max(__atleast, __k_default_new_pool);
+    auto __size                                  = max(__atleast, __k_default_new_pool);
     // "next_pool_" was already allocated, just need to initialize it
     auto* __bytes = new_bytes_(__size);
     _LIBCPP_ASSERT(__bytes, "could not allocate more bytes for arena");
@@ -155,12 +158,14 @@ struct arena {
 
   std::byte* alloc(size_t __size, size_t __align) noexcept {
     auto* __ret = (*curr_pool_)(__size, __align);
-    if (__ret) [[likely]] { goto success; }
+    if (__ret) [[likely]] {
+      goto success;
+    }
     // Need a new pool to accommodate this request + internal structs
     expand(__size + __align + sizeof(byte_pool) + alignof(byte_pool)); // upper bound
     __ret = (*curr_pool_)(__size, __align);
     _LIBCPP_ASSERT(__ret, "arena failed to allocate");
-success:
+  success:
     ++allocs_;
     return __ret;
   }
@@ -181,31 +186,6 @@ struct alloc {
   }
 };
 
-template <typename _Tp, size_t _Sz>
-struct fixed_buf {
-  using value_type = _Tp;
-  template <typename _Up> struct rebind { using other = fixed_buf<_Up, _Sz>; };
-
-  _Tp __buf_[_Sz];
-  size_t __size_;
-  void deallocate(_Tp*, size_t) {}
-  _Tp* allocate(size_t) { return __buf_; }
-};
-
-template <size_t _Sz>
-struct fixed_str : std::basic_string<char, std::char_traits<char>, fixed_buf<char, _Sz>> {
-  using _Base _LIBCPP_NODEBUG = std::basic_string<char, std::char_traits<char>, fixed_buf<char, _Sz>>;
-  using _Base::operator=;
-
-  fixed_buf<char, _Sz> __fb_;
-  fixed_str() : _Base(__fb_) {
-    this->resize(_Sz - 1);
-    this->resize(0);
-  }
-  fixed_str(fixed_str const& __rhs) : fixed_str() { _Base::operator=(__rhs); }
-  fixed_str& operator=(fixed_str const& __rhs) = default;
-};
-
 struct str : std::basic_string<char, std::char_traits<char>, alloc<char>> {
   using _Base _LIBCPP_NODEBUG = std::basic_string<char, std::char_traits<char>, alloc<char>>;
   using _Base::basic_string;
@@ -236,7 +216,47 @@ struct str : std::basic_string<char, std::char_traits<char>, alloc<char>> {
   }
 };
 
-// clang-format on
+/** A string that contains its own fixed-size, fixed-location buffer. */
+template <size_t _Sz>
+struct fixed_str final {
+  size_t __size_{0};
+  char __buf_[_Sz]{0};
+
+  ~fixed_str() = default;
+  fixed_str()  = default;
+
+  size_t size() const { return __size_; }
+  bool empty() const { return !size(); }
+  auto* data(this auto& __self) { return __self.__buf_; }
+  operator std::string_view() const { return {__buf_, __size_}; }
+
+  fixed_str& operator=(std::string_view __sv) {
+    strncpy(__buf_, __sv.data(), std::min(_Sz, __sv.size() + 1));
+    __size_         = __sv.size();
+    __buf_[__size_] = 0;
+    return *this;
+  }
+
+  fixed_str(auto const& __rhs) : fixed_str() { *this = __rhs; }
+  fixed_str& operator=(auto const& __rhs) { return (*this = std::string_view(__rhs)); }
+
+  template <size_t _S2>
+    requires requires { _S2 <= _Sz; }
+  fixed_str& operator=(fixed_str<_S2> const& __rhs) {
+    return (*this = std::string_view(__rhs));
+  }
+
+  template <size_t _S2>
+    requires requires { _S2 <= _Sz; }
+  fixed_str(fixed_str<_S2> const& __rhs) {
+    *this = std::string_view(__rhs);
+  }
+
+  fixed_str(fixed_str const& __rhs) { *this = std::string_view(__rhs); }
+  fixed_str& operator=(fixed_str const& __rhs) { return (*this = std::string_view(__rhs)); }
+
+  friend std::ostream& operator<<(std::ostream& __os, fixed_str const& __f) { return __os << std::string_view(__f); }
+};
 
 } // namespace __stacktrace
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/stacktrace/images.cpp

@@ -11,6 +11,7 @@
 //
 
 #include "__config"
+
 #if defined(__APPLE__)
 // MacOS-specific: use the `dyld` loader to access info about loaded Mach-O images.
 #  include <__stacktrace/images.h>

libcxx/src/stacktrace/impl_generic.cpp

@@ -101,11 +101,10 @@ _LIBCPP_EXPORTED_FROM_ABI void base::find_symbols(arena& arena) {}
 
 _LIBCPP_EXPORTED_FROM_ABI void base::find_source_locs(arena& arena) {
 #  if __has_include(<spawn.h>) && _LIBCPP_STACKTRACE_ALLOW_TOOLS_AT_RUNTIME
-  (void)(false                                        //
-         || __run_tool<atos>(*this, arena)            // preferred on MacOS
-         || __run_tool<llvm_symbolizer>(*this, arena) // prefer this in other (non-MacOS, non-Windows)
-         || __run_tool<addr2line>(*this, arena)       // a good fallback; dev machines tend to have gcc if not llvm
-  );
+  (void)(false                                                                                         //
+         || (__has_working_executable<atos>() && __run_tool<atos>(*this, arena))                       //
+         || (__has_working_executable<llvm_symbolizer>() && __run_tool<llvm_symbolizer>(*this, arena)) //
+         || (__has_working_executable<addr2line>() && __run_tool<addr2line>(*this, arena)));           //
 #  endif
 }
 

libcxx/src/stacktrace/tools/apple_atos.cpp

@@ -71,7 +71,7 @@ template<> bool _LIBCPP_EXPORTED_FROM_ABI __run_tool<atos>(base& base, arena& ar
   spawner spawner{tool, base};
   if (spawner.errno_) { return false; }
 
-  fixed_str<PATH_MAX * 2> line;               // our read buffer
+  str line;                                   // our read buffer
   auto* entry_iter = base.entries_begin();    // position at first entry
   while (spawner.stream_.good()) {            // loop until we get EOF from tool stdout
     std::getline(spawner.stream_, line);      // consume a line from stdout

libcxx/src/stacktrace/tools/gnu_addr2line.cpp

@@ -106,7 +106,7 @@ template<> bool _LIBCPP_EXPORTED_FROM_ABI __run_tool<addr2line>(base& base, aren
   spawner spawner{tool, base};
   if (spawner.errno_) { return false; }
 
-  fixed_str<PATH_MAX * 2> line;               // our read buffer
+  str line                    ;               // our read buffer
   auto* entry_iter = base.entries_begin();    // position at first entry
   while (spawner.stream_.good()) {            // loop until we get EOF from tool stdout
     std::string_view view;

libcxx/src/stacktrace/tools/llvm_symbolizer.cpp

@@ -38,8 +38,7 @@ bool llvm_symbolizer::build_argv() {
   while (it != end) {
     auto& entry = *(entry_base*)(it++);
     if (entry.__image_ && !entry.__image_->name_.empty()) {
-      fixed_str<PATH_MAX> image_path = entry.__image_->name_;
-      push_arg("FILE:%s %p", image_path.data(), (void*)entry.adjusted_addr());
+      push_arg("FILE:%s %p", entry.__image_->name_.data(), (void*)entry.adjusted_addr());
     } else {
       push_arg("%p", (void*)entry.adjusted_addr());
     }
@@ -89,7 +88,7 @@ template<> bool _LIBCPP_EXPORTED_FROM_ABI __run_tool<llvm_symbolizer>(base& base
   spawner spawner{tool, base};
   if (spawner.errno_) { return false; }
 
-  fixed_str<PATH_MAX * 2> line;                 // our read buffer
+  str line;                                     // our read buffer
   auto* entry_iter = base.entries_begin() - 1;  // "before first" entry
   while (spawner.stream_.good()) {              // loop until we get EOF from tool stdout
     std::getline(spawner.stream_, line);        // consume a line from stdout

libcxx/src/stacktrace/tools/tools.h

@@ -117,7 +117,7 @@ struct file_actions {
   optional<posix_spawn_file_actions_t> fa_{};
   fd stdout_read_;  // read end of subprocess's stdout, IFF redir_stdout used
   fd stdout_write_; // write end of subprocess's stdout, IFF redir_stdout used
-  errno_t errno_{}; // set to nonzero if any of these C calls failed
+  int errno_{};     // set to nonzero if any of these C calls failed
 
   bool failed() const { return errno_; }
 
@@ -223,8 +223,8 @@ struct sigchld_enable {
 
 struct pid_waiter {
   pid_t pid_{};
-  int status_{};    // value is valid iff wait() completed
-  errno_t errno_{}; // set to nonzero if any of these C calls failed
+  int status_{}; // value is valid iff wait() completed
+  int errno_{};  // set to nonzero if any of these C calls failed
   bool done_{};
 
   operator pid_t() const { return pid_; }
@@ -271,7 +271,7 @@ struct spawner {
   fd::istream stream_;         // istream interface from which we can `getline`
   sigchld_enable chld_enable_; // temporarily enables SIGCHLD so `waitpid` works
   pid_waiter pid_{0};          // set during successful `spawn`, can `waitpid` automatically
-  errno_t errno_{};            // set to nonzero if any of these C calls failed
+  int errno_{};                // set to nonzero if any of these C calls failed
 
   bool failed() const { return errno_; }
 
@@ -346,7 +346,7 @@ template <>
 bool _LIBCPP_EXPORTED_FROM_ABI __run_tool<atos>(base&, arena&);
 
 struct llvm_symbolizer : tool_base {
-  constexpr static char const* __default_prog_name = "llvm_symbolizer";
+  constexpr static char const* __default_prog_name = "llvm-symbolizer";
   constexpr static char const* __override_prog_env = "LIBCXX_STACKTRACE_FORCE_LLVM_SYMBOLIZER_PATH";
 
   llvm_symbolizer(base& base, arena& arena) : tool_base{base, arena, __executable_name<llvm_symbolizer>::get()} {}