28 refactor clean up codebase and reduce duplication

.github/workflows/commit-check.yml

@@ -0,0 +1,16 @@
+name: Commit conventions
+
+on:
+  push:
+
+jobs:
+  commit_check:
+    name: Check conventional commits
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Validate commit messages
+        run: |
+          python3 scripts/ci/commit_checker.py

.gitignore

@@ -0,0 +1,35 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# Build directories
+/build/

.pre-commit-config.yaml

@@ -0,0 +1,9 @@
+repos:
+  - repo: local
+    hooks:
+      - id: conventional-commit-msg
+        name: conventional commit message
+        entry: python3 scripts/git/commit_msg_checker.py
+        language: system
+        stages: [commit-msg]
+        pass_filenames: true

CMakeLists.txt

@@ -48,7 +48,23 @@ option(BUILD_SHARED_LIB "Build shared library variant" ON)
 # ===========================
 set(STACK_ANALYZER_SOURCES
     src/StackUsageAnalyzer.cpp
+    src/analysis/AllocaUsage.cpp
+    src/analysis/AnalyzerUtils.cpp
+    src/analysis/ConstParamAnalysis.cpp
+    src/analysis/DynamicAlloca.cpp
+    src/analysis/FunctionFilter.cpp
+    src/analysis/IRValueUtils.cpp
+    src/analysis/IntRanges.cpp
+    src/analysis/InputPipeline.cpp
+    src/analysis/InvalidBaseReconstruction.cpp
+    src/analysis/MemIntrinsicOverflow.cpp
+    src/analysis/SizeMinusKWrites.cpp
+    src/analysis/StackBufferAnalysis.cpp
+    src/analysis/StackComputation.cpp
+    src/analysis/StackPointerEscape.cpp
+    src/report/ReportSerialization.cpp
     src/mangle.cpp
+    src/passes/ModulePasses.cpp
 )
 
 include_directories(${LLVM_INCLUDE_DIRS})

include/StackUsageAnalyzer.hpp

@@ -106,12 +106,13 @@ namespace ctrace::stack
         AllocaTooLarge = 8,
         AllocaUsageWarning = 9,
         InvalidBaseReconstruction = 10,
-        ConstParameterNotModified = 11
+        ConstParameterNotModified = 11,
+        SizeMinusOneWrite = 12
     };
 
     template <> struct EnumTraits<DescriptiveErrorCode>
     {
-        static constexpr std::array<std::string_view, 12> names = {"None",
+        static constexpr std::array<std::string_view, 13> names = {"None",
                                                                    "StackBufferOverflow",
                                                                    "NegativeStackIndex",
                                                                    "VLAUsage",
@@ -122,7 +123,8 @@ namespace ctrace::stack
                                                                    "AllocaTooLarge",
                                                                    "AllocaUsageWarning",
                                                                    "InvalidBaseReconstruction",
-                                                                   "ConstParameterNotModified"};
+                                                                   "ConstParameterNotModified",
+                                                                   "SizeMinusOneWrite"};
     };
 
     /*

include/analysis/AllocaUsage.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <functional>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "StackUsageAnalyzer.hpp"
+
+namespace llvm
+{
+    class AllocaInst;
+    class DataLayout;
+    class Function;
+    class Module;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    struct AllocaUsageIssue
+    {
+        std::string funcName;
+        std::string varName;
+        const llvm::AllocaInst* allocaInst = nullptr;
+
+        bool userControlled = false;      // size derived from argument / non-local value
+        bool sizeIsConst = false;         // size known exactly
+        bool hasUpperBound = false;       // bounded size (from ICmp-derived range)
+        bool isRecursive = false;         // function participates in a recursion cycle
+        bool isInfiniteRecursive = false; // unconditional self recursion
+
+        StackSize sizeBytes = 0;       // exact size in bytes (if sizeIsConst)
+        StackSize upperBoundBytes = 0; // upper bound in bytes (if hasUpperBound)
+    };
+
+    std::vector<AllocaUsageIssue>
+    analyzeAllocaUsage(llvm::Module& mod, const llvm::DataLayout& DL,
+                       const std::set<const llvm::Function*>& recursiveFuncs,
+                       const std::set<const llvm::Function*>& infiniteRecursionFuncs,
+                       const std::function<bool(const llvm::Function&)>& shouldAnalyze);
+} // namespace ctrace::stack::analysis

include/analysis/AnalyzerUtils.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+#include "StackUsageAnalyzer.hpp"
+#include "analysis/StackComputation.hpp"
+
+namespace llvm
+{
+    class Function;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    std::string formatFunctionNameForMessage(const std::string& name);
+
+    std::string getFunctionSourcePath(const llvm::Function& F);
+
+    bool getFunctionSourceLocation(const llvm::Function& F, unsigned& line, unsigned& column);
+
+    std::string buildMaxStackCallPath(const llvm::Function* F, const CallGraph& CG,
+                                      const InternalAnalysisState& state);
+
+    bool shouldIncludePath(const std::string& path, const AnalysisConfig& config);
+
+    bool functionNameMatches(const llvm::Function& F, const AnalysisConfig& config);
+} // namespace ctrace::stack::analysis

include/analysis/ConstParamAnalysis.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace llvm
+{
+    class Function;
+    class Module;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    struct ConstParamIssue
+    {
+        std::string funcName;
+        std::string paramName;
+        std::string currentType;
+        std::string suggestedType;
+        std::string suggestedTypeAlt;
+        bool pointerConstOnly = false; // ex: T * const param
+        bool isReference = false;
+        bool isRvalueRef = false;
+        unsigned line = 0;
+        unsigned column = 0;
+    };
+
+    std::vector<ConstParamIssue>
+    analyzeConstParams(llvm::Module& mod,
+                       const std::function<bool(const llvm::Function&)>& shouldAnalyze);
+} // namespace ctrace::stack::analysis

include/analysis/DynamicAlloca.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace llvm
+{
+    class AllocaInst;
+    class Function;
+    class Module;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    struct DynamicAllocaIssue
+    {
+        std::string funcName;
+        std::string varName;
+        std::string typeName;
+        const llvm::AllocaInst* allocaInst = nullptr;
+    };
+
+    std::vector<DynamicAllocaIssue>
+    analyzeDynamicAllocas(llvm::Module& mod,
+                          const std::function<bool(const llvm::Function&)>& shouldAnalyze);
+} // namespace ctrace::stack::analysis

include/analysis/FunctionFilter.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+#include "StackUsageAnalyzer.hpp"
+
+namespace llvm
+{
+    class Function;
+    class Module;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    struct FunctionFilter
+    {
+        bool hasPathFilter = false;
+        bool hasFuncFilter = false;
+        bool hasFilter = false;
+        std::string moduleSourcePath;
+        const AnalysisConfig* config = nullptr;
+
+        bool shouldAnalyze(const llvm::Function& F) const;
+    };
+
+    FunctionFilter buildFunctionFilter(const llvm::Module& mod, const AnalysisConfig& config);
+} // namespace ctrace::stack::analysis

include/analysis/IRValueUtils.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+
+namespace llvm
+{
+    class AllocaInst;
+    class ConstantInt;
+    class Function;
+    class Value;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    std::string deriveAllocaName(const llvm::AllocaInst* AI);
+
+    const llvm::ConstantInt* tryGetConstFromValue(const llvm::Value* V, const llvm::Function& F);
+} // namespace ctrace::stack::analysis

include/analysis/InputPipeline.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "StackUsageAnalyzer.hpp"
+
+namespace llvm
+{
+    class LLVMContext;
+    class Module;
+    class SMDiagnostic;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    struct ModuleLoadResult
+    {
+        std::unique_ptr<llvm::Module> module;
+        LanguageType language = LanguageType::Unknown;
+        std::string error;
+    };
+
+    LanguageType detectFromExtension(const std::string& path);
+
+    LanguageType detectLanguageFromFile(const std::string& path, llvm::LLVMContext& ctx);
+
+    ModuleLoadResult loadModuleForAnalysis(const std::string& filename,
+                                           const AnalysisConfig& config, llvm::LLVMContext& ctx,
+                                           llvm::SMDiagnostic& err);
+} // namespace ctrace::stack::analysis

include/analysis/IntRanges.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <map>
+
+namespace llvm
+{
+    class Function;
+    class Value;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    struct IntRange
+    {
+        bool hasLower = false;
+        long long lower = 0;
+        bool hasUpper = false;
+        long long upper = 0;
+    };
+
+    std::map<const llvm::Value*, IntRange> computeIntRangesFromICmps(llvm::Function& F);
+} // namespace ctrace::stack::analysis

include/analysis/InvalidBaseReconstruction.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "StackUsageAnalyzer.hpp"
+
+namespace llvm
+{
+    class DataLayout;
+    class Function;
+    class Instruction;
+    class Module;
+} // namespace llvm
+
+namespace ctrace::stack::analysis
+{
+    struct InvalidBaseReconstructionIssue
+    {
+        std::string funcName;
+        std::string varName;        // nom de la variable alloca (stack object)
+        std::string sourceMember;   // membre source (ex: "b")
+        int64_t offsetUsed = 0;     // offset utilisé dans le calcul (peut être négatif)
+        std::string targetType;     // type vers lequel on cast (ex: "struct A*")
+        bool isOutOfBounds = false; // true si on peut prouver que c'est hors bornes
+        const llvm::Instruction* inst = nullptr;
+    };
+
+    std::vector<InvalidBaseReconstructionIssue> analyzeInvalidBaseReconstructions(
+        llvm::Module& mod, const llvm::DataLayout& DL,
+        const std::function<bool(const llvm::Function&)>& shouldAnalyze);
+} // namespace ctrace::stack::analysis