drop 'debug'; fix windows

Author: elsteveogrande

libcxx/include/__stacktrace/base.h

@@ -56,6 +56,11 @@ struct _LIBCPP_EXPORTED_FROM_ABI base {
     template <typename _T2 = _Tp>
     Alloc(Alloc<_T2> const& __rhs) : Alloc(__rhs.__alloc_bytes_, __rhs.__dealloc_bytes_) {}
 
+    Alloc()
+        : __alloc_bytes_([](size_t __sz) { return std::allocator<std::byte>().allocate(__sz); }),
+          __dealloc_bytes_([](std::byte* __ptr, size_t __sz) { std::allocator<std::byte>().deallocate(__ptr, __sz); }) {
+    }
+
     // XXX Alignment?
     using value_type = _Tp;
     [[nodiscard]] _Tp* allocate(size_t __sz) { return (_Tp*)__alloc_bytes_(__sz * sizeof(_Tp)); }

libcxx/src/stacktrace/config.h

@@ -8,13 +8,12 @@
 
 #if defined(__linux__)
 
+#  include <__stacktrace/base.h>
 #  include <cassert>
 #  include <dlfcn.h>
 #  include <link.h>
-#  include <stacktrace>
 #  include <unistd.h>
 
-#  include "stacktrace/config.h"
 #  include "stacktrace/linux/elf.h"
 #  include "stacktrace/linux/images.h"
 #  include "stacktrace/linux/impl.h"

libcxx/src/stacktrace/linux/impl.cpp

@@ -110,11 +110,6 @@ void spawner::resolve_lines() {
       proc.run();
       return true;
     } catch (failed const& failed) {
-      debug() << failed.what();
-      if (failed.errno_) {
-        debug() << " (" << failed.errno_ << " " << strerror(failed.errno_) << ')';
-      }
-      debug() << '\n';
     }
     return false;
   });

libcxx/src/stacktrace/tools/tools.cpp

@@ -27,7 +27,6 @@
 #include <__stacktrace/basic.h>
 #include <__stacktrace/entry.h>
 
-#include "stacktrace/utils/debug.h"
 #include "stacktrace/utils/failed.h"
 #include "stacktrace/utils/fd.h"
 
@@ -152,9 +151,7 @@ struct pspawn_tool : pspawn {
 
   pspawn_tool(tool const& a2l, base& trace, char* buf, size_t size)
       : pspawn{a2l}, base_(trace), fd_(fa_.redirectOutFD()), buf_(fd_, buf, size), stream_(buf_) {
-    if (!debug::enabled()) {
-      fa_.redirectErrNull();
-    }
+    fa_.redirectErrNull();
     fa_.redirectInNull();
   }
 
@@ -167,14 +164,6 @@ struct pspawn_tool : pspawn {
     }
 
     auto argStrings = tool_.buildArgs(base_);
-    if (debug::enabled()) {
-      debug() << "Trying to get stacktrace using:";
-      for (auto& str : argStrings) {
-        debug() << " \"" << str << '"';
-      }
-      debug() << '\n';
-    }
-
     spawn(argStrings);
 
     auto end = base_.__entries_.end();

libcxx/src/stacktrace/tools/tools.h

@@ -12,9 +12,6 @@
 
 #  include <__stacktrace/base.h>
 
-#  include "stacktrace/base.h"
-#  include "stacktrace/config.h"
-#  include "stacktrace/utils.h"
 #  include "stacktrace/windows/dll.h"
 #  include "stacktrace/windows/impl.h"
 
@@ -23,188 +20,29 @@ namespace __stacktrace {
 
 namespace {
 
-/*
-Global objects, shared among all threads and among all stacktrace operations.
-The `dbghelp` APIs are not safe to call concurrently (according to their docs)
-so we claim a lock in the `WinDebugAPIs` constructor.
-*/
-
-// Statically-initialized
-std::mutex gWindowsAPILock;
-DbgHelpDLL dbg;
-PSAPIDLL ps;
-
-// Initialized once, in first WinDebugAPIs construction;
-// protected by the above mutex.
+// Initialized once, in first `win_impl` construction.
+// Protected by mutex within the `win_impl` constructor.
 HANDLE proc;
 HMODULE exe;
 IMAGE_NT_HEADERS* ntHeaders;
 bool globalInitialized{false};
 
 // Globals used across invocations of the functions below.
-// Also guarded by the above mutex.
+// Protected by mutex within the `win_impl` constructor.
 bool symsInitialized{false};
 HMODULE moduleHandles[1024];
 size_t moduleCount; // 0 IFF module enumeration failed
 
 } // namespace
 
-win_impl::WinDebugAPIs(base& trace) : base_(trace), guard_(gWindowsAPILock) {
-  if (!globalInitialized) {
-    // Cannot proceed without these DLLs:
-    if (!dbg) {
-      return;
-    }
-    if (!ps) {
-      return;
-    }
-    proc = GetCurrentProcess();
-    if (!(exe = GetModuleHandle(nullptr))) {
-      return;
-    }
-    if (!(ntHeaders = (*dbg.ImageNtHeader)(exe))) {
-      return;
-    }
-
-    globalInitialized = true;
-  }
-
-  // Initialize symbol machinery.
-  // Presumably the symbols in this process's space can change between
-  // stacktraces, so we'll do this each time we take a trace.
-  // The final `true` means we want the runtime to enumerate all this
-  // process's modules' symbol tables.
-  symsInitialized  = (*dbg.SymInitialize)(proc, nullptr, true);
-  DWORD symOptions = (*dbg.SymGetOptions)();
-  symOptions |= SYMOPT_LOAD_LINES | SYMOPT_UNDNAME;
-  (*dbg.SymSetOptions)(symOptions);
-}
-
-win_impl::~WinDebugAPIs() {
-  if (symsInitialized) {
-    (*dbg.SymCleanup)(proc);
-    symsInitialized = false;
-  }
-}
-
-void win_impl::ident_modules() {
-  if (!globalInitialized) {
-    return;
-  }
-  DWORD needBytes;
-  auto enumMods = (*ps.EnumProcessModules)(proc, moduleHandles, sizeof(moduleHandles), LPDWORD(&needBytes));
-  if (enumMods) {
-    moduleCount = needBytes / sizeof(HMODULE);
-  } else {
-    moduleCount = 0;
-    Debug() << "EnumProcessModules failed: " << GetLastError() << '\n';
-  }
-}
-
-void win_impl::symbolize() {
-  // Very long symbols longer than this amount will be truncated.
-  static constexpr size_t kMaxSymName = 256;
-  if (!globalInitialized) {
-    return;
-  }
-
-  for (auto& entry : base_.__entries_) {
-    char space[sizeof(IMAGEHLP_SYMBOL64) + kMaxSymName];
-    auto* sym          = (IMAGEHLP_SYMBOL64*)space;
-    sym->SizeOfStruct  = sizeof(IMAGEHLP_SYMBOL64);
-    sym->MaxNameLength = kMaxSymName;
-    uint64_t disp{0};
-    if ((*dbg.SymGetSymFromAddr64)(proc, entry.__addr_actual_, &disp, sym)) {
-      // Copy chars into the destination string which uses the caller-provided allocator.
-      ((entry_base&)entry).__desc_ = {sym->Name};
-    } else {
-      Debug() << "SymGetSymFromAddr64 failed: " << GetLastError() << '\n';
-    }
-  }
-}
-
-void win_impl::resolve_lines() {
-  if (!globalInitialized) {
-    return;
-  }
-
-  for (auto& entry : base_.__entries_) {
-    DWORD disp{0};
-    IMAGEHLP_LINE64 line;
-    line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
-    if ((*dbg.SymGetLineFromAddr64)(proc, entry.__addr_actual_, &disp, &line)) {
-      // Copy chars into the destination string which uses the caller-provided allocator.
-      entry.__file_ = line.FileName;
-      entry.__line_ = line.LineNumber;
-    } else {
-      Debug() << "SymGetLineFromAddr64 failed: " << GetLastError() << '\n';
-    }
-  }
-}
-
-/*
-Inlining is disabled from here on;
-this is to ensure `collect` below doesn't get merged into its caller
-and mess around with the top of the stack (making `skip` inaccurate).
-*/
-#  pragma auto_inline(off)
-
-_LIBCPP_NO_TAIL_CALLS _LIBCPP_NOINLINE void win_impl::collect(size_t skip, size_t max_depth) {
-  if (!globalInitialized) {
-    return;
-  }
-
-  auto thread  = GetCurrentThread();
-  auto machine = ntHeaders->FileHeader.Machine;
-
-  CONTEXT ccx;
-  RtlCaptureContext(&ccx);
-
-  STACKFRAME64 frame;
-  memset(&frame, 0, sizeof(frame));
-  frame.AddrPC.Mode      = AddrModeFlat;
-  frame.AddrStack.Mode   = AddrModeFlat;
-  frame.AddrFrame.Mode   = AddrModeFlat;
-  frame.AddrPC.Offset    = ctrace.Rip;
-  frame.AddrStack.Offset = ctrace.Rsp;
-  frame.AddrFrame.Offset = ctrace.Rbp;
-
-  while (max_depth &&
-         (*dbg.StackWalk64)(
-             machine,
-             proc,
-             thread,
-             &frame,
-             &ccx,
-             nullptr,
-             dbg.SymFunctionTableAccess64,
-             dbg.SymGetModuleBase64,
-             nullptr)) {
-    if (skip) {
-      --skip;
-      continue;
-    }
-    --max_depth;
-    auto& entry = base_.__entries_.emplace_back();
-    // We don't need to compute the un-slid addr; windbg only needs the actual addresses.
-    // Assume address is of the instruction after a call instruction, since we can't
-    // differentiate between a signal, SEH exception handler, or a normal function call.
-    entry.__addr_actual_ = frame.AddrPC.Offset - 1; // Back up 1 byte to get into prev insn range
-  }
-}
-
 dll::~dll() { FreeLibrary(module_); }
 
-dll::dll(char const* name) : name_(name), module_(LoadLibrary(name)) {
-  if (!module_) {
-    debug() << "LoadLibrary failed: " << name_ << ": " << GetLastError() << '\n';
-  }
-}
+dll::dll(char const* name) : name_(name), module_(LoadLibrary(name)) {}
 
 dbghelp_dll::~dbghelp_dll() = default;
 
 dbghelp_dll& dbghelp_dll::get() {
-  dbghelp_dll ret;
+  static dbghelp_dll ret;
   return ret;
 }
 
@@ -228,15 +66,15 @@ if (!get_func(&ImageNtHeader, "ImageNtHeader")) { return; }
 psapi_dll::~psapi_dll() = default;
 
 psapi_dll& psapi_dll::get() {
-  psapi_dll ret;
+  static psapi_dll ret;
   return ret;
 }
 
-psapi_dll() : dll("psapi.dll") {
+psapi_dll::psapi_dll() : dll("psapi.dll") {
   // clang-format off
-if (!getFunc(&EnumProcessModules, "EnumProcessModules")) { return; }
-  if (!getFunc(&GetModuleInformation, "GetModuleInformation")) { return; }
-  if (!getFunc(&GetModuleBaseName, "GetModuleBaseNameA")) { return; }
+if (!get_func(&EnumProcessModules, "EnumProcessModules")) { return; }
+  if (!get_func(&GetModuleInformation, "GetModuleInformation")) { return; }
+  if (!get_func(&GetModuleBaseName, "GetModuleBaseNameA")) { return; }
   valid_ = true;
   // clang-format on
 }