Update hookcheck

Added ability to ignore symbols by source file path, and functions in output are sorted now

Author: botder

Client/game_sa/premake5.lua

@@ -43,7 +43,7 @@ project "Game SA"
 	}
 
 	postbuildcommands {
-		"%[%{!wks.location}/../utils/hookcheck.exe] %[$(TargetPath)]"
+		"%[%{!wks.location}/../utils/hookcheck.exe] -dll:%[$(TargetPath)] -ignore:\\vendor\\"
 	}
 
 	filter "architecture:not x86"

Client/multiplayer_sa/premake5.lua

@@ -34,7 +34,7 @@ project "Multiplayer SA"
 	}
 
 	postbuildcommands {
-		"%[%{!wks.location}/../utils/hookcheck.exe] %[$(TargetPath)]"
+		"%[%{!wks.location}/../utils/hookcheck.exe] -dll:%[$(TargetPath)] -ignore:\\vendor\\"
 	}
 
 	filter "architecture:not x86"

utils/hookcheck.exe

@@ -25,6 +25,8 @@
 #include <algorithm>
 #include <array>
 #include <format>
+#include <vector>
+#include <optional>
 
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
@@ -36,35 +38,79 @@ int wmain(int argc, wchar_t* argv[])
 {
     SetConsoleOutputCP(CP_UTF8);
 
-    if (argc < 2)
+    struct Arguments
     {
-        PrintLn(L"Usage: " TOOL_NAME L" <dll_path> [<label:" DEFAULT_LABEL L">]");
-        return 1;
-    }
+        std::optional<std::wstring> dll;
+        std::optional<std::wstring> label;
+        std::vector<std::wstring>   ignore;
+    } arguments;
 
-    const fs::path dllFilePath = fs::absolute(argv[1]);
-    std::wstring   labelName = (argc >= 3) ? argv[2] : (L"" DEFAULT_LABEL);
+    for (int i = 1; i < argc; ++i)
+    {
+        std::wstring_view arg = argv[i];
 
-    if (!fs::exists(dllFilePath) || !fs::is_regular_file(dllFilePath))
+        if (arg.length() < 2 || !arg.starts_with(L'-'))
+            continue;
+
+        std::wstring key;
+        std::wstring value;
+
+        if (const size_t pos = arg.find_first_of(L':', 1); pos != std::wstring_view::npos && pos > 1)
+        {
+            key = arg.substr(1, pos - 1);
+            value = arg.substr(pos + 1);
+        }
+        else
+        {
+            key = arg.substr(1);
+        }
+
+        Trim(key);
+        Trim(value);
+
+        if (key.empty())
+            continue;
+
+        if (!_wcsnicmp(key.c_str(), L"dll", key.size()))
+        {
+            if (!value.empty() && !arguments.dll.has_value())
+                arguments.dll = value;
+
+            continue;
+        }
+
+        if (!_wcsnicmp(key.c_str(), L"label", key.size()))
+        {
+            if (!value.empty() && !arguments.label.has_value())
+                arguments.label = value;
+
+            continue;
+        }
+
+        if (!_wcsnicmp(key.c_str(), L"ignore", key.size()))
+        {
+            if (!value.empty())
+                arguments.ignore.emplace_back(value);
+
+            continue;
+        }
+    }
+
+    if (!arguments.dll.has_value())
     {
-        PrintErrorLn(L"{} is not a regular file", dllFilePath.wstring());
+        PrintLn(L"Usage: " TOOL_NAME L" -dll:<path> [-label:" DEFAULT_LABEL L"] [-ignore:<path>]");
         return 1;
     }
 
-    Trim(labelName);
+    const fs::path dllFilePath = fs::absolute(arguments.dll.value());
+    std::wstring   labelName = arguments.label.value_or(L"" DEFAULT_LABEL);
 
-    if (labelName.empty())
+    if (!fs::exists(dllFilePath) || !fs::is_regular_file(dllFilePath))
     {
-        PrintWarningLn(L"'label' program argument is empty, using " DEFAULT_LABEL);
-        labelName = (L"" DEFAULT_LABEL);
+        PrintErrorLn(L"DLL file '{}' does not exist or is not readable", dllFilePath.wstring());
+        return 1;
     }
 
-#ifdef MTA_DEBUG
-    PrintLn(L"[~] " TOOL_NAME L" " TOOL_VERSION);
-    PrintLn(L"[~] Label: '{}'", labelName);
-    PrintLn(L"[~] DLL:   '{}'", dllFilePath.wstring());
-#endif
-
     DllAnalyzer dll;
 
     if (auto [errorCode, hr] = dll.LoadDll(dllFilePath.wstring()); errorCode != DllAnalyzer::LoadError::None)
@@ -133,7 +179,13 @@ int wmain(int argc, wchar_t* argv[])
     }
 
 #ifdef MTA_DEBUG
-    PrintLn(L"[~] PDB:   '{}'", pdbFilePath.wstring());
+    PrintLn(L"[~] " TOOL_NAME L" " TOOL_VERSION);
+    PrintLn(L"[~] Label:  '{}'", labelName);
+    PrintLn(L"[~] DLL:    '{}'", dllFilePath.wstring());
+    PrintLn(L"[~] PDB:    '{}'", pdbFilePath.wstring());
+
+    for (const std::wstring& ignore : arguments.ignore)
+        PrintLn(L"[~] Ignore: '{}'", ignore);
 #endif
 
     if (!fs::exists(pdbFilePath) || !fs::is_regular_file(pdbFilePath))
@@ -184,11 +236,40 @@ int wmain(int argc, wchar_t* argv[])
         return 1;
     }
 
-    const std::vector<PdbAnalyzer::Function>& functions = pdb.GetFunctions();
+    std::vector<PdbAnalyzer::Function>& functions = pdb.GetFunctions();
 
     if (functions.empty())
         return 0;
 
+    const auto ContainsIgnore = [&ignored = arguments.ignore](const PdbAnalyzer::Function& f)
+    {
+        for (const std::wstring& ignore : ignored)
+        {
+            if (StrStrIW(f.SourceFile.c_str(), ignore.c_str()) != nullptr)
+                return true;
+        }
+
+        return false;
+    };
+
+    functions.erase(std::remove_if(std::begin(functions), std::end(functions), ContainsIgnore), std::end(functions));
+
+    const auto SortBySource = [](const PdbAnalyzer::Function& lhs, const PdbAnalyzer::Function& rhs)
+    {
+        const auto compare =
+            std::lexicographical_compare_three_way(std::begin(lhs.SourceFile), std::end(lhs.SourceFile), std::begin(rhs.SourceFile), std::end(rhs.SourceFile),
+                                                   [](wchar_t a, wchar_t b) { return std::tolower(a) <=> std::tolower(b); });
+
+        if (std::is_lt(compare))
+            return true;
+        if (std::is_gt(compare))
+            return false;
+
+        return lhs.SourceLine < rhs.SourceLine;
+    };
+
+    std::sort(std::begin(functions), std::end(functions), SortBySource);
+
     int exitCode = 0;
 
     const auto isOurLabel = [&labelName](const PdbAnalyzer::Label& l) { return l.Name == labelName; };
@@ -200,6 +281,9 @@ int wmain(int argc, wchar_t* argv[])
 
         std::vector<std::wstring> problems;
 
+        if (!hasLabel && !fs::is_regular_file(function.SourceFile))
+            continue;
+
         if (function.Name.starts_with(L"std::") || function.Name.starts_with(L'_'))
         {
             if (!hasLabel)
@@ -246,19 +330,8 @@ int wmain(int argc, wchar_t* argv[])
         if (problems.empty())
             continue;
 
-        if (function.SourceFile.empty())
-        {
-            PrintLn(L"");
-            PrintLn(L"[>] {}", function.Name);
-
-            for (const std::wstring& problem : problems)
-                PrintLn(L"[-] {}", problem);
-        }
-        else
-        {
-            for (const std::wstring& problem : problems)
-                PrintLn(L"{}({}): {}", function.SourceFile, function.SourceLine, problem);
-        }
+        for (const std::wstring& problem : problems)
+            PrintLn(L"{}({}): {}", function.SourceFile, function.SourceLine, problem);
     }
 
     return exitCode;

utils/src/hookcheck/hookcheck.cpp

@@ -245,8 +245,15 @@ void PdbAnalyzer::AnalyzeFunction(IDiaSymbol* functionSymbol)
     newFunction.HasInlineAssembly = hasInlineAssembly;
 
     AttachLocation(functionSymbol, newFunction);
+    NormalizePath(newFunction.SourceFile);
+
+    if (newFunction.SourceFile.empty())
+    {
+        m_functions.pop_back();
+        return;
+    }
+
     AttachLabels(functionSymbol, newFunction);
-    SysFreeString(name);
 }
 
 void PdbAnalyzer::AttachLocation(IDiaSymbol* functionSymbol, Function& attachTo)

utils/src/hookcheck/pdb-analyzer.cpp

@@ -10,6 +10,7 @@
  *****************************************************************************/
 
 #include "utility.h"
+#include <filesystem>
 
 void Trim(std::wstring& input)
 {
@@ -22,3 +23,16 @@ void Trim(std::wstring& input)
     if (size_t position = input.find_last_not_of(L" \r\n\t\0"); position != std::string_view::npos)
         input = input.substr(0, position + 1);
 }
+
+void NormalizePath(std::wstring& input)
+{
+    if (input.empty())
+        return;
+
+    std::error_code ec{};
+
+    if (const auto canon = std::filesystem::canonical(input, ec); !ec)
+        input = canon.wstring();
+
+    std::replace(input.begin(), input.end(), L'/', L'\\');
+}

utils/src/hookcheck/utility.cpp

@@ -19,6 +19,8 @@ using HRESULT = long;
 
 void Trim(std::wstring& input);
 
+void NormalizePath(std::wstring& input);
+
 template <typename... Args>
 void PrintLn(const std::wformat_string<Args...> fmt, Args&&... args)
 {