Cool_Tools/ImHex
1
0
Fork 0
mirror of synced 2025-01-22 11:33:46 +01:00
Code Releases Wiki Activity

feat: Added initial support for tracing function calls and printing exception stack traces

Browse Source
This commit is contained in:
WerWolv 2024-06-01 16:36:36 +02:00
parent cf34c4bd95
commit 3e0bb6d8be
16 changed files with 286 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -69,6 +69,7 @@ addBundledLibraries()
add_subdirectory(lib/libimhex)
add_subdirectory(main)
addPluginDirectories()
add_subdirectory(lib/trace)
# Add unit tests
if (IMHEX_ENABLE_UNIT_TESTS)

24
cmake/build_helpers.cmake
View File

@ -734,30 +734,6 @@ macro(addBundledLibraries)
find_package(mbedTLS 3.4.0 REQUIRED)
find_package(Magic 5.39 REQUIRED)
if (NOT IMHEX_DISABLE_STACKTRACE)
if (WIN32)
message(STATUS "StackWalk enabled!")
set(LIBBACKTRACE_LIBRARIES DbgHelp.lib)
else ()
find_package(Backtrace)
if (${Backtrace_FOUND})
message(STATUS "Backtrace enabled! Header: ${Backtrace_HEADER}")
if (Backtrace_HEADER STREQUAL "backtrace.h")
set(LIBBACKTRACE_LIBRARIES ${Backtrace_LIBRARY})
set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
add_compile_definitions(BACKTRACE_HEADER=<${Backtrace_HEADER}>)
add_compile_definitions(HEX_HAS_BACKTRACE)
elseif (Backtrace_HEADER STREQUAL "execinfo.h")
set(LIBBACKTRACE_LIBRARIES ${Backtrace_LIBRARY})
set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
add_compile_definitions(BACKTRACE_HEADER=<${Backtrace_HEADER}>)
add_compile_definitions(HEX_HAS_EXECINFO)
endif()
endif()
endif()
endif()
endmacro()
function(enableUnityBuild TARGET)

2
lib/libimhex/CMakeLists.txt
View File

@ -142,7 +142,7 @@ if (NOT IMHEX_EXTERNAL_PLUGIN_BUILD)
precompileHeaders(libimhex "${CMAKE_CURRENT_SOURCE_DIR}/include")
endif()
target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${NLOHMANN_JSON_LIBRARIES} imgui_all_includes ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${LUNASVG_LIBRARIES})
target_link_libraries(libimhex ${LIBIMHEX_LIBRARY_TYPE} ${NLOHMANN_JSON_LIBRARIES} imgui_all_includes ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${LUNASVG_LIBRARIES} tracing)
set_property(TARGET libimhex PROPERTY INTERPROCEDURAL_OPTIMIZATION FALSE)

61
lib/trace/CMakeLists.txt Normal file
View File

@ -0,0 +1,61 @@
project(tracing)
option(IMHEX_TRACE_EXCEPTIONS "Hook thrown exceptions to display a stack trace when possible" ON)
option(IMHEX_INSTRUMENT_FUNCTIONS "Hook all function entries and exits to profile things in Tracy" OFF)
add_library(tracing OBJECT
source/stacktrace.cpp
source/exceptions.cpp
)
target_include_directories(tracing PUBLIC include)
target_link_libraries(tracing PRIVATE stdc++exp)
if (NOT IMHEX_DISABLE_STACKTRACE)
if (WIN32)
message(STATUS "StackWalk enabled!")
target_link_libraries(tracing PRIVATE DbgHelp.lib)
else ()
find_package(Backtrace)
if (${Backtrace_FOUND})
message(STATUS "Backtrace enabled! Header: ${Backtrace_HEADER}")
if (Backtrace_HEADER STREQUAL "backtrace.h")
target_link_libraries(tracing PRIVATE ${Backtrace_LIBRARY})
target_include_directories(tracing PRIVATE ${Backtrace_INCLUDE_DIR})
target_compile_definitions(tracing PRIVATE BACKTRACE_HEADER=<${Backtrace_HEADER}>)
target_compile_definitions(tracing PRIVATE HEX_HAS_BACKTRACE)
elseif (Backtrace_HEADER STREQUAL "execinfo.h")
target_link_libraries(tracing PRIVATE ${Backtrace_LIBRARY})
target_include_directories(tracing PRIVATE ${Backtrace_INCLUDE_DIR})
target_compile_definitions(tracing PRIVATE BACKTRACE_HEADER=<${Backtrace_HEADER}>)
target_compile_definitions(tracing PRIVATE HEX_HAS_EXECINFO)
endif()
endif()
endif()
target_link_libraries(tracing PRIVATE LLVMDemangle)
endif()
if (IMHEX_TRACE_EXCEPTIONS)
target_link_options(tracing PUBLIC "-Wl,--wrap=__cxa_throw")
endif()
if (IMHEX_INSTRUMENT_FUNCTIONS)
target_sources(tracing PUBLIC
source/instr_entry.cpp
source/instrumentation.cpp
)
FetchContent_Declare(
tracy
GIT_REPOSITORY https://github.com/wolfpld/tracy.git
GIT_TAG v0.10
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
FetchContent_MakeAvailable(tracy)
target_compile_options(TracyClient PRIVATE "-Wno-error")
target_compile_options(tracing PUBLIC "-finstrument-functions")
target_link_libraries(tracing PRIVATE TracyClient)
endif()

11
lib/trace/include/hex/trace/exceptions.hpp Normal file
View File

@ -0,0 +1,11 @@
#pragma once
#include <hex/trace/stacktrace.hpp>
#include <optional>
namespace hex::trace {
std::optional<StackTrace> getLastExceptionStackTrace();
}

6
lib/trace/include/hex/trace/instrumentation.hpp Normal file
View File

@ -0,0 +1,6 @@
#pragma once
#include <map>
#include <memory>

12
main/gui/include/stacktrace.hpp → lib/trace/include/hex/trace/stacktrace.hpp
View File

@ -1,20 +1,20 @@
#pragma once
#include <hex.hpp>
#include <cstdint>
#include <string>
#include <vector>
namespace hex::stacktrace {
namespace hex::trace {
struct StackFrame {
std::string file;
std::string function;
u32 line;
std::uint32_t line;
};
void initialize();
using StackTrace = std::vector<StackFrame>;
std::vector<StackFrame> getStackTrace();
void initialize();
StackTrace getStackTrace();
}

27
lib/trace/source/exceptions.cpp Normal file
View File

@ -0,0 +1,27 @@
#include <hex/trace/exceptions.hpp>
namespace hex::trace {
static std::optional<StackTrace> s_lastExceptionStackTrace;
std::optional<StackTrace> getLastExceptionStackTrace() {
if (!s_lastExceptionStackTrace.has_value())
return std::nullopt;
auto result = s_lastExceptionStackTrace.value();
s_lastExceptionStackTrace.reset();
return result;
}
}
extern "C" {
[[noreturn]] void __real___cxa_throw(void* thrownException, void* type, void (*destructor)(void*));
[[noreturn]] void __wrap___cxa_throw(void* thrownException, void* type, void (*destructor)(void*)) {
hex::trace::s_lastExceptionStackTrace = hex::trace::getStackTrace();
__real___cxa_throw(thrownException, type, destructor);
}
}

28
lib/trace/source/instr_entry.cpp Normal file
View File

@ -0,0 +1,28 @@
#include <mutex>
namespace hex {
void functionEntry(void *);
void functionExit(void *);
}
extern "C" {
static std::mutex s_mutex;
[[gnu::no_instrument_function]]
void __cyg_profile_func_enter(void *functionAddress, void *) {
std::scoped_lock lock(s_mutex);
hex::functionEntry(functionAddress);
}
[[gnu::no_instrument_function]]
void __cyg_profile_func_exit(void *functionAddress, void *) {
std::scoped_lock lock(s_mutex);
hex::functionExit(functionAddress);
}
}

13
lib/trace/source/instrumentation.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <hex/trace/instrumentation.hpp>
namespace hex {
void functionEntry([[maybe_unused]] void *functionAddress) {
}
void functionExit([[maybe_unused]] void *functionAddress) {
}
}

78
main/gui/source/stacktrace.cpp → lib/trace/source/stacktrace.cpp
View File

@ -1,7 +1,6 @@
#include <stacktrace.hpp>
#include <hex/helpers/fmt.hpp>
#include <iostream>
#include <hex/trace/stacktrace.hpp>
#include <array>
#include <llvm/Demangle/Demangle.h>
namespace {
@ -18,19 +17,48 @@ namespace {
}
#if defined(OS_WINDOWS)
#include <windows.h>
#include <dbghelp.h>
#if __has_include(<stacktrace>)
namespace hex::stacktrace {
#include <stacktrace>
namespace hex::trace {
void initialize() {
}
std::vector<StackFrame> getStackTrace() {
std::vector<StackFrame> stackTrace;
StackTrace getStackTrace() {
StackTrace result;
auto stackTrace = std::stacktrace::current();
for (const auto &entry : stackTrace) {
if (entry.source_line() == 0 && entry.source_file().empty())
result.emplace_back("", "??", 0);
else
result.emplace_back(entry.source_file(), entry.description(), entry.source_line());
}
return result;
}
}
#elif defined(OS_WINDOWS)
#include <windows.h>
#include <dbghelp.h>
#include <array>
namespace hex::trace {
void initialize() {
}
StackTrace getStackTrace() {
StackTrace stackTrace;
HANDLE process = GetCurrentProcess();
HANDLE thread = GetCurrentThread();
@ -84,7 +112,7 @@ namespace {
DWORD displacementLine = 0;
u32 lineNumber = 0;
std::uint32_t lineNumber = 0;
const char *fileName;
if (SymGetLineFromAddr64(process, stackFrame.AddrPC.Offset, &displacementLine, &line) == TRUE) {
lineNumber = line.LineNumber;
@ -110,17 +138,18 @@ namespace {
#if __has_include(BACKTRACE_HEADER)
#include BACKTRACE_HEADER
#include <hex/helpers/utils.hpp>
#include <filesystem>
#include <dlfcn.h>
#include <array>
namespace hex::stacktrace {
namespace hex::trace {
void initialize() {
}
std::vector<StackFrame> getStackTrace() {
static std::vector<StackFrame> result;
StackTrace getStackTrace() {
StackTrace result;
std::array<void*, 128> addresses = {};
const size_t count = backtrace(addresses.data(), addresses.size());
@ -129,7 +158,7 @@ namespace {
for (size_t i = 0; i < count; i += 1) {
dladdr(addresses[i], &info);
auto fileName = info.dli_fname != nullptr ? std::fs::path(info.dli_fname).filename().string() : "??";
auto fileName = info.dli_fname != nullptr ? std::filesystem::path(info.dli_fname).filename().string() : "??";
auto demangledName = info.dli_sname != nullptr ? tryDemangle(info.dli_sname) : "??";
result.push_back(StackFrame { std::move(fileName), std::move(demangledName), 0 });
@ -147,10 +176,10 @@ namespace {
#if __has_include(BACKTRACE_HEADER)
#include BACKTRACE_HEADER
#include <hex/helpers/logger.hpp>
#include <hex/helpers/utils.hpp>
namespace hex::stacktrace {
#include <wolv/io/fs.hpp>
namespace hex::trace {
static struct backtrace_state *s_backtraceState;
@ -158,14 +187,13 @@ namespace {
void initialize() {
if (auto executablePath = wolv::io::fs::getExecutablePath(); executablePath.has_value()) {
static std::string path = executablePath->string();
s_backtraceState = backtrace_create_state(path.c_str(), 1, [](void *, const char *msg, int) { log::error("{}", msg); }, nullptr);
s_backtraceState = backtrace_create_state(path.c_str(), 1, [](void *, const char *, int) { }, nullptr);
}
}
std::vector<StackFrame> getStackTrace() {
static std::vector<StackFrame> result;
StackTrace getStackTrace() {
StackTrace result;
result.clear();
if (s_backtraceState != nullptr) {
backtrace_full(s_backtraceState, 0, [](void *, uintptr_t, const char *fileName, int lineNumber, const char *function) -> int {
if (fileName == nullptr)
@ -173,7 +201,7 @@ namespace {
if (function == nullptr)
function = "??";
result.push_back(StackFrame { std::fs::path(fileName).filename().string(), tryDemangle(function), u32(lineNumber) });
result.push_back(StackFrame { std::filesystem::path(fileName).filename().string(), tryDemangle(function), std::uint32_t(lineNumber) });
return 0;
}, nullptr, nullptr);
@ -189,10 +217,10 @@ namespace {
#else
namespace hex::stacktrace {
namespace hex::trace {
void initialize() { }
std::vector<StackFrame> getStackTrace() { return { StackFrame { "??", "Stacktrace collecting not available!", 0 } }; }
StackTrace getStackTrace() { return { StackFrame { "??", "Stacktrace collecting not available!", 0 } }; }
}

1
main/gui/CMakeLists.txt
View File

@ -3,7 +3,6 @@ project(main)
add_executable(main ${APPLICATION_TYPE}
source/main.cpp
source/crash_handlers.cpp
source/stacktrace.cpp
source/window/window.cpp
source/window/win_window.cpp

3
main/gui/include/window.hpp
View File

@ -1,5 +1,7 @@
#pragma once
#include <hex.hpp>
#include <filesystem>
#include <memory>
#include <string>
@ -34,6 +36,7 @@ namespace hex {
void beginNativeWindowFrame();
void endNativeWindowFrame();
void drawTitleBar();
void drawView(const std::string &name, const std::unique_ptr<View> &view);
void frameBegin();
void frame();

6
main/gui/source/crash_handlers.cpp
View File

@ -13,7 +13,7 @@
#include <nlohmann/json.hpp>
#include <stacktrace.hpp>
#include <hex/trace/stacktrace.hpp>
#include <llvm/Demangle/Demangle.h>
#include <csignal>
@ -63,7 +63,7 @@ namespace hex::crash {
}
static void printStackTrace() {
for (const auto &stackFrame : stacktrace::getStackTrace()) {
for (const auto &stackFrame : trace::getStackTrace()) {
if (stackFrame.line == 0)
log::fatal(" ({}) | {}", stackFrame.file, stackFrame.function);
else
@ -153,7 +153,7 @@ namespace hex::crash {
// Setup functions to handle signals, uncaught exception, or similar stuff that will crash ImHex
void setupCrashHandlers() {
stacktrace::initialize();
trace::initialize();
// Register signal handlers
{

21
main/gui/source/window/window.cpp
View File

@ -546,19 +546,13 @@ namespace hex {
TaskManager::runDeferredCalls();
}
void Window::frame() {
auto &io = ImGui::GetIO();
// Loop through all views and draw them
for (auto &[name, view] : ContentRegistry::Views::impl::getEntries()) {
ImGui::GetCurrentContext()->NextWindowData.ClearFlags();
void Window::drawView(const std::string &name, const std::unique_ptr<View> &view) {
// Draw always visible views
view->drawAlwaysVisibleContent();
// Skip views that shouldn't be processed currently
if (!view->shouldProcess())
continue;
return;
const auto openViewCount = std::ranges::count_if(ContentRegistry::Views::impl::getEntries(), [](const auto &entry) {
const auto &[unlocalizedName, openView] = entry;
@ -605,13 +599,23 @@ namespace hex {
}
// Pass on currently pressed keys to the shortcut handler
auto &io = ImGui::GetIO();
for (const auto &key : m_pressedKeys) {
ShortcutManager::process(view.get(), io.KeyCtrl, io.KeyAlt, io.KeyShift, io.KeySuper, focused, key);
}
}
}
void Window::frame() {
// Loop through all views and draw them
for (auto &[name, view] : ContentRegistry::Views::impl::getEntries()) {
ImGui::GetCurrentContext()->NextWindowData.ClearFlags();
drawView(name, view);
}
// Handle global shortcuts
auto &io = ImGui::GetIO();
for (const auto &key : m_pressedKeys) {
ShortcutManager::processGlobals(io.KeyCtrl, io.KeyAlt, io.KeyShift, io.KeySuper, key);
}
@ -738,6 +742,7 @@ namespace hex {
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_SRGB_CAPABLE, GLFW_TRUE);
if (initialWindowProperties.has_value()) {
glfwWindowHint(GLFW_MAXIMIZED, initialWindowProperties->maximized);

9
plugins/builtin/source/content/events.cpp
View File

@ -6,6 +6,8 @@
#include <hex/api/achievement_manager.hpp>
#include <hex/api/workspace_manager.hpp>
#include <hex/trace/exceptions.hpp>
#include <hex/providers/provider.hpp>
#include <hex/ui/view.hpp>
@ -53,6 +55,13 @@ namespace hex::plugin::builtin {
static bool imhexClosing = false;
EventCrashRecovered::subscribe([](const std::exception &e) {
PopupCrashRecovered::open(e);
auto stackTrace = hex::trace::getLastExceptionStackTrace();
if (stackTrace.has_value()) {
for (const auto &entry : *stackTrace) {
hex::log::fatal(" {} at {}:{}", entry.function, entry.file, entry.line);
}
}
});
EventWindowClosing::subscribe([](GLFWwindow *window) {