backtrace.cpp

#include "crucible/core/backtrace.inl"

#include "crucible/core/format.inl"

#include <cstddef>
#include <cstring>
#include <mutex>
#include <utility>

#ifdef CRUCIBLE_PLATFORM_IS_POSIX_LIKE
#include "crucible/core/demangle.inl"

#include <dlfcn.h>
#include <execinfo.h>
#endif // CRUCIBLE_PLATFORM_IS_POSIX_LIKE

#ifdef CRUCIBLE_PLATFORM_IS_WINDOWS_LIKE
#include <Windows.h>
#include <DbgHelp.h>

#include <limits>
#include <optional>
#endif // CRUCIBLE_PLATFORM_IS_WINDOWS_LIKE

namespace crucible::core
{
  namespace
  {
    std::mutex backtrace_mutex;

#ifdef CRUCIBLE_PLATFORM_IS_POSIX_LIKE
    constexpr std::size_t MAXIMUM_STACK_FRAMES { 1024 };
#endif // CRUCIBLE_PLATFORM_IS_POSIX_LIKE

#ifdef CRUCIBLE_PLATFORM_IS_WINDOWS_LIKE
    constexpr std::size_t MAXIMUM_SYMBOL_LENGTH { 1024 };

    struct SymSetOptionsWarden
    {
      std::optional<::DWORD> original_options { std::nullopt };

      ~SymSetOptionsWarden();
    };

    SymSetOptionsWarden::~SymSetOptionsWarden()
    {
      if (original_options.has_value()) {
        ::SymSetOptions(original_options.value());
      }
    }

    struct SymCleanupWarden
    {
      std::optional<::HANDLE> process_handle { std::nullopt };

      ~SymCleanupWarden();
    };

    SymCleanupWarden::~SymCleanupWarden()
    {
      if (process_handle.has_value()) {
        ::SymCleanup(process_handle.value());
      }
    }
#endif // CRUCIBLE_PLATFORM_IS_WINDOWS_LIKE

  }

  auto Backtrace_Unavailable::describe() const -> String
  {
    return String { "Backtrace is unavailable (call stack may be corrupted)" };
  }

  auto Stack_Frame::describe() const -> String
  {
    String result { function };

    if (!location.is_empty()) {
      result += " at " + location;
    }

    if (!details.is_empty()) {
      result += " (" + details + ")";
    }

    return result;
  }

  auto backtrace() -> Backtrace_Result<Heap_Buffer<Stack_Frame>>
  {

#ifdef CRUCIBLE_PLATFORM_IS_POSIX_LIKE
    std::unique_lock<std::mutex> const backtrace_lock { backtrace_mutex };
    Heap_Buffer<Stack_Frame> result {};

    void *stack_data[MAXIMUM_STACK_FRAMES];
    int const stack_size { ::backtrace(stack_data, MAXIMUM_STACK_FRAMES) };

    if (stack_size <= 0) {
      return make_failure<Backtrace_Error>(Backtrace_Unavailable {});
    }

    for (int i { 0 }; i < stack_size; ++i) {
      ::Dl_info symbol_table_entry {};

      // Try to read out the symbol name from the dynamic symbol table
      if (::dladdr(stack_data[i], &symbol_table_entry) == 0) {
        Stack_Frame frame;
        frame.function = format_address(stack_data[i]);
        frame.details = "Failed to read symbol";
        result.push(frame);
        continue;
      }

      // Even if ::dladdr() succeeds, we can still end up with `dli_sname == nullptr`
      if (symbol_table_entry.dli_sname == nullptr) {
        Stack_Frame frame;
        frame.function = format_address(stack_data[i]);
        frame.details = "No associated symbol";
        result.push(frame);
        continue;
      }

      FFI_String<char> const mangled_symbol {
        symbol_table_entry.dli_sname,
        std::strlen(symbol_table_entry.dli_sname)
      };

      auto const handle_failure {
        [&mangled_symbol](Demangle_Error const &error) {
          Stack_Frame frame;
          frame.function = String { mangled_symbol.data(), mangled_symbol.size() };
          frame.details = error.describe();
          return frame;
        }
      };

      auto const handle_success {
        [](FFI_String<char> const &demangled_symbol) {
          Stack_Frame frame;
          frame.function = String { demangled_symbol.data(), demangled_symbol.size() };
          return frame;
        }
      };

      auto const frame = demangle(mangled_symbol)
        .resolve(handle_failure, handle_success);

      result.push(frame);
    }

    return make_success(std::move(result));
#endif // CRUCIBLE_PLATFORM_IS_POSIX_LIKE

#ifdef CRUCIBLE_PLATFORM_IS_WINDOWS_LIKE
    std::unique_lock<std::mutex> const backtrace_lock { backtrace_mutex };
    auto result { make_heap_buffer<Stack_Frame>() };

    ::DWORD original_options { ::SymGetOptions() };
    ::SymSetOptions(original_options | SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES);
    SymSetOptionsWarden const sym_set_options_warden { original_options };

    // Not sure where to put this, but: ::GetCurrentProcess() returns INVALID_HANDLE_VALUE... ON PURPOSE!!!
    // MSDN: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getcurrentprocess
    ::HANDLE process_handle { ::GetCurrentProcess() };

    if (::SymInitialize(process_handle, nullptr, TRUE) != TRUE) {
      return make_failure<Backtrace_Error>(SymInitialize_Failed {});
    }

    SymCleanupWarden const sym_cleanup_warden { process_handle };

    ::CONTEXT processor_context {};
    ::RtlCaptureContext(&processor_context);

    ::STACKFRAME64 stack_frame {};
    stack_frame.AddrPC.Offset = processor_context.Rip;
    stack_frame.AddrPC.Mode = ::AddrModeFlat;
    stack_frame.AddrFrame.Offset = processor_context.Rbp;
    stack_frame.AddrFrame.Mode = ::AddrModeFlat;
    stack_frame.AddrStack.Offset = processor_context.Rsp;
    stack_frame.AddrStack.Mode = ::AddrModeFlat;

    ::DWORD unused32 { 0 };
    ::DWORD64 unused64 { 0 };

    // BARK BARK BARK BARK BARK
    alignas(::IMAGEHLP_SYMBOL64) std::byte symbol_storage[sizeof(::IMAGEHLP_SYMBOL64) + MAXIMUM_SYMBOL_LENGTH];
    ::IMAGEHLP_SYMBOL64 *symbol { new (&symbol_storage) ::IMAGEHLP_SYMBOL64 };

    do {
      ::BOOL const have_next_frame = ::StackWalk64(
        IMAGE_FILE_MACHINE_AMD64,
        ::GetCurrentProcess(),
        ::GetCurrentThread(),
        &stack_frame,
        &processor_context,
        nullptr,
        ::SymFunctionTableAccess64,
        ::SymGetModuleBase64,
        nullptr
      );

      if (have_next_frame != TRUE) {
        Stack_Frame frame;
        frame.function = format_unsigned_hexadecimal(stack_frame.AddrPC.Offset);
        frame.details = "Failed to find stack frame";
        result.push(frame);
        break;
      }

      symbol->SizeOfStruct = sizeof(::IMAGEHLP_SYMBOL64);
      symbol->MaxNameLength = MAXIMUM_SYMBOL_LENGTH;

      ::BOOL const have_next_symbol {
        ::SymGetSymFromAddr64(
          process_handle,
          stack_frame.AddrPC.Offset,
          &unused64,
          symbol
        )
      };

      if (have_next_symbol != TRUE) {
        Stack_Frame frame;
        frame.function = format_unsigned_hexadecimal(stack_frame.AddrPC.Offset);
        frame.details = "Failed to find symbol";
        result.push(frame);
        break;
      }

      ::IMAGEHLP_LINE64 line {};
      line.SizeOfStruct = sizeof(::IMAGEHLP_LINE64);

      ::BOOL const have_next_line {
        ::SymGetLineFromAddr64(
          process_handle,
          stack_frame.AddrPC.Offset,
          &unused32,
          &line
        )
      };

      if (have_next_line != TRUE) {
        Stack_Frame frame;
        frame.function = String { symbol->Name, std::strlen(symbol->Name) } + "()";
        frame.details = "Failed to find file and line";
        result.push(frame);
        continue;
      }

      CRUCIBLE_CORE_ASSERT_GE(line.LineNumber, 0u);
      CRUCIBLE_CORE_ASSERT_LE(static_cast<int>(line.LineNumber), std::numeric_limits<int>::max());

      String_View const file { line.FileName, std::strlen(line.FileName) };
      auto const relative_file { file.view().strip_prefix(CRUCIBLE_SOURCE_ROOT) };

      Stack_Frame frame;
      frame.function = String { symbol->Name, std::strlen(symbol->Name) } + "()";
      frame.location = relative_file + ":" + format_integral(line.LineNumber);
      result.push(frame);
    } while (stack_frame.AddrReturn.Offset != 0);

    return make_success(std::move(result));
#endif // CRUCIBLE_PLATFORM_IS_WINDOWS_LIKE

  }
}