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)" };
  }

  Stack_Frame::Stack_Frame(String const &function, String const &file, String const &line, String const &details) :
    my_function { function },
    my_file { file },
    my_line { line },
    my_details { details }
  {}

  auto Stack_Frame::function() const -> String
  {
    return my_function;
  }

  auto Stack_Frame::file() const -> String
  {
    return my_file;
  }

  auto Stack_Frame::line() const -> String
  {
    return my_line;
  }

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

    if (my_file.is_empty()) {
      if (my_line.is_empty()) {
        location = "<unknown source location>";
      } else {
        location = "<unknown source file>:" + my_line;
      }
    } else {
      // TODO: CRUCIBLE_SOURCE_ROOT is from a -D from cmake, but it should be in a .hpp.in file
      auto const relative_file { my_file.view().strip_prefix(CRUCIBLE_SOURCE_ROOT) };

      if (my_line.is_empty()) {
        location = relative_file + ":<unknown source line>";
      } else {
        location = relative_file + ":" + my_line;
      }
    }

    String result { my_function + " at " + location };

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

    return result;
  }

  auto Stack_Frame_Builder::add_function(String_View const &value) -> Stack_Frame_Builder &
  {
    my_function = value;
    return *this;
  }

  auto Stack_Frame_Builder::add_file(String_View const &value) -> Stack_Frame_Builder &
  {
    my_file = value;
    return *this;
  }

  auto Stack_Frame_Builder::add_line(int const value) -> Stack_Frame_Builder &
  {
    my_line = format_integral(value);
    return *this;
  }

  auto Stack_Frame_Builder::add_details(String_View const &value) -> Stack_Frame_Builder &
  {
    my_details = value;
    return *this;
  }

  auto Stack_Frame_Builder::done() const -> Stack_Frame
  {
    return Stack_Frame { my_function, my_file, my_line, my_details };
  }

  auto build_stack_frame() -> Stack_Frame_Builder
  {
    return Stack_Frame_Builder {};
  }

  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_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) {
        auto const frame {
          build_stack_frame()
            .add_function(format_address(stack_data[i]))
            .add_details("Failed to read symbol")
            .done()
        };
        result.push(frame);
        continue;
      }

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

      String_View 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 {
          return build_stack_frame()
            .add_function(mangled_symbol)
            .add_details(error.describe())
            .done();
        }
      };

      auto const handle_success {
        [](String const &demangled_symbol) -> Stack_Frame {
          return build_stack_frame()
            .add_function(demangled_symbol)
            .done();
        }
      };

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

      result.push(stack_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) {
        auto const hack { format_unsigned_hexadecimal(stack_frame.AddrPC.Offset) };
        auto const frame {
          build_stack_frame()
            .add_function(make_string_from_char_array(hack.data(), hack.size()))
            .add_details("Failed to find stack frame")
            .done()
        };
        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) {
        auto const hack { format_unsigned_hexadecimal(stack_frame.AddrPC.Offset) };
        auto const frame {
          build_stack_frame()
            .add_function(make_string_from_char_array(hack.data(), hack.size()))
            .add_details("Failed to find symbol")
            .done()
        };
        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) {
        auto const hack { make_string_from_char_array(symbol->Name, std::strlen(symbol->Name)) };
        auto const frame {
          build_stack_frame()
            .add_function(hack + "()")
            .add_details("Failed to find file and line")
            .done()
        };
        result.push(frame);
        continue;
      }

      auto const hack1 { make_string_from_char_array(symbol->Name, std::strlen(symbol->Name)) };
      auto const hack2 { make_string_from_char_array(line.FileName, std::strlen(line.FileName)) };

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

      auto const frame {
        build_stack_frame()
          .add_function(hack1 + "()")
          .add_file(hack2)
          .add_line(static_cast<int>(line.LineNumber))
          .done()
      };

      result.push(frame);
    } while (stack_frame.AddrReturn.Offset != 0);

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

  }

  auto backtrace_unavailable() -> Backtrace_Error
  {
    return Backtrace_Unavailable {};
  }
}