feat: Add automatic type inference and SIMD-accelerated core algorithms

This commit introduces a major capability to automatically refine variable types during decompilation and overhauls the core algorithmic foundation with SIMD acceleration and cache-friendly data structures to support real-time analysis.

Primary changes:

include/structor/type_fixer.hpp (new):
- Implemented TypeFixer to analyze variable access patterns in Hex-Rays cfuncs.
- Detects and repairs generic types (void* -> struct*, int -> pointer).
- Configurable thresholds for applying fixes based on inference confidence.

include/structor/simd.hpp (new):
- Added portable SIMD abstraction layer supporting AVX-512, AVX2, SSE4.1, and NEON.
- Provides unified interface for vector loads, stores, and arithmetic.

include/structor/optimized_algorithms.hpp (new):
- Implemented O(n log n) sweep-line algorithm for interval overlap detection, replacing O(n^2) pairwise checks.
- Added SIMD-accelerated binary GCD and batch coverage analysis.

include/structor/optimized_containers.hpp (new):
- Added Arena and ObjectPool allocators to reduce heap fragmentation during synthesis.
- Implemented FlatUnionFind and FlatHashSet for cache-locality improvements.
- Added SmallVector for inline storage optimization.

src/plugin.cpp:
- Hooked Hex-Rays `hxe_func_printed` event to trigger automatic type fixing.
- Added IDC bindings for manual type analysis and fixing (e.g., `structor_fix_function_types`).

src/z3/layout_constraints.cpp & src/z3/field_candidates.cpp:
- Integrated optimized algorithms into the constraint generation pipeline.
- Replaced naive overlap checks with sweep-line implementation.
- Added prefetching hints for candidate traversal.

src/z3/type_lattice.cpp:
- Added memoization (caching) for Least Upper Bound (LUB) and Greatest Lower Bound (GLB) operations.
- Improved type hashing using FNV-1a with golden ratio mixing to reduce collisions.

bench/ (new):
- Added comprehensive benchmark suite comparing naive vs. optimized implementations.

Impact:
- User Experience: Decompiled code now automatically receives better type definitions without manual intervention.
- Performance: Constraint generation for large structures is significantly faster due to algorithmic complexity reduction (O(n^2) -> O(n log n)) and hardware acceleration.
- Reliability: Type inference is conservative by default but can be tuned via config.

Author: 19h

bench/bench_algorithms.cpp

@@ -0,0 +1,36 @@
+// Test aligned allocation
+#include <iostream>
+#include <cstdlib>
+#include <cstdint>
+
+void* my_aligned_alloc(size_t alignment, size_t size) {
+    std::cerr << "aligned_alloc(alignment=" << alignment << ", size=" << size << ")\n";
+    
+#if defined(__APPLE__)
+    void* ptr = nullptr;
+    int result = posix_memalign(&ptr, alignment, size);
+    std::cerr << "  posix_memalign returned " << result << ", ptr=" << ptr << "\n";
+    if (result != 0) {
+        return nullptr;
+    }
+    return ptr;
+#else
+    return std::aligned_alloc(alignment, size);
+#endif
+}
+
+int main() {
+    // Test with alignof(int32_t) = 4
+    void* p1 = my_aligned_alloc(4, 64);
+    if (p1) std::free(p1);
+    
+    // Test with alignment = 16
+    void* p2 = my_aligned_alloc(16, 64);
+    if (p2) std::free(p2);
+    
+    // Test with alignment = 4 but small size
+    void* p3 = my_aligned_alloc(4, 32);
+    if (p3) std::free(p3);
+    
+    return 0;
+}

bench/test_alloc.cpp

@@ -0,0 +1,36 @@
+// Simple test for overlap detection
+#define STRUCTOR_TESTING
+#include "structor/optimized_algorithms.hpp"
+#include <iostream>
+#include <random>
+
+using namespace structor::algorithms;
+
+int main() {
+    std::cerr << "Creating intervals...\n";
+    
+    std::mt19937 rng(42);
+    std::uniform_int_distribution<int64_t> start_dist(0, 1000);
+    std::uniform_int_distribution<int64_t> len_dist(250, 500);
+    
+    std::vector<Interval> intervals;
+    for (int i = 0; i < 256; ++i) {
+        int64_t start = start_dist(rng);
+        int64_t len = len_dist(rng);
+        intervals.emplace_back(start, start + len, i);
+    }
+    
+    std::cerr << "Created " << intervals.size() << " intervals\n";
+    std::cerr << "Finding overlaps...\n";
+    
+    try {
+        auto result = find_overlapping_pairs(intervals);
+        std::cerr << "Found " << result.size() << " overlapping pairs\n";
+    } catch (const std::exception& e) {
+        std::cerr << "Exception: " << e.what() << "\n";
+        return 1;
+    }
+    
+    std::cerr << "Done\n";
+    return 0;
+}

bench/test_overlap.cpp

@@ -0,0 +1,27 @@
+#define STRUCTOR_TESTING
+#include "structor/optimized_containers.hpp"
+#include <iostream>
+#include <vector>
+
+using namespace structor;
+
+int main() {
+    std::cerr << "Creating FlatUnionFind...\n";
+    FlatUnionFind uf(256);
+    
+    std::cerr << "Making sets...\n";
+    for (int i = 0; i < 256; ++i) {
+        uf.make_set(i);
+    }
+    
+    std::cerr << "Performing unions...\n";
+    for (int i = 0; i < 100; ++i) {
+        uf.unite(i, i + 100);
+        if (i % 20 == 0) {
+            std::cerr << "  united " << i << " and " << i+100 << "\n";
+        }
+    }
+    
+    std::cerr << "Done\n";
+    return 0;
+}

bench/test_union_find.cpp

@@ -9,6 +9,7 @@
 #include "pseudocode_rewriter.hpp"
 #include "structure_persistence.hpp"
 #include "ui_integration.hpp"
+#include "type_fixer.hpp"
 
 namespace structor {
 
@@ -60,6 +61,27 @@ class StructorAPI {
         const tinfo_t& type,
         PropagationDirection direction = PropagationDirection::Both);
 
+    /// Fix types for all variables in a function
+    /// Analyzes access patterns and applies inferred types when significantly different
+    [[nodiscard]] TypeFixResult fix_function_types(
+        ea_t func_ea,
+        const TypeFixerConfig* config = nullptr);
+
+    /// Fix types for a specific variable in a function
+    [[nodiscard]] VariableTypeFix fix_variable_type(
+        ea_t func_ea,
+        int var_idx,
+        const TypeFixerConfig* config = nullptr);
+
+    /// Fix types for a variable by name
+    [[nodiscard]] VariableTypeFix fix_variable_type(
+        ea_t func_ea,
+        const char* var_name,
+        const TypeFixerConfig* config = nullptr);
+
+    /// Analyze types without fixing (dry run)
+    [[nodiscard]] TypeFixResult analyze_function_types(ea_t func_ea);
+
     /// Get current configuration
     [[nodiscard]] const SynthOptions& get_options() const {
         return Config::instance().options();
@@ -181,6 +203,101 @@ inline PropagationResult StructorAPI::propagate_type(
     return propagator.propagate(func_ea, var_idx, type, direction);
 }
 
+inline TypeFixResult StructorAPI::fix_function_types(
+    ea_t func_ea,
+    const TypeFixerConfig* config)
+{
+    TypeFixerConfig cfg = config ? *config : TypeFixerConfig();
+    TypeFixer fixer(cfg);
+    return fixer.fix_function_types(func_ea);
+}
+
+inline VariableTypeFix StructorAPI::fix_variable_type(
+    ea_t func_ea,
+    int var_idx,
+    const TypeFixerConfig* config)
+{
+    VariableTypeFix result;
+    result.var_idx = var_idx;
+
+    cfuncptr_t cfunc = utils::get_cfunc(func_ea);
+    if (!cfunc) {
+        result.skip_reason = "Failed to decompile function";
+        return result;
+    }
+
+    lvars_t* lvars = cfunc->get_lvars();
+    if (!lvars || var_idx < 0 || static_cast<size_t>(var_idx) >= lvars->size()) {
+        result.skip_reason = "Invalid variable index";
+        return result;
+    }
+
+    result.var_name = lvars->at(var_idx).name;
+    result.is_argument = lvars->at(var_idx).is_arg_var();
+
+    TypeFixerConfig cfg = config ? *config : TypeFixerConfig();
+    TypeFixer fixer(cfg);
+    
+    // Analyze the variable
+    result.comparison = fixer.analyze_variable(cfunc, var_idx);
+    
+    // Apply fix if significant and not dry run
+    if (result.comparison.is_significant() && !cfg.dry_run) {
+        PropagationResult prop;
+        if (fixer.apply_fix(cfunc, var_idx, result.comparison.inferred_type, 
+                           cfg.propagate_fixes ? &prop : nullptr)) {
+            result.applied = true;
+            result.propagation = std::move(prop);
+        } else {
+            result.skip_reason = "Failed to apply type";
+        }
+    } else if (!result.comparison.is_significant()) {
+        result.skip_reason.sprnt("Not significant (%s)", 
+            type_difference_str(result.comparison.difference));
+    } else {
+        result.skip_reason = "Dry run mode";
+    }
+
+    return result;
+}
+
+inline VariableTypeFix StructorAPI::fix_variable_type(
+    ea_t func_ea,
+    const char* var_name,
+    const TypeFixerConfig* config)
+{
+    VariableTypeFix result;
+
+    cfuncptr_t cfunc = utils::get_cfunc(func_ea);
+    if (!cfunc) {
+        result.skip_reason = "Failed to decompile function";
+        return result;
+    }
+
+    lvar_t* var = utils::find_lvar_by_name(cfunc, var_name);
+    if (!var) {
+        result.skip_reason.sprnt("Variable '%s' not found", var_name);
+        return result;
+    }
+
+    lvars_t& lvars = *cfunc->get_lvars();
+    for (size_t i = 0; i < lvars.size(); ++i) {
+        if (&lvars[i] == var) {
+            return fix_variable_type(func_ea, static_cast<int>(i), config);
+        }
+    }
+
+    result.skip_reason = "Variable index lookup failed";
+    return result;
+}
+
+inline TypeFixResult StructorAPI::analyze_function_types(ea_t func_ea) {
+    TypeFixerConfig cfg;
+    cfg.dry_run = true;  // Don't actually apply changes
+    TypeFixer fixer(cfg);
+    return fixer.fix_function_types(func_ea);
+}
+
 inline SynthResult StructorAPI::do_synthesis(ea_t func_ea, int var_idx, const SynthOptions& opts) {
     SynthResult result;
 

include/structor/api.hpp

@@ -141,6 +141,10 @@ struct SynthOptions {
     bool            debug_mode;         // Enable debug logging (adopted from Suture)
     AccessPredicate access_filter;      // Filter predicate for accesses (adopted from Suture)
 
+    // Automatic type fixing options
+    bool            auto_fix_types;     // Automatically fix types when decompiling
+    bool            auto_fix_verbose;   // Print messages about auto-fixed types
+
     // Z3-specific options
     Z3Options       z3;                 // Z3 synthesis configuration
 
@@ -161,6 +165,8 @@ struct SynthOptions {
         , emit_substructs(true)
         , debug_mode(false)
         , access_filter(predicates::accept_all)
+        , auto_fix_types(true)
+        , auto_fix_verbose(false)
         , z3() {}
 };
 
@@ -258,7 +264,8 @@ inline bool Config::load() {
 
     std::ifstream file(path);
     if (!file.is_open()) {
-        // No config file, use defaults
+        // No config file, create one with defaults
+        save();
         return true;
     }
 
@@ -316,6 +323,12 @@ inline bool Config::load() {
         } else if (key == "debug_mode") {
             options_.debug_mode = parse_bool(value);
         }
+        // Auto type fixing options
+        else if (key == "auto_fix_types") {
+            options_.auto_fix_types = parse_bool(value);
+        } else if (key == "auto_fix_verbose") {
+            options_.auto_fix_verbose = parse_bool(value);
+        }
         // Z3 options
         else if (key == "z3_mode") {
             if (value == "disabled") options_.z3.mode = Z3SynthesisMode::Disabled;
@@ -378,6 +391,11 @@ inline bool Config::save() {
     file << "debug_mode=" << (options_.debug_mode ? "true" : "false") << "\n";
     file << "\n";
 
+    file << "[TypeFix]\n";
+    file << "auto_fix_types=" << (options_.auto_fix_types ? "true" : "false") << "\n";
+    file << "auto_fix_verbose=" << (options_.auto_fix_verbose ? "true" : "false") << "\n";
+    file << "\n";
+
     file << "[Synthesis]\n";
     file << "min_accesses=" << options_.min_accesses << "\n";
     file << "alignment=" << options_.alignment << "\n";