break up other impl's

Author: elsteveogrande

libcxx/src/stacktrace/builder.cpp

@@ -11,75 +11,44 @@
 
 #include <__stacktrace/base.h>
 
-#include "stacktrace/config.h"
 #include "stacktrace/linux.h"
 #include "stacktrace/macos.h"
 #include "stacktrace/tools.h"
 #include "stacktrace/unwind.h"
-#include "stacktrace/utils/debug.h"
-#include "stacktrace/utils/failed.h"
-#include "stacktrace/utils/fd.h"
-#include "stacktrace/win/dll.h"
 #include "stacktrace/win/impl.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __stacktrace {
 
 _LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE void builder::build_stacktrace(size_t skip, size_t max_depth) {
-  /*
-  Here we declare stacktrace components or "backends" which will handle the different tasks:
-
-  (1) get the addresses from the call stack
-  (2) identify program images in process virtual space (program binary, plus modules, shared/dynamic libs)
-  (3) resolve using debug info, and possibly with an external tool on the $PATH
-  (4+) extra passes to get symbols, in case 3 couldn't
-
-  Based on the macros defined in `config.h`, throw all backends we have available at the task.  Ideally the #ifdef
-  gauntlet below should result in one of each of the above functions: (1) collector, (2) mod_ident, (3) resolver, (4)
-  symbolizer.  If any are missing or duplicated that is still fine; we work with zero or all the available utilities.
-
-  All these classes do their best to provide any of the requested fields they can: symbol, filename, source line,
-  substituting if needed with something reasonable.  For example, if the source filename and line are not available
-  then we will at least report that the address and symbol are in the module `c:\path\foo.exe`.
-
-  These components should also tolerate: missing data, weirdly-formatted data (e.g. from the external tools), or even
-  already-populated data.  We take care not to crash / abort / throw in any of these, and we'll silently fail.  See
-  `common/debug.h` for a debugging logger you can enable at runtime.
-  */
-
-#if defined(_LIBCPP_STACKTRACE_WINDOWS)
+  // First get the instruction addresses, populate __entries_
   win_impl dbghelp{*this};
-  auto& collector  = dbghelp;
-  auto& mod_ident  = dbghelp;
-  auto& resolver   = dbghelp;
-  auto& symbolizer = dbghelp;
-#endif
-#if defined(_LIBCPP_STACKTRACE_COLLECT_UNWIND)
   unwind unwind{*this};
-  auto& collector = unwind;
-#endif
-#if defined(_LIBCPP_STACKTRACE_MACOS)
+  dbghelp.collect(skip + 1, max_depth);
+  unwind.collect(skip + 1, max_depth);
+
+  // (Can't proceed if empty)
+  if (!__entries_.size()) {
+    return;
+  }
+
+  // Associate addrs with binaries (ELF/MachO/etc.)
   macos macos{*this};
-  auto& mod_ident  = macos;
-  auto& symbolizer = macos;
-#endif
-#if defined(_LIBCPP_STACKTRACE_LINUX)
   linux linux{*this};
-  auto& mod_ident  = linux;
-  auto& symbolizer = linux;
-#endif
-#if defined(_LIBCPP_STACKTRACE_CAN_SPAWN_TOOLS)
+  dbghelp.ident_modules();
+  macos.ident_modules();
+  linux.ident_modules();
+
+  // Resolve addresses to symbols, filename, linenumber
   spawner pspawn{*this};
-  auto& resolver = pspawn;
-#endif
+  dbghelp.resolve_lines();
+  pspawn.resolve_lines();
 
-  collector.collect(skip + 1, max_depth); // First get the instruction addresses, populate __entries_
-  if (__entries_.size()) {                // (Can't proceed if empty)
-    mod_ident.ident_modules();            // Associate addrs with binaries (ELF/MachO/etc.)
-    resolver.resolve_lines();             // Resolve addresses to symbols, filename, linenumber
-    symbolizer.symbolize();               // Populate missing symbols, if any.
-  }
+  // Populate missing symbols, if any.
+  dbghelp.symbolize();
+  macos.symbolize();
+  linux.symbolize();
 }
 
 } // namespace __stacktrace

libcxx/src/stacktrace/linux.cpp

@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "stacktrace/linux.h"
 #include "stacktrace/config.h"
 
 #if defined(_LIBCPP_STACKTRACE_LINUX)
@@ -16,11 +17,9 @@
 #  include <stacktrace>
 #  include <unistd.h>
 
-#  include <__stacktrace/base.h>
-
 #  include "stacktrace/config.h"
-#  include "stacktrace/linux.h"
-#  include "stacktrace/utils.h"
+#  include "stacktrace/utils/fd.h"
+#  include "stacktrace/utils/image.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace __stacktrace {
@@ -112,4 +111,16 @@ void linux::symbolize() {
 } // namespace __stacktrace
 _LIBCPP_END_NAMESPACE_STD
 
+#else
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __stacktrace {
+
+void linux::ident_modules() {}
+void linux::symbolize() {}
+void linux::resolve_main_elf_syms(std::string_view main_elf_name) {}
+
+} // namespace __stacktrace
+_LIBCPP_END_NAMESPACE_STD
+
 #endif // _LIBCPP_STACKTRACE_LINUX

libcxx/src/stacktrace/linux.h

@@ -9,6 +9,23 @@
 #ifndef _LIBCPP_STACKTRACE_LINUX_H
 #define _LIBCPP_STACKTRACE_LINUX_H
 
+#include <__stacktrace/base.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __stacktrace {
+
+struct linux {
+  builder& builder_;
+  void ident_modules();
+  void symbolize();
+
+private:
+  void resolve_main_elf_syms(std::string_view elf_name);
+};
+
+} // namespace __stacktrace
+_LIBCPP_END_NAMESPACE_STD
+
 #include "stacktrace/config.h"
 
 #if defined(_LIBCPP_STACKTRACE_LINUX)
@@ -23,30 +40,18 @@
 #  include <string_view>
 #  include <unistd.h>
 
-#  include <__stacktrace/base.h>
-
-#  include "stacktrace/config.h"
-#  include "stacktrace/utils.h"
+#  include "stacktrace/utils/image.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace __stacktrace {
 
-struct linux {
-  builder& builder_;
-  void ident_modules();
-  void symbolize();
-
-private:
-  void resolve_main_elf_syms(std::string_view elf_name);
-};
-
 struct images {
   // How many images this contains, including the left/right sentinels.
   unsigned count_{0};
-  std::array<image, k_max_images + 2> images_{};
+  std::array<image, image::kMaxImages + 2> images_{};
 
   int add(dl_phdr_info& info) {
-    assert(count_ < k_max_images);
+    assert(count_ < image::kMaxImages);
     auto isFirst        = (count_ == 0);
     auto& image         = images_.at(count_++);
     image.loaded_at_    = info.dlpi_addr;
@@ -60,7 +65,7 @@ struct images {
         image.name_ = buffer;
       }
     }
-    return count_ == k_max_images; // return nonzero if we're at the limit
+    return count_ == image::kMaxImages; // return nonzero if we're at the limit
   }
 
   static int callback(dl_phdr_info* info, size_t, void* self) { return (*(images*)(self)).add(*info); }

libcxx/src/stacktrace/macos.cpp

@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "stacktrace/macos.h"
 #include "stacktrace/config.h"
 
 #if defined(_LIBCPP_STACKTRACE_MACOS)
@@ -18,44 +19,34 @@
 
 #  include <__stacktrace/base.h>
 
-#  include "stacktrace/macos.h"
+#  include "stacktrace/utils/image.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace __stacktrace {
 
-constexpr unsigned kMaxImages = 256;
-
-struct Image {
-  uintptr_t loadedAt{};
-  intptr_t slide{};
-  std::string_view name{};
-  bool operator<(Image const& rhs) const { return loadedAt < rhs.loadedAt; }
-  operator bool() const { return !name.empty(); }
-};
-
-void ident_module(alloc& alloc, entry_base& entry, unsigned& index, Image* images) {
+void ident_module(alloc& alloc, entry_base& entry, unsigned& index, image* images) {
   if (entry.__addr_actual_) {
-    while (images[index].loadedAt > entry.__addr_actual_) {
+    while (images[index].loaded_at_ > entry.__addr_actual_) {
       --index;
     }
-    while (images[index + 1].loadedAt <= entry.__addr_actual_) {
+    while (images[index + 1].loaded_at_ <= entry.__addr_actual_) {
       ++index;
     }
     auto& image = images[index];
     if (image) {
-      entry.__addr_unslid_ = entry.__addr_actual_ - images[index].slide;
-      entry.__file_        = alloc.make_str(images[index].name);
+      entry.__addr_unslid_ = entry.__addr_actual_ - images[index].slide_;
+      entry.__file_        = alloc.make_str(images[index].name_);
     }
   }
 }
 
 bool enum_modules(unsigned& count, auto& images) {
-  count = std::min(kMaxImages, _dyld_image_count());
+  count = std::min(image::kMaxImages, size_t(_dyld_image_count()));
   for (size_t i = 0; i < count; i++) {
-    auto& image    = images[i];
-    image.slide    = _dyld_get_image_vmaddr_slide(i);
-    image.loadedAt = uintptr_t(_dyld_get_image_header(i));
-    image.name     = _dyld_get_image_name(i);
+    auto& image      = images[i];
+    image.slide_     = _dyld_get_image_vmaddr_slide(i);
+    image.loaded_at_ = uintptr_t(_dyld_get_image_header(i));
+    image.name_      = _dyld_get_image_name(i);
   }
   images[count++] = {0uz, 0};  // sentinel at low end
   images[count++] = {~0uz, 0}; // sentinel at high end
@@ -65,7 +56,7 @@ bool enum_modules(unsigned& count, auto& images) {
 
 void macos::ident_modules() {
   static unsigned imageCount;
-  static std::array<Image, kMaxImages + 2> images;
+  static std::array<image, image::kMaxImages + 2> images;
   static bool atomicInitialized = enum_modules(imageCount, images);
   (void)atomicInitialized;
 
@@ -76,7 +67,7 @@ void macos::ident_modules() {
   }
 
   // First image (the main program) is at index 1
-  builder_.__main_prog_path_ = builder_.__alloc_.make_str(images.at(1).name);
+  builder_.__main_prog_path_ = builder_.__alloc_.make_str(images.at(1).name_);
 
   unsigned index = 1; // Starts at one, and is moved by 'ident_module'
   for (auto& entry : builder_.__entries_) {
@@ -107,4 +98,15 @@ void macos::symbolize() {
 } // namespace __stacktrace
 _LIBCPP_END_NAMESPACE_STD
 
+#else
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __stacktrace {
+
+void macos::ident_modules() {}
+void macos::symbolize() {}
+
+} // namespace __stacktrace
+_LIBCPP_END_NAMESPACE_STD
+
 #endif // _LIBCPP_STACKTRACE_MACOS

libcxx/src/stacktrace/tools.cpp

@@ -28,7 +28,6 @@
 #  include <__stacktrace/entry.h>
 
 #  include "stacktrace/tools.h"
-#  include "stacktrace/utils.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace __stacktrace {

libcxx/src/stacktrace/utils/image.h

@@ -10,23 +10,21 @@
 #define _LIBCPP_STACKTRACE_UTILS_IMAGE
 
 #include <__config>
-#include <cerrno>
-#include <string_view>
-#include <unistd.h>
+#include <__stacktrace/base.h>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace __stacktrace {
 
-constexpr unsigned k_max_images = 256;
+struct image {
+  constexpr static size_t kMaxImages = 256;
 
-struct _LIBCPP_HIDE_FROM_ABI image {
   uintptr_t loaded_at_{};
   intptr_t slide_{};
   std::string_view name_{};
   bool is_main_prog_{};
 
-  _LIBCPP_HIDE_FROM_ABI bool operator<(image const& rhs) const { return loaded_at_ < rhs.loaded_at_; }
-  _LIBCPP_HIDE_FROM_ABI operator bool() const { return !name_.empty(); }
+  bool operator<(image const& rhs) const { return loaded_at_ < rhs.loaded_at_; }
+  operator bool() const { return !name_.empty(); }
 };
 
 } // namespace __stacktrace

libcxx/src/stacktrace/win/impl.cpp

@@ -6,8 +6,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "stacktrace/win/impl.h"
 #include <__config>
 
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __stacktrace {
+std::mutex win_impl::mutex_;
+} // namespace __stacktrace
+_LIBCPP_END_NAMESPACE_STD
+
 #if defined(_LIBCPP_WIN32API)
 // windows.h must be first
 #  include <windows.h>
@@ -34,7 +41,6 @@ so we claim a lock in the `WinDebugAPIs` constructor.
 */
 
 // Statically-initialized
-std::mutex gWindowsAPILock;
 DbgHelpDLL dbg;
 PSAPIDLL ps;
 
@@ -53,7 +59,7 @@ size_t moduleCount; // 0 IFF module enumeration failed
 
 } // namespace
 
-win_impl::WinDebugAPIs(builder& trace) : builder_(trace), guard_(gWindowsAPILock) {
+win_impl::global_init() {
   if (!globalInitialized) {
     // Cannot proceed without these DLLs:
     if (!dbg) {
@@ -84,7 +90,7 @@ win_impl::WinDebugAPIs(builder& trace) : builder_(trace), guard_(gWindowsAPILock
   (*dbg.SymSetOptions)(symOptions);
 }
 
-win_impl::~WinDebugAPIs() {
+win_impl::~win_impl() {
   if (symsInitialized) {
     (*dbg.SymCleanup)(proc);
     symsInitialized = false;
@@ -204,15 +210,15 @@ _LIBCPP_END_NAMESPACE_STD
 
 // Not_LIBCPP_WIN32API
 
-#  include "stacktrace/win/impl.h"
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace __stacktrace {
 
+void win_impl::global_init() {}
 void win_impl::collect(size_t skip, size_t max_depth) {}
 void win_impl::ident_modules() {}
 void win_impl::symbolize() {}
 void win_impl::resolve_lines() {}
+win_impl::~win_impl() {}
 
 } // namespace __stacktrace
 _LIBCPP_END_NAMESPACE_STD