feat(jit-report): attribute cost-model declines to the actual function at runtime (item #2)

The report's per-function "declined by cost model" verdict re-derived the
profitability from a bare re-translation, which loses profile-guided PICs (no
profile feedback at report time) — so the very case that most often stays
interpreted was not attributed.

Now `consult_profitability` takes the function name and records it in a new
`unprofitable_declined_fns` map (fn name → first decline reason) as the run
happens — ground truth. The report reads that map for the per-function verdict
instead of re-deriving, so a profile-guided PIC decline is now correctly
attributed to its function. `report` mode's per-region log line also gains the
`fn=...` tag, and the map is exposed in `to_json`.

Test: report_explains_cost_model_decline_for_polymorphic_pic now additionally
asserts the per-function `not native: declined by cost model` line (previously
only the summary block was reliable).

Verified: clippy 0; lib 276/0; runtime 453/0 (incl. all 11 report tests);
differential 33/0.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/reg_vm/mod.rs

@@ -2434,6 +2434,11 @@ pub struct NativeStats {
     /// profitability is a distinct, post-eligibility judgement and must not be
     /// clobbered by it.
     pub unprofitable_decline_reasons: BTreeMap<String, u64>,
+    /// Runtime attribution: for each function the cost model declined this run, the
+    /// (first) decline reason — ground truth for the report's per-function "declined
+    /// by cost model" verdict, so it need not re-derive (which loses profile-guided
+    /// PICs). Keyed by function name.
+    pub unprofitable_declined_fns: BTreeMap<String, String>,
 }
 
 #[cfg(feature = "native-jit")]
@@ -2551,6 +2556,7 @@ compile_ms={:.3} run_ms={:.3} osr_entries={} unprofitable_declines={}",
             "osr_entries": self.osr_entries,
             "unprofitable_declines": self.unprofitable_declines,
             "unprofitable_decline_reasons": &self.unprofitable_decline_reasons,
+            "unprofitable_declined_fns": &self.unprofitable_declined_fns,
         })
     }
 }
@@ -2589,24 +2595,23 @@ fn jit_missed_opt_report(unit: &RegUnit, native: &NativeState) -> Vec<String> {
 
         // --- Native-tier verdict --------------------------------------------------
         match translate_to_native_jit(unit, func) {
-            Some((jit_fn, ..)) => {
+            Some(_) => {
                 if native.report_native_ok.contains(&key) {
                     block.push("  native: ok".to_string());
+                } else if let Some(reason) =
+                    native.stats.unprofitable_declined_fns.get(&func.name)
+                {
+                    // Runtime attribution (ground truth from this run's cost-model
+                    // consult) — the common "why no JIT" case now the model enforces
+                    // by default. Reliable even for profile-guided PICs, which a
+                    // re-derivation here would miss.
+                    block.push(format!("  not native: declined by cost model — {reason}"));
                 } else {
-                    // Eligible but never observed running natively this run. Distinguish
-                    // the cost-model (profitability) decline — the common "why no JIT"
-                    // case now that the model enforces by default — from a plain
-                    // tier-deferred/not-hot miss.
-                    let profit = effective_cost_mode().active().then(|| {
-                        native_region_profitability(&jit_fn, jit_function_has_loop(&func.code))
-                    });
-                    match profit {
-                        Some(p) if p.decline => block
-                            .push(format!("  not native: declined by cost model — {}", p.reason(&func.name))),
-                        _ => block.push(
-                            "  native: eligible (not run natively this execution)".to_string(),
-                        ),
-                    }
+                    // Eligible but never observed running natively this run
+                    // (tier-deferred, not called hot, or demoted by another gate).
+                    block.push(
+                        "  native: eligible (not run natively this execution)".to_string(),
+                    );
                 }
             }
             None => {

crates/rsscript/src/reg_vm/tier.rs

@@ -162,6 +162,7 @@ fn consult_profitability(
     jit_fn: &vm_jit::JitFunction,
     has_backedge: bool,
     region: &str,
+    func_name: &str,
 ) -> bool {
     let mode = effective_cost_mode();
     if !mode.active() {
@@ -170,7 +171,7 @@ fn consult_profitability(
     let p = native_region_profitability(jit_fn, has_backedge);
     if matches!(mode, CostMode::Report) && std::env::var_os("RSS_JIT_REPORT").is_some() {
         // Log EVERY scored region (kept and declined) so weights can be calibrated.
-        eprintln!("[cost-model] {}", p.summary(region));
+        eprintln!("[cost-model] {} fn=`{func_name}`", p.summary(region));
     }
     if !p.decline {
         return false;
@@ -182,6 +183,14 @@ fn consult_profitability(
             .unprofitable_decline_reasons
             .entry(p.reason(region))
             .or_insert(0) += 1;
+        // Runtime ATTRIBUTION: record which actual function/region was declined, so
+        // the report can say per-function "declined by cost model" from ground truth
+        // rather than a fragile re-derivation (which loses profile-guided PICs).
+        native
+            .stats
+            .unprofitable_declined_fns
+            .entry(func_name.to_string())
+            .or_insert_with(|| p.reason(region));
     }
     // `report` observes but never changes execution; only `enforce` declines.
     matches!(mode, CostMode::Enforce)
@@ -996,7 +1005,13 @@ impl RegVm {
                             // function on the interpreter (cached below as not-native). `off`
                             // and `report` modes never change execution here.
                             let has_backedge = jit_function_has_loop(&func.code);
-                            if consult_profitability(native, &jit_fn, has_backedge, "whole-fn") {
+                            if consult_profitability(
+                                native,
+                                &jit_fn,
+                                has_backedge,
+                                "whole-fn",
+                                &func.name,
+                            ) {
                                 None
                             } else {
                                 let started = native.collect_stats.then(std::time::Instant::now);
@@ -1756,7 +1771,7 @@ impl RegVm {
                                 // Step 1 cost model: an OSR loop is always a back-edge region;
                                 // in `enforce` mode decline an unprofitable loop and resume on
                                 // the interpreter (correctness-safe).
-                                if consult_profitability(native, &jit_fn, true, "osr") {
+                                if consult_profitability(native, &jit_fn, true, "osr", &func.name) {
                                     return None;
                                 }
                                 let heap_input_regs = osr_heap_input_regs(&jit_fn);
@@ -2140,7 +2155,7 @@ impl RegVm {
                                     // Step 1 cost model: an OSR loop is always a back-edge
                                     // region; in `enforce` mode decline an unprofitable loop
                                     // and resume on the interpreter (correctness-safe).
-                                    if consult_profitability(native, &jit_fn, true, "osr") {
+                                    if consult_profitability(native, &jit_fn, true, "osr", &func.name) {
                                         return None;
                                     }
                                     let heap_input_regs = osr_heap_input_regs(&jit_fn);

crates/rsscript/tests/jit_acceptance.rs

@@ -4574,15 +4574,20 @@ fn main() -> Unit {
         "the PIC must be declined under the default cost model: {stats:?}",
     );
     let report = lines.join("\n");
-    // The cost-model decline summary is built from the actual run's telemetry, so it
-    // reliably shows the PIC decline with its score breakdown. (The per-function
-    // verdict re-translates WITHOUT profile feedback, so it may not reproduce the
-    // profile-guided PIC — the summary block is the dependable signal here.)
+    // The cost-model decline summary (built from this run's telemetry) shows the PIC
+    // decline with its score breakdown...
     assert!(
         report.contains("jit-report: cost-model decline summary")
             && report.contains("pic_sites=1"),
         "report must summarize the cost-model decline with its score breakdown, got:\n{report}",
     );
+    // ...and the per-function verdict now attributes it to the actual declined
+    // function via runtime attribution (item #2) — reliable even for a profile-guided
+    // PIC, which a re-derivation would miss.
+    assert!(
+        report.contains("not native: declined by cost model"),
+        "a function block must be attributed to the cost-model decline, got:\n{report}",
+    );
 }
 
 #[cfg(feature = "native-jit")]