feat: add per-pass performance profiling support

Author: Timwood0x10

src/main.zig

@@ -71,12 +71,17 @@ fn registerAllPasses(pipeline: *Pipeline) !void {
     // try pipeline.registerPass(OmniScope.cross_lang.ThreadCrossingPass);
 }
 
-fn runModulePipeline(allocator: std.mem.Allocator, loader: *IRLoader) !AnalyzeResult {
+fn runModulePipeline(allocator: std.mem.Allocator, loader: *IRLoader, config: Config) !AnalyzeResult {
     var pipeline = try Pipeline.init(allocator);
     if (loader.getModule()) |module_ref| {
         pipeline.setModule(module_ref);
     }
 
+    // Enable per-pass profiling if --perf-stats flag is set
+    if (config.perf_stats) {
+        pipeline.setPerfStats(true);
+    }
+
     try registerAllPasses(&pipeline);
 
     const analysis_start = std.time.milliTimestamp();
@@ -630,7 +635,7 @@ fn runSingleFileAnalysis(allocator: std.mem.Allocator, path: []const u8, config:
 
     log.debug("Loaded: {d} functions\n\n", .{loader.getFunctionCount()});
 
-    var result = try runModulePipeline(allocator, &loader);
+    var result = try runModulePipeline(allocator, &loader, config);
     defer deinitAnalyzeResult(&result);
 
     try emitOutput(allocator, result.issues, result.func_count, result.time_ms, config);
@@ -711,7 +716,7 @@ fn runMultiFileAnalysis(allocator: std.mem.Allocator, files: []const []const u8,
     log.info("[*] Running per-file pipelines...\n", .{});
     for (loaders.items, 0..) |*loader, i| {
         log.info("  [{d}/{d}] Analyzing: {s} ({d} functions)\n", .{ i + 1, loaders.items.len, files[i], loader.getFunctionCount() });
-        const result = runModulePipeline(allocator, loader) catch |err| {
+        const result = runModulePipeline(allocator, loader, config) catch |err| {
             log.err("  [{d}/{d}] Analysis FAILED: {}\n", .{ i + 1, loaders.items.len, err });
             continue;
         };

src/pass/analysis/rust_ffi/rust_ffi_auditor.zig

@@ -1904,3 +1904,70 @@ test "isPureConsumptionFunction - safe functions" {
     try std.testing.expect(!isPureConsumptionFunction("c_ffi_store_pointer"));
     try std.testing.expect(!isPureConsumptionFunction("pthread_create"));
 }
+
+test "StringHashMap pairing stability - same content, different backing" {
+    // Verify StringHashMap key stability: same function name from different
+    // memory locations must map to the same entry (POT-BUG-8 regression test).
+    // This ensures into_raw/from_raw pairing doesn't miss matches due to
+    // slice header pointer instability.
+    const testing = std.testing;
+
+    var into_raw_set = std.StringHashMap(void).init(testing.allocator);
+    defer into_raw_set.deinit();
+    var from_raw_set = std.StringHashMap(void).init(testing.allocator);
+    defer from_raw_set.deinit();
+
+    // Simulate LLVM returning same name from different allocations (common in
+    // real modules where LLVMGetValueName may return different pointers for
+    // the same logical string across calls).
+    const name1 = "my_func_into_raw";
+    const name2 = "my_func_into_raw";
+    // name1 and name2 have identical content but are separate comptime
+    // constants — in runtime they'd be separate allocations.
+
+    try into_raw_set.put(name1, {});
+    try testing.expect(into_raw_set.contains(name2));
+    try testing.expectEqual(@as(usize, 1), into_raw_set.count());
+
+    // Verify from_raw set behaves identically
+    const name3 = "my_func_from_raw";
+    const name4 = "my_func_from_raw";
+    try from_raw_set.put(name3, {});
+    try testing.expect(from_raw_set.contains(name4));
+    try testing.expectEqual(@as(usize, 1), from_raw_set.count());
+
+    // Cross-check: different names must not collide
+    try testing.expect(!into_raw_set.contains("other_func"));
+    try testing.expect(!from_raw_set.contains("my_func_into_raw"));
+}
+
+test "StringHashMap pairing stability - mangled Rust names" {
+    // Verify mangled Rust names pair correctly through StringHashMap.
+    // Real-world Rust FFI uses mangled names like _ZN5alloc... which must
+    // match regardless of backing allocation.
+    const testing = std.testing;
+
+    var set = std.StringHashMap(void).init(testing.allocator);
+    defer set.deinit();
+
+    const mangled_names = [_][]const u8{
+        "_ZN5alloc3boxed3Box*.*8into_raw17habc123",
+        "_ZN5alloc3boxed3Box*.*8from_raw17hdef456",
+        "_RNvCsfLfy6EI15iL_7___rustc12___rust_alloc",
+    };
+
+    // Insert each name
+    for (mangled_names) |name| {
+        try set.put(name, {});
+    }
+
+    try testing.expectEqual(@as(usize, 3), set.count());
+
+    // Verify each name can be looked up with an identical copy
+    for (mangled_names) |name| {
+        // Create a duplicate to simulate different backing memory
+        const dup = try testing.dupe(u8, name);
+        defer testing.allocator.free(dup);
+        try testing.expect(set.contains(dup));
+    }
+}

src/pass/manager.zig

@@ -2,6 +2,7 @@
 //!
 //! This module manages pass registration, dependency resolution,
 //! and execution in the correct order using topological sorting.
+//! Supports optional per-pass performance profiling via --perf-stats flag.
 
 const std = @import("std");
 const Allocator = std.mem.Allocator;
@@ -12,6 +13,7 @@ const DiagnosticWriter = @import("pass.zig").DiagnosticWriter;
 const PassKind = @import("pass.zig").PassKind;
 const FactStore = @import("../fact/store.zig").FactStore;
 const QueryEngine = @import("../fact/query.zig").QueryEngine;
+const profiler = @import("../perf/profiler.zig");
 
 /// Dependency resolution error
 pub const DependencyError = error{
@@ -26,6 +28,8 @@ pub const PassManager = struct {
     pass_map: std.StringHashMap(usize), // name -> index
     resolved_order: ?[]usize, // indices in execution order
     execution_names: ?[]const []const u8, // cached pass names in order
+    perf_stats: bool = false, // Enable per-pass performance profiling
+    pass_stats_collector: ?profiler.PassStatsCollector = null, // Collected statistics
 
     const PassEntry = struct {
         name: []const u8,
@@ -53,6 +57,10 @@ pub const PassManager = struct {
         if (self.resolved_order) |order| {
             self.allocator.free(order);
         }
+        if (self.pass_stats_collector) |*collector| {
+            collector.deinit();
+            self.pass_stats_collector = null;
+        }
         self.pass_map.deinit();
         self.passes.deinit(self.allocator);
     }
@@ -195,16 +203,40 @@ pub const PassManager = struct {
             _ = try self.resolveDependencies();
         }
 
+        // Initialize stats collector if profiling is enabled
+        if (self.perf_stats) {
+            self.pass_stats_collector = profiler.PassStatsCollector.init(self.allocator);
+        }
+
         // Execute in resolved order with graceful degradation (v0.1.6)
         var pass_failures: usize = 0;
         for (self.resolved_order.?) |idx| {
             const pass_name = self.passes.items[idx].name;
+
+            // Per-pass timing and memory sampling (only when enabled)
+            var pass_timer: ?profiler.PassTimer = null;
+            if (self.perf_stats) {
+                pass_timer = profiler.PassTimer.startPass() catch null;
+            }
+
             const t0 = std.time.nanoTimestamp();
             self.passes.items[idx].run_fn(ctx, diag) catch |err| {
                 diag.warn("PassManager: pass '{s}' failed with error: {any}, degrading gracefully", .{ pass_name, err });
                 pass_failures += 1;
                 // Continue running remaining passes
             };
+
+            // Record per-pass statistics
+            if (self.perf_stats and pass_timer != null) {
+                if (pass_timer) |*timer| {
+                    if (timer.stopPass(pass_name)) |stats| {
+                        if (self.pass_stats_collector) |*collector| {
+                            collector.record(stats) catch {};
+                        }
+                    } else |_| {}
+                }
+            }
+
             // Early exit: no FFI boundaries found, skip remaining heavy passes
             if (ctx.early_exit) {
                 diag.info("PassManager: early exit after '{s}' — no FFI boundaries, remaining passes skipped", .{pass_name});
@@ -217,11 +249,33 @@ pub const PassManager = struct {
             }
         }
 
+        // Print performance report if profiling was enabled
+        if (self.perf_stats) {
+            if (self.pass_stats_collector) |*collector| {
+                collector.printReport(true);
+            }
+        }
+
         if (pass_failures > 0) {
             diag.info("PassManager: completed with {} degraded passes out of {}", .{ pass_failures, self.resolved_order.?.len });
         }
     }
 
+    /// Enable or disable per-pass performance profiling
+    /// Must be called before run()
+    pub fn setPerfStats(self: *PassManager, enabled: bool) void {
+        self.perf_stats = enabled;
+    }
+
+    /// Get the collected pass statistics (for programmatic access)
+    /// Returns null if profiling was not enabled or no data collected
+    pub fn getPassStats(self: *const PassManager) ?[]const profiler.PassStats {
+        if (self.pass_stats_collector) |*collector| {
+            return collector.stats.items;
+        }
+        return null;
+    }
+
     /// Get the number of registered passes
     pub fn count(self: *const PassManager) usize {
         return self.passes.items.len;