From 41afa5c6dce6f171f76290cc3eccd48c8339fd0a Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 04:09:52 +0900
Subject: [PATCH 1/8] gc: root every SRE group selector before slicing

---
 pyre/extra_tests/snippets/stdlib_re.py              |  9 +++++++++
 pyre/pyre-interpreter/src/module/_sre/interp_sre.rs | 13 +++++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/pyre/extra_tests/snippets/stdlib_re.py b/pyre/extra_tests/snippets/stdlib_re.py
index 8613ddd30fc..eff3ef40bf0 100644
--- a/pyre/extra_tests/snippets/stdlib_re.py
+++ b/pyre/extra_tests/snippets/stdlib_re.py
@@ -62,6 +62,15 @@
 assert re.compile("(a)(bc)").match("abc")[1] == "a"
 assert re.compile("a(b)(?P<a>c)d").match("abcd").groupdict() == {"a": "c"}
 
+# Keep later dynamically-created selectors alive while each earlier group
+# slice allocates.  Repetition crosses the moving nursery boundary, exercising
+# the gateway argument-rooting path rather than only immortal integer indices.
+named_match = re.compile("(?P<left>a)(?P<right>bc)").match("abc")
+for i in range(4096):
+    left = ("left" + str(i))[:4]
+    right = ("right" + str(i))[:5]
+    assert named_match.group(left, right) == ("a", "bc")
+
 # test op branch
 assert re.compile(r"((?=\d|\.\d)(?P<int>\d*)|a)").match("123.2132").group() == "123"
 
diff --git a/pyre/pyre-interpreter/src/module/_sre/interp_sre.rs b/pyre/pyre-interpreter/src/module/_sre/interp_sre.rs
index 452d1c0666f..6f62cf60ee2 100644
--- a/pyre/pyre-interpreter/src/module/_sre/interp_sre.rs
+++ b/pyre/pyre-interpreter/src/module/_sre/interp_sre.rs
@@ -1743,9 +1743,18 @@ fn sre_match_group(args: &[PyObjectRef]) -> Result<PyObjectRef, crate::PyError>
         return Ok(unsafe { slice_w(m, span, w_none()) });
     }
     let _roots = pyre_object::gc_roots::push_roots();
-    let m = RootedObject::pin(m as PyObjectRef);
+    // Publish the match and every selector as one live set before performing
+    // any forwarding query.  Besides matching RPython's `args_w` liveness,
+    // this avoids a foreign collection entering between sequential pins while
+    // a later dynamically-created group name is still unpublished.
+    let args_base = pyre_object::gc_roots::pin_roots(args);
+    let m = RootedObject(args_base);
+    // RPython's GC transform keeps every entry in `args_w` live across each
+    // `slice_w` allocation.  The gateway's native argument copy is not a GC
+    // root, so read selectors back from that live set after every allocation.
     let mut results: Vec<RootedObject> = Vec::with_capacity(group_args.len());
-    for &w_arg in group_args {
+    for i in 0..group_args.len() {
+        let w_arg = pyre_object::gc_roots::shadow_stack_get(args_base + 1 + i);
         let span = do_span(m.get() as *const W_SRE_Match, Some(w_arg))?;
         results.push(RootedObject::pin(unsafe {
             slice_w(m.get() as *const W_SRE_Match, span, w_none())

From d39dcbfadd3e1b3579c447e5eca29e9717e88495 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 04:40:05 +0900
Subject: [PATCH 2/8] gc: preserve GIL across sandbox heap dumps

---
 pyre/pyre-interpreter/src/host_seam.rs     | 27 +++++++
 pyre/pyre-interpreter/src/module/gc/mod.rs |  2 +-
 pyre/pyre-sandbox/tests/e2e_interact.rs    | 93 +++++++++++++++++++---
 3 files changed, 111 insertions(+), 11 deletions(-)

diff --git a/pyre/pyre-interpreter/src/host_seam.rs b/pyre/pyre-interpreter/src/host_seam.rs
index dd321ab6824..cb608558822 100644
--- a/pyre/pyre-interpreter/src/host_seam.rs
+++ b/pyre/pyre-interpreter/src/host_seam.rs
@@ -510,6 +510,33 @@ declare_seam! {
     sleep(seconds: f64) -> unit = "ll_time.ll_time_sleep";
 }
 
+/// The sandbox trampoline for `inspector.py:89 raw_os_write`, whose
+/// `_nowrapper=True` declaration deliberately keeps the GIL held.  Heap
+/// dumping calls this while it owns the collector's `&mut MiniMarkGC` and,
+/// when another mutator exists, the stop-the-world guard.  The ordinary
+/// [`ops::write`] releases the GIL around the controller round trip; a waiting
+/// mutator can then acquire it and park at the active STW safepoint while still
+/// holding it, preventing the dump owner from reacquiring the GIL forever.
+///
+/// Keep this boundary private to the collector hook.  Every ordinary host
+/// operation must continue to use the release-GIL seam generated above.
+#[cfg(feature = "sandbox")]
+pub(crate) fn raw_heap_dump_write(fd: i32, data: &[u8]) -> SeamResult<i64> {
+    let args = [
+        MarshalValue::Int(fd as i64),
+        MarshalValue::Str(data.to_vec()),
+    ];
+    let result = client::syscall(
+        "ll_os.ll_os_write",
+        &args,
+        pyre_sandbox::protocol::ResultKind::Int,
+    )?;
+    match result {
+        SyscallResult::Int(written) => Ok(written),
+        _ => Err(SeamError::Runtime),
+    }
+}
+
 /// Read one process-environment value through the host seam.
 ///
 /// Keep this target-independent entry point at the module root: Charon's
diff --git a/pyre/pyre-interpreter/src/module/gc/mod.rs b/pyre/pyre-interpreter/src/module/gc/mod.rs
index 770be5ffea4..81fcaf76838 100644
--- a/pyre/pyre-interpreter/src/module/gc/mod.rs
+++ b/pyre/pyre-interpreter/src/module/gc/mod.rs
@@ -997,7 +997,7 @@ fn gc_call_method(
 
 #[cfg(feature = "sandbox")]
 fn heap_dump_write_via_host(fd: i32, bytes: &[u8]) -> Result<isize, i32> {
-    crate::host_seam::ops::write(fd, bytes)
+    crate::host_seam::raw_heap_dump_write(fd, bytes)
         .map(|written| written as isize)
         // A non-OS seam failure still needs an errno. Use the collector's code
         // for targets and failure modes that cannot supply one.
diff --git a/pyre/pyre-sandbox/tests/e2e_interact.rs b/pyre/pyre-sandbox/tests/e2e_interact.rs
index b8eef8f9c8c..ae051e95e95 100644
--- a/pyre/pyre-sandbox/tests/e2e_interact.rs
+++ b/pyre/pyre-sandbox/tests/e2e_interact.rs
@@ -31,10 +31,32 @@ fn workspace_root() -> PathBuf {
     p
 }
 
-/// Build the sandbox `pyre` binary once and return its path.  Cargo skips the
-/// work when the binary is already current, so repeated runs are cheap.
-fn build_sandbox_pyre() -> PathBuf {
+/// Build a trusted, non-sandbox controller and the sandbox child, then return
+/// both paths.  A sandbox-linked `pyre` cannot act as its own controller: even
+/// its startup environment reads are protocol trampolines.  The dedicated
+/// dynasm binary stays linked to the real host while the plain `pyre` binary is
+/// rebuilt as the untrusted child.
+fn build_sandbox_pyre() -> (PathBuf, PathBuf) {
     let root = workspace_root();
+    let controller_status = Command::new(env!("CARGO"))
+        .current_dir(&root)
+        .args([
+            "build",
+            "--release",
+            "-p",
+            "pyrex",
+            "--bin",
+            "pyre-dynasm",
+            "--no-default-features",
+            "--features",
+            "dynasm",
+        ])
+        .status()
+        .expect("spawn cargo build for sandbox controller");
+    assert!(
+        controller_status.success(),
+        "building sandbox controller failed"
+    );
     let status = Command::new(env!("CARGO"))
         .current_dir(&root)
         .args([
@@ -50,16 +72,27 @@ fn build_sandbox_pyre() -> PathBuf {
         .status()
         .expect("spawn cargo build");
     assert!(status.success(), "building sandbox pyre failed");
+    let controller = root.join("target/release/pyre-dynasm");
     let bin = root.join("target/release/pyre");
+    assert!(
+        controller.is_file(),
+        "sandbox controller missing at {}",
+        controller.display()
+    );
     assert!(bin.is_file(), "sandbox pyre missing at {}", bin.display());
-    bin
+    (controller, bin)
 }
 
 /// Run `pyre interact --tmp <root> <pyre> -c <script>` and return
 /// `(stdout, exit_code)`.  The controller relays the child's mediated stdout to
 /// its own, so `stdout` is the program output seen through the protocol.
-fn interact(pyre: &PathBuf, tmp: &std::path::Path, script: &str) -> (String, i32) {
-    let out = Command::new(pyre)
+fn interact(
+    controller: &PathBuf,
+    pyre: &PathBuf,
+    tmp: &std::path::Path,
+    script: &str,
+) -> (String, i32) {
+    let out = Command::new(controller)
         .args([
             "interact",
             "--tmp",
@@ -94,7 +127,7 @@ fn interact(pyre: &PathBuf, tmp: &std::path::Path, script: &str) -> (String, i32
 #[test]
 #[ignore = "builds a release sandbox binary; run with --ignored"]
 fn sandbox_reads_virtual_file_and_blocks_escapes() {
-    let pyre = build_sandbox_pyre();
+    let (controller, pyre) = build_sandbox_pyre();
     let tmp = tempfile::tempdir().expect("tempdir");
     std::fs::write(tmp.path().join("hello.txt"), b"sandbox-ok").unwrap();
 
@@ -102,6 +135,7 @@ fn sandbox_reads_virtual_file_and_blocks_escapes() {
     // Keep this VFS/seam probe binary: the controller intentionally mounts no
     // stdlib, so text-mode open would additionally require `encodings`.
     let (out, code) = interact(
+        &controller,
         &pyre,
         tmp.path(),
         r#"print(open("/tmp/hello.txt", "rb").read())"#,
@@ -111,6 +145,7 @@ fn sandbox_reads_virtual_file_and_blocks_escapes() {
 
     // 2. The virtual cwd is `/tmp`, not the controller's real directory.
     let (out, code) = interact(
+        &controller,
         &pyre,
         tmp.path(),
         "import posix\nprint('cwd:', posix.getcwd())",
@@ -120,6 +155,7 @@ fn sandbox_reads_virtual_file_and_blocks_escapes() {
 
     // 3. Reading outside the virtual root is denied (the node is absent).
     let (out, _) = interact(
+        &controller,
         &pyre,
         tmp.path(),
         "try:\n    open('/etc/passwd').read()\n    print('LEAK')\nexcept OSError:\n    print('BLOCKED')",
@@ -137,7 +173,7 @@ fn sandbox_reads_virtual_file_and_blocks_escapes() {
     let script = format!(
         "try:\n    open('/tmp/{sentinel}', 'w').write('x')\n    print('WROTE')\nexcept OSError:\n    print('BLOCKED')"
     );
-    let (out, _) = interact(&pyre, tmp.path(), &script);
+    let (out, _) = interact(&controller, &pyre, tmp.path(), &script);
     assert!(out.contains("BLOCKED"), "write attempt produced: {out:?}");
     assert!(!out.contains("WROTE"), "write attempt succeeded: {out:?}");
     // The controller created the file nowhere: neither in the virtual root's
@@ -161,7 +197,7 @@ fn sandbox_reads_virtual_file_and_blocks_escapes() {
 #[test]
 #[ignore = "builds a release sandbox binary; run with --ignored"]
 fn sandbox_blocks_known_escapes() {
-    let pyre = build_sandbox_pyre();
+    let (controller, pyre) = build_sandbox_pyre();
     let tmp = tempfile::tempdir().expect("tempdir");
 
     // Each `blocked` entry must raise (the function is stubbed/unavailable); a
@@ -231,10 +267,47 @@ for m in ("_socket", "_ctypes", "_posixsubprocess", "_multiprocessing",
 print("FAILS:" + ",".join(fails) if fails else "ALL-BLOCKED")
 "#;
 
-    let (out, code) = interact(&pyre, tmp.path(), script);
+    let (out, code) = interact(&controller, &pyre, tmp.path(), script);
     assert_eq!(code, 0, "escape-probe exited non-zero: {out:?}");
     assert!(
         out.contains("ALL-BLOCKED"),
         "escape regression detected: {out:?}"
     );
 }
+
+/// `inspector.py:89 raw_os_write` is `_nowrapper=True`: heap-dump writes keep
+/// the GIL because the dumper owns the collector and a stop-the-world window.
+/// Releasing it for the sandbox controller round trip lets this waiting worker
+/// acquire the GIL and park at the active STW safepoint while still holding
+/// it; the dump owner then deadlocks trying to reacquire it.
+#[test]
+#[ignore = "builds a release sandbox binary; run with --ignored"]
+fn sandbox_heap_dump_keeps_gil_while_world_is_stopped() {
+    let (controller, pyre) = build_sandbox_pyre();
+    let tmp = tempfile::tempdir().expect("tempdir");
+    let script = r#"
+import _thread, gc
+ready = _thread.allocate_lock()
+ready.acquire()
+stop = False
+
+def worker():
+    global stop
+    ready.release()
+    while not stop:
+        pass
+
+_thread.start_new_thread(worker, ())
+ready.acquire()
+for _ in range(3):
+    gc._dump_rpy_heap(2)
+stop = True
+print("HEAP_DUMP_DONE")
+"#;
+    let (out, code) = interact(&controller, &pyre, tmp.path(), script);
+    assert_eq!(code, 0, "sandbox heap dump timed out or failed");
+    assert!(
+        out.contains("HEAP_DUMP_DONE"),
+        "sandbox heap dump did not complete: {out:?}"
+    );
+}

From d354db4cb170732c3a74f96f493dab8dcbe4299e Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 05:09:50 +0900
Subject: [PATCH 3/8] gc: end action borrow before yielding GIL

---
 pyre/pyre-interpreter/src/executioncontext.rs | 53 +++++++++++++++----
 pyre/pyre-interpreter/src/module/gc/hook.rs   | 22 ++++----
 .../src/module/signal/interp_signal.rs        |  8 +--
 .../pyre-interpreter/src/module/thread/gil.rs | 15 ++++--
 4 files changed, 69 insertions(+), 29 deletions(-)

diff --git a/pyre/pyre-interpreter/src/executioncontext.rs b/pyre/pyre-interpreter/src/executioncontext.rs
index a7391ed88d6..d9d271bb5a2 100644
--- a/pyre/pyre-interpreter/src/executioncontext.rs
+++ b/pyre/pyre-interpreter/src/executioncontext.rs
@@ -1374,7 +1374,7 @@ impl ExecutionContext {
         if let Some(action) = self.check_signal_action {
             let self_ptr = self as *mut ExecutionContext;
             unsafe {
-                (*action).perform(&mut *self_ptr, std::ptr::null_mut())?;
+                perform_async_action(action, self_ptr, std::ptr::null_mut())?;
             }
         }
         Ok(())
@@ -1537,6 +1537,28 @@ pub extern "C" fn perform_pending_actions(ec_ptr: i64, frame_ptr: i64) -> i64 {
     }
 }
 
+/// Invoke one action, ending the action object's exclusive borrow before a
+/// requested GIL hand-off.  `GILReleaseAction` is process-owned, so the next
+/// thread can dispatch this same object as soon as it acquires the GIL.  A
+/// direct `perform()` implementation that yields would leave the first
+/// thread's `&mut dyn AsyncActionOps` live across that second mutable borrow.
+///
+/// # Safety
+///
+/// `action` and `ec` must point to live objects for the duration of the
+/// action call.  The caller must hold the GIL on entry.
+unsafe fn perform_async_action(
+    action: *mut dyn AsyncActionOps,
+    ec: *mut ExecutionContext,
+    frame: *mut PyFrame,
+) -> Result<(), crate::PyError> {
+    let control = unsafe { (*action).perform(&mut *ec, frame)? };
+    if control == AsyncActionControl::YieldGil {
+        majit_gc::rgil::yield_thread();
+    }
+    Ok(())
+}
+
 #[derive(Clone)]
 pub struct AbstractActionFlag {
     _periodic_actions: Vec<*mut dyn AsyncActionOps>,
@@ -1773,7 +1795,7 @@ pub trait ActionFlagOps {
                 continue;
             }
             unsafe {
-                (*action_ptr).perform(&mut *ec, frame)?;
+                perform_async_action(action_ptr, ec, frame)?;
             }
         }
         // executioncontext.py:543-556 — nonperiodic bit-mask scan.
@@ -1788,7 +1810,7 @@ pub trait ActionFlagOps {
                     self.abstract_flag_mut()._fired_bitmask &= !mask;
                     if !action_ptr.is_null() && !ec.is_null() {
                         unsafe {
-                            (*action_ptr).perform(&mut *ec, frame)?;
+                            perform_async_action(action_ptr, ec, frame)?;
                         }
                     }
                 }
@@ -2144,18 +2166,27 @@ impl AsyncAction {
 /// `*mut dyn AsyncActionOps` so the dispatcher reaches the override
 /// through the embedded vtable, and `fire` / `action_dispatcher` can
 /// reach the base bitmask through the accessor.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum AsyncActionControl {
+    Continue,
+    /// Complete the action call first, then hand the GIL to a waiter.
+    YieldGil,
+}
+
 pub trait AsyncActionOps {
     /// pypy/interpreter/executioncontext.py:608-609 `AsyncAction.perform`:
     /// `def perform(self, executioncontext, frame): "To be overridden."`
     ///
     /// Returns `Result` so an overriding action (e.g. `CheckSignalAction`)
     /// can raise — PyPy's `perform` propagates an `OperationError` up
-    /// through `action_dispatcher` to the eval loop.
+    /// through `action_dispatcher` to the eval loop.  The control value lets
+    /// the process-owned GIL action defer its hand-off until this method's
+    /// exclusive receiver has ended.
     fn perform(
         &mut self,
         executioncontext: &mut ExecutionContext,
         frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError>;
+    ) -> Result<AsyncActionControl, crate::PyError>;
 
     /// Composition accessor: shared `AsyncAction` state.
     fn async_action(&self) -> &AsyncAction;
@@ -2245,8 +2276,8 @@ impl AsyncActionOps for AsyncAction {
         &mut self,
         _executioncontext: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
-        Ok(())
+    ) -> Result<AsyncActionControl, crate::PyError> {
+        Ok(AsyncActionControl::Continue)
     }
 
     fn async_action(&self) -> &AsyncAction {
@@ -2335,8 +2366,8 @@ impl AsyncActionOps for PeriodicAsyncAction {
         &mut self,
         _executioncontext: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
-        Ok(())
+    ) -> Result<AsyncActionControl, crate::PyError> {
+        Ok(AsyncActionControl::Continue)
     }
 
     fn async_action(&self) -> &AsyncAction {
@@ -2557,13 +2588,13 @@ impl AsyncActionOps for UserDelAction {
         &mut self,
         _executioncontext: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
+    ) -> Result<AsyncActionControl, crate::PyError> {
         if self.collect_oldgen_before_run {
             self.collect_oldgen_before_run = false;
             pyre_object::gc_hook::try_gc_collect_oldgen();
         }
         self._run_finalizers();
-        Ok(())
+        Ok(AsyncActionControl::Continue)
     }
 
     fn async_action(&self) -> &AsyncAction {
diff --git a/pyre/pyre-interpreter/src/module/gc/hook.rs b/pyre/pyre-interpreter/src/module/gc/hook.rs
index 47a8bc6e174..10475a3f5b4 100644
--- a/pyre/pyre-interpreter/src/module/gc/hook.rs
+++ b/pyre/pyre-interpreter/src/module/gc/hook.rs
@@ -1,7 +1,9 @@
 //! App-level GC hooks — PyPy: `pypy/module/gc/hook.py`.
 
 use super::{new_collect_stats, new_collect_step_stats_full, new_minor_stats};
-use crate::executioncontext::{ActionFlagOps, AsyncAction, AsyncActionOps, ExecutionContext};
+use crate::executioncontext::{
+    ActionFlagOps, AsyncAction, AsyncActionControl, AsyncActionOps, ExecutionContext,
+};
 use crate::pyframe::PyFrame;
 use pyre_object::*;
 use std::sync::OnceLock;
@@ -78,14 +80,14 @@ impl AsyncActionOps for GcMinorHookAction {
         &mut self,
         _executioncontext: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
+    ) -> Result<AsyncActionControl, crate::PyError> {
         if self.depth != 0 {
-            return Ok(());
+            return Ok(AsyncActionControl::Continue);
         }
         self.depth += 1;
         let result = self.do_perform();
         self.depth -= 1;
-        result
+        result.map(|()| AsyncActionControl::Continue)
     }
 
     fn async_action(&self) -> &AsyncAction {
@@ -170,14 +172,14 @@ impl AsyncActionOps for GcCollectStepHookAction {
         &mut self,
         _executioncontext: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
+    ) -> Result<AsyncActionControl, crate::PyError> {
         if self.depth != 0 {
-            return Ok(());
+            return Ok(AsyncActionControl::Continue);
         }
         self.depth += 1;
         let result = self.do_perform();
         self.depth -= 1;
-        result
+        result.map(|()| AsyncActionControl::Continue)
     }
 
     fn async_action(&self) -> &AsyncAction {
@@ -262,14 +264,14 @@ impl AsyncActionOps for GcCollectHookAction {
         &mut self,
         _executioncontext: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
+    ) -> Result<AsyncActionControl, crate::PyError> {
         if self.depth != 0 {
-            return Ok(());
+            return Ok(AsyncActionControl::Continue);
         }
         self.depth += 1;
         let result = self.do_perform();
         self.depth -= 1;
-        result
+        result.map(|()| AsyncActionControl::Continue)
     }
 
     fn async_action(&self) -> &AsyncAction {
diff --git a/pyre/pyre-interpreter/src/module/signal/interp_signal.rs b/pyre/pyre-interpreter/src/module/signal/interp_signal.rs
index 02832edb03f..fd049b29ae9 100644
--- a/pyre/pyre-interpreter/src/module/signal/interp_signal.rs
+++ b/pyre/pyre-interpreter/src/module/signal/interp_signal.rs
@@ -4,7 +4,8 @@
 
 use super::signalstate;
 use crate::executioncontext::{
-    AsyncAction, AsyncActionOps, ExecutionContext, PeriodicAsyncAction, PeriodicAsyncActionOps,
+    AsyncAction, AsyncActionControl, AsyncActionOps, ExecutionContext, PeriodicAsyncAction,
+    PeriodicAsyncActionOps,
 };
 use crate::pyframe::PyFrame;
 use pyre_object::PyObjectRef;
@@ -423,8 +424,9 @@ impl AsyncActionOps for CheckSignalAction {
         &mut self,
         ec: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
-        self.poll_for_signals(ec)
+    ) -> Result<AsyncActionControl, crate::PyError> {
+        self.poll_for_signals(ec)?;
+        Ok(AsyncActionControl::Continue)
     }
 
     fn async_action(&self) -> &AsyncAction {
diff --git a/pyre/pyre-interpreter/src/module/thread/gil.rs b/pyre/pyre-interpreter/src/module/thread/gil.rs
index 02c7b7fdf1b..b2f5fbdf0d3 100644
--- a/pyre/pyre-interpreter/src/module/thread/gil.rs
+++ b/pyre/pyre-interpreter/src/module/thread/gil.rs
@@ -11,7 +11,8 @@ use std::sync::OnceLock;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use crate::executioncontext::{
-    AsyncAction, AsyncActionOps, ExecutionContext, PeriodicAsyncAction, PeriodicAsyncActionOps,
+    AsyncAction, AsyncActionControl, AsyncActionOps, ExecutionContext, PeriodicAsyncAction,
+    PeriodicAsyncActionOps,
 };
 use crate::pyframe::PyFrame;
 use pyre_object::PyObjectRef;
@@ -32,14 +33,18 @@ impl GilReleaseAction {
 }
 
 impl AsyncActionOps for GilReleaseAction {
-    /// gil.py:48-50 `perform`: `rgil.yield_thread()`.
+    /// gil.py:48-50 `perform`: request `rgil.yield_thread()`.
+    ///
+    /// The dispatcher performs the request after this method returns so its
+    /// `&mut GilReleaseAction` has ended before another thread dispatches the
+    /// same process-owned action.  This is the Rust ownership boundary around
+    /// the otherwise line-for-line upstream hand-off.
     fn perform(
         &mut self,
         _ec: &mut ExecutionContext,
         _frame: *mut PyFrame,
-    ) -> Result<(), crate::PyError> {
-        majit_gc::rgil::yield_thread();
-        Ok(())
+    ) -> Result<AsyncActionControl, crate::PyError> {
+        Ok(AsyncActionControl::YieldGil)
     }
 
     fn async_action(&self) -> &AsyncAction {

From 04d64528097eb42e209a168df3515e588b2c0720 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 05:59:30 +0900
Subject: [PATCH 4/8] gc: make async ticker signal-safe

---
 majit/majit-ir/src/eval_breaker_word.rs       |  5 +-
 pyre/extra_tests/snippets/stdlib_signal.py    |  2 +-
 pyre/pyre-interpreter/src/executioncontext.rs | 81 ++++++++++++-------
 .../src/module/signal/signalstate.rs          | 80 ++++++++++--------
 4 files changed, 106 insertions(+), 62 deletions(-)

diff --git a/majit/majit-ir/src/eval_breaker_word.rs b/majit/majit-ir/src/eval_breaker_word.rs
index bde809bf521..4db21a45c46 100644
--- a/majit/majit-ir/src/eval_breaker_word.rs
+++ b/majit/majit-ir/src/eval_breaker_word.rs
@@ -1,8 +1,9 @@
 //! The single process-global eval-breaker word polled by JIT-compiled loop
 //! back-edges. One `AtomicUsize` whose bits fold the two former back-edge
 //! polls into one load + one nonzero branch:
-//!   bit0 EB_ASYNC — mirrors a negative async ticker (`ActionFlag._ticker < 0`);
-//!                   OR'd in by the OS signal handler and the action dispatcher.
+//!   bit0 EB_ASYNC — an async ticker request; OR'd in by the OS signal handler
+//!                   and action dispatcher, then copied into
+//!                   `ActionFlag._ticker` at a safe interpreter checkpoint.
 //!   bit1 EB_STW   — mirrors `GC_SYNC.stw_requested`; OR'd in by the collector
 //!                   while it drains mutators to safepoints.
 //!   bit2 EB_FINALIZING — mirrors interpreter finalization; once armed,
diff --git a/pyre/extra_tests/snippets/stdlib_signal.py b/pyre/extra_tests/snippets/stdlib_signal.py
index 9d0b13bbd67..fe979ceba1f 100644
--- a/pyre/extra_tests/snippets/stdlib_signal.py
+++ b/pyre/extra_tests/snippets/stdlib_signal.py
@@ -22,7 +22,7 @@ def handler(signum, frame):
 
 
 # unix
-if "win" not in sys.platform:
+if not sys.platform.startswith("win"):
     signal.signal(signal.SIGALRM, handler)
     assert signal.getsignal(signal.SIGALRM) is handler
 
diff --git a/pyre/pyre-interpreter/src/executioncontext.rs b/pyre/pyre-interpreter/src/executioncontext.rs
index d9d271bb5a2..e612cfa2d54 100644
--- a/pyre/pyre-interpreter/src/executioncontext.rs
+++ b/pyre/pyre-interpreter/src/executioncontext.rs
@@ -764,6 +764,10 @@ impl ExecutionContext {
                 let w_exc = crate::builtins::exc_exception_new(&[w_async_exception_type])?;
                 return Err(unsafe { crate::PyError::from_exc_object(w_exc) });
             }
+            // The OS signal handler may only touch atomics.  Copy its breaker
+            // request into the ordinary ActionFlag ticker here, under the GIL,
+            // before the upstream decrement-and-dispatch sequence below.
+            self.actionflag.sync_async_ticker();
         }
         // executioncontext.py:158-165 bytecode_trace:
         //   def bytecode_trace(self, frame, decr_by=TICK_COUNTER_STEP):
@@ -954,6 +958,9 @@ impl ExecutionContext {
         frame: *mut PyFrame,
     ) -> Result<(), crate::PyError> {
         self.bytecode_only_trace(frame)?;
+        if majit_ir::eval_breaker_word::load() & majit_ir::eval_breaker_word::EB_ASYNC != 0 {
+            self.actionflag.sync_async_ticker();
+        }
         if self.actionflag.get_ticker() < 0 {
             // executioncontext.py:207-208 — `if actionflag.get_ticker()
             // < 0: actionflag.action_dispatcher(self, frame)`.  Routed
@@ -1515,6 +1522,16 @@ pub fn disarm_async_eval_breaker() {
     majit_ir::eval_breaker_word::clear_async();
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+fn has_pending_signal_action() -> bool {
+    crate::module::signal::signalstate::has_pending_signals()
+}
+
+#[cfg(target_arch = "wasm32")]
+fn has_pending_signal_action() -> bool {
+    false
+}
+
 /// `dont_look_inside` so the tracer treats it as an opaque call and never
 /// follows the action machinery's trait-object virtual dispatch +
 /// `Result<(), PyError>` propagation (which the JIT codewriter cannot
@@ -1831,16 +1848,12 @@ pub trait ActionFlagOps {
 ///
 /// PyPy starts with a plain `ActionFlag` (its ticker is a Python field)
 /// and, when the `signal` module loads, rebinds `space.actionflag` to a
-/// `SignalActionFlag` whose ticker IS the C `pypysig_counter` cell so the
-/// OS signal handler can force it negative.  pyre merges the two: the
-/// ticker stays a plain `_ticker` field (a plain field read is what the
-/// JIT codewriter can model in the per-bytecode hot path — an atomic /
-/// volatile global read is not), and the OS signal handler writes -1 into
-/// it through a pointer registered at startup
-/// (`signalstate::register_ticker` ← `ticker_addr`).  This is the same
-/// arrangement as upstream's volatile `pypysig_counter.value`: the
-/// handler stores through the cell's address while the interpreter reads
-/// the field directly.
+/// `SignalActionFlag` whose ticker is the C `pypysig_counter` cell.  pyre
+/// merges the two while respecting Rust's memory model: `_ticker` remains a
+/// plain field for the translated per-bytecode hot path, the OS handler arms
+/// the atomic process eval breaker, and `sync_async_ticker` makes the field
+/// negative at the next safe interpreter checkpoint.  No asynchronous code
+/// reads or writes `_ticker`.
 #[derive(Clone)]
 pub struct ActionFlag {
     base: AbstractActionFlag,
@@ -1865,14 +1878,23 @@ impl ActionFlag {
         let _ = (ec, frame);
     }
 
-    /// Address of the ticker cell, handed to `signalstate::register_ticker`
-    /// so the OS signal handler can force the ticker negative.  Stable for
-    /// the process lifetime — the `ExecutionContext` is created once and
-    /// never moved (held behind an `Rc` in pyrex).
+    /// Address used to identify this as the signal-driving ticker.  The OS
+    /// handler never dereferences it; it is stable for the process lifetime
+    /// because the owning process `ActionFlag` allocation never moves.
     pub fn ticker_addr(&mut self) -> *mut isize {
         &mut self._ticker
     }
 
+    /// Transfer an asynchronous eval-breaker request into the registered
+    /// ticker.  Called only by the owning interpreter thread while it holds
+    /// the GIL and after observing `EB_ASYNC`; the OS signal handler never
+    /// accesses `_ticker` itself.
+    pub(crate) fn sync_async_ticker(&mut self) {
+        if self.is_registered_ticker() {
+            self._ticker = -1;
+        }
+    }
+
     /// True when `self._ticker` is the signal-registered ticker cell — the
     /// single cell compiled-loop back-edges poll. Only that ticker drives the
     /// shared async bit; per-EC flags that are not the registered breaker
@@ -1909,8 +1931,8 @@ impl ActionFlagOps for ActionFlag {
     }
 
     /// interp_signal.py:30-32 `SignalActionFlag.get_ticker` — `p.c_value`.
-    /// The cell is the `_ticker` field; the OS handler writes it through
-    /// the registered pointer (`ticker_addr`).
+    /// The safe-checkpoint synchronization above is the Rust equivalent of
+    /// the signal handler making this cell negative.
     fn get_ticker(&self) -> isize {
         self._ticker
     }
@@ -1923,17 +1945,18 @@ impl ActionFlagOps for ActionFlag {
             if value < 0 {
                 arm_async_eval_breaker();
             } else {
-                if !crate::module::thread::has_pending_async_exception() {
+                let async_work_pending = crate::module::thread::has_pending_async_exception()
+                    || has_pending_signal_action();
+                if !async_work_pending {
                     disarm_async_eval_breaker();
                 }
-                // A signal delivered between the ticker store and this clear
-                // rearms the ticker to -1 and re-sets the async bit; the clear
-                // would then drop it, leaving a negative ticker with the bit
-                // clear so a non-allocating compiled loop misses the signal.
-                // Re-read the ticker — the handler writes it through the
-                // registered pointer, so force a fresh load — and restore the
-                // bit if it was rearmed.
-                if unsafe { std::ptr::read_volatile(&self._ticker) } < 0 {
+                // A signal/async exception published between the first
+                // pending check and the clear above must re-arm the bit.  If
+                // it arrives after this second check, its publisher runs
+                // after the clear and leaves the bit armed itself.
+                if crate::module::thread::has_pending_async_exception()
+                    || has_pending_signal_action()
+                {
                     arm_async_eval_breaker();
                 }
             }
@@ -2004,8 +2027,8 @@ impl SpaceActionFlag {
 
     fn inner(&self) -> &ActionFlag {
         // SAFETY: SPACE_ACTIONFLAG owns one leaked process-lifetime value.
-        // Interpreter calls are serialized by the GIL; shared signal writes
-        // touch only `_ticker` through its registered raw address.
+        // Interpreter calls are serialized by the GIL; the signal handler
+        // touches only process-global atomics, never this allocation.
         unsafe { &*self.ptr }
     }
 
@@ -2027,6 +2050,10 @@ impl SpaceActionFlag {
     pub fn ticker_addr(&mut self) -> *mut isize {
         self.inner_mut().ticker_addr()
     }
+
+    pub(crate) fn sync_async_ticker(&mut self) {
+        self.inner_mut().sync_async_ticker()
+    }
 }
 
 impl ActionFlagOps for SpaceActionFlag {
diff --git a/pyre/pyre-interpreter/src/module/signal/signalstate.rs b/pyre/pyre-interpreter/src/module/signal/signalstate.rs
index f40a7d4745a..68b7716be4d 100644
--- a/pyre/pyre-interpreter/src/module/signal/signalstate.rs
+++ b/pyre/pyre-interpreter/src/module/signal/signalstate.rs
@@ -2,14 +2,10 @@
 //!
 //! The OS signal handler runs in an async context where almost nothing
 //! is safe to do, so it only flips atomic flags: it records the signal
-//! number in `SIG_PENDING`, forces `SIG_TICKER` to -1 (so the next
-//! `bytecode_trace` runs `action_dispatcher`), and writes one byte to
-//! the wakeup fd.  The actual app-level handler is invoked later, from
-//! `CheckSignalAction::perform`, at a safe interpreter checkpoint.
-//!
-//! `SIG_TICKER` is the analogue of C `pypysig_counter.inner.value`; the
-//! `ActionFlag` ticker methods (`SignalActionFlag` in upstream) read and
-//! write it directly so the handler and the eval loop share one cell.
+//! number in `SIG_PENDING`, arms the process eval breaker (so the next
+//! `bytecode_trace` runs `action_dispatcher`), and writes one byte to the
+//! wakeup fd.  The actual app-level handler and the ticker update happen
+//! later, from a safe interpreter checkpoint.
 
 use std::sync::atomic::{AtomicBool, AtomicI32, AtomicI64, AtomicPtr, Ordering};
 
@@ -17,13 +13,12 @@ use std::sync::atomic::{AtomicBool, AtomicI32, AtomicI64, AtomicPtr, Ordering};
 /// surface `NSIG` portably.  64 fits a single `i64` bitmask.
 pub const NSIG: i32 = 64;
 
-/// Address of the `ActionFlag` ticker cell (`signals.c:45-49
-/// pypysig_counter`).  The interpreter reads the cell directly as a
-/// plain field in the per-bytecode hot path (an atomic / volatile global
-/// read there is not modellable by the JIT codewriter); the OS handler
-/// stores -1 through this registered pointer, exactly like upstream
-/// writing the volatile `pypysig_counter.value` via its address.  Null
-/// until `register_ticker` runs at startup.
+/// Identity of the signal-driving `ActionFlag` ticker cell (`signals.c:45-49
+/// pypysig_counter`).  The pointer is compared by the interpreter but never
+/// dereferenced by the OS handler: Rust volatile access would still race the
+/// ordinary field reads and writes.  The handler arms the atomic eval breaker,
+/// and `ExecutionContext::bytecode_trace` copies that request into this cell
+/// while holding the GIL.  Null until `register_ticker` runs at startup.
 static TICKER_PTR: AtomicPtr<isize> = AtomicPtr::new(std::ptr::null_mut());
 
 /// `signals.c:51 pypysig_flags_bits` — one bit per pending signal.
@@ -65,16 +60,10 @@ pub fn registered_ticker_ptr() -> *mut isize {
     TICKER_PTR.load(Ordering::SeqCst)
 }
 
-/// Store -1 into the ticker cell so the next `decrement_ticker` runs
-/// `action_dispatcher`.  Async-signal-safe: a single aligned word store.
+/// Arm the process breaker so the next bytecode checkpoint makes the
+/// registered ticker negative and runs `action_dispatcher`.  This is a
+/// lock-free atomic RMW and is safe in the OS signal handler.
 pub(crate) fn rearm_ticker() {
-    let p = TICKER_PTR.load(Ordering::SeqCst);
-    if !p.is_null() {
-        unsafe { std::ptr::write_volatile(p, -1) };
-    }
-    // The signal handler also arms the JIT back-edge trigger. This runs even
-    // before a ticker address is registered because compiled loops poll the
-    // process-global word directly.
     majit_ir::eval_breaker_word::set_async();
 }
 
@@ -107,6 +96,14 @@ pub fn signal_poll() -> i32 {
     -1
 }
 
+/// Whether a signal bit remains for `CheckSignalAction` to consume.  The
+/// action dispatcher uses this authoritative state when clearing the async
+/// eval-breaker bit, closing the race where a signal arrives immediately
+/// before that clear.
+pub(crate) fn has_pending_signals() -> bool {
+    SIG_PENDING.load(Ordering::SeqCst) != 0
+}
+
 // ── wakeup fd (signals.c:246-272 pypysig_set_wakeup_fd) ──
 
 /// `signals.c:246-272 pypysig_set_wakeup_fd` — install `fd`, return the
@@ -264,13 +261,14 @@ mod tests {
     }
 
     /// Drives process-global signal state: installs a real SIGINT handler,
-    /// registers this `ActionFlag`'s ticker as *the* cell the handler writes
-    /// (`TICKER_PTR`), raises a real signal, and asserts on the shared
-    /// eval-breaker word. Nothing serializes that, so this must stay the only
-    /// test in the crate that touches those globals — a second one running in
-    /// parallel would race it. Tests that merely build an `ActionFlag` are safe
-    /// alongside it: the async-bit mirror is gated on the registered ticker, so
-    /// an unregistered flag's `reset_ticker` never reaches the shared word.
+    /// registers this `ActionFlag` as the signal-driving ticker, raises a real
+    /// signal, and asserts that the handler touches only atomic state until a
+    /// safe checkpoint synchronizes the ticker. Nothing serializes those
+    /// process globals, so this must stay the only test in the crate that
+    /// touches them — a second one running in parallel would race it. Tests
+    /// that merely build an `ActionFlag` are safe alongside it: the async-bit
+    /// mirror is gated on the registered ticker, so an unregistered flag's
+    /// `reset_ticker` never reaches the shared word.
     #[test]
     fn signal_during_warmup_sets_async_bit() {
         let _reset = ResetSignalState;
@@ -281,12 +279,30 @@ mod tests {
 
         assert!(pypysig_setflag(libc::SIGINT));
         assert_eq!(unsafe { libc::raise(libc::SIGINT) }, 0);
-        assert!(actionflag.get_ticker() < 0);
+        assert!(
+            actionflag.get_ticker() >= 0,
+            "the async handler must not write the plain Rust ticker field"
+        );
         assert_ne!(
             load_eval_breaker_word() & majit_ir::eval_breaker_word::EB_ASYNC,
             0,
             "the real signal handler must arm bit0"
         );
+        actionflag.sync_async_ticker();
+        assert!(actionflag.get_ticker() < 0);
+
+        // `action_dispatcher` resets the ticker before CheckSignalAction polls.
+        // The still-pending signal bit must keep the shared breaker armed
+        // across that reset; the same reset can also happen independently via
+        // setcheckinterval, before any signal action has consumed the bit.
+        actionflag.reset_ticker(100);
+        assert_ne!(
+            load_eval_breaker_word() & majit_ir::eval_breaker_word::EB_ASYNC,
+            0,
+            "a positive ticker reset must not clear a pending signal"
+        );
+        actionflag.sync_async_ticker();
+        assert!(actionflag.get_ticker() < 0);
         assert_eq!(signal_poll(), libc::SIGINT);
 
         actionflag

From 6d3a6faa7bd7979fd854c8037d60fcbe3e0280bb Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 06:36:02 +0900
Subject: [PATCH 5/8] gc: root the process signal action

---
 pyre/pyre-interpreter/src/eval.rs             |  2 +
 pyre/pyre-interpreter/src/executioncontext.rs |  4 +-
 .../src/module/signal/interp_signal.rs        | 75 +++++++++++++------
 pyre/pyrex/src/lib.rs                         | 20 ++++-
 4 files changed, 77 insertions(+), 24 deletions(-)

diff --git a/pyre/pyre-interpreter/src/eval.rs b/pyre/pyre-interpreter/src/eval.rs
index fb54670671e..556de31f9cb 100644
--- a/pyre/pyre-interpreter/src/eval.rs
+++ b/pyre/pyre-interpreter/src/eval.rs
@@ -1186,6 +1186,8 @@ fn walk_interpreter_global_roots(visitor: &mut dyn FnMut(&mut majit_ir::GcRef))
         crate::cpyext::walk_gc_roots(&mut forward);
     }
     crate::executioncontext::walk_space_user_del_action_roots(visitor);
+    #[cfg(not(target_arch = "wasm32"))]
+    crate::module::signal::interp_signal::walk_check_signal_action_roots(visitor);
     crate::module::gc::hook::walk_hook_roots(visitor);
     crate::module::thread::walk_thread_roots(visitor);
     #[cfg(all(not(target_arch = "wasm32"), not(feature = "sandbox")))]
diff --git a/pyre/pyre-interpreter/src/executioncontext.rs b/pyre/pyre-interpreter/src/executioncontext.rs
index e612cfa2d54..27b4a5333d9 100644
--- a/pyre/pyre-interpreter/src/executioncontext.rs
+++ b/pyre/pyre-interpreter/src/executioncontext.rs
@@ -341,8 +341,8 @@ pub struct ExecutionContext {
     /// `pypy/interpreter/baseobjspace.py` `space.check_signal_action` —
     /// the `CheckSignalAction` registered when the `signal` module loads.
     /// `checksignals` calls its `perform` directly.  Stored as a trait
-    /// pointer into the leaked action owned by `module::_signal`
-    /// (`install_signal_handling`); `None` until installed.
+    /// pointer into the process object-space singleton owned by
+    /// `module::_signal` (`install_signal_handling`); `None` until installed.
     pub check_signal_action: Option<*mut dyn AsyncActionOps>,
     /// `executioncontext.py sys_exc_operror` — the active exception for
     /// `sys.exc_info()` / bare `raise`, saved/restored across handler
diff --git a/pyre/pyre-interpreter/src/module/signal/interp_signal.rs b/pyre/pyre-interpreter/src/module/signal/interp_signal.rs
index fd049b29ae9..5b308c62972 100644
--- a/pyre/pyre-interpreter/src/module/signal/interp_signal.rs
+++ b/pyre/pyre-interpreter/src/module/signal/interp_signal.rs
@@ -10,6 +10,7 @@ use crate::executioncontext::{
 use crate::pyframe::PyFrame;
 use pyre_object::PyObjectRef;
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::OnceLock;
 
 /// executioncontext.py:436-441 `space.getexecutioncontext().checksignals()`
 /// — deliver a signal that may have arrived during a syscall.  Resolves
@@ -440,35 +441,67 @@ impl AsyncActionOps for CheckSignalAction {
 
 impl PeriodicAsyncActionOps for CheckSignalAction {}
 
+// `moduledef.py:64-66` stores one `CheckSignalAction` on the object space.
+// Pyre's typed Rust object space is still process-owned, so keep the same
+// singleton shape here rather than leaking and registering a new action for
+// every top-level ExecutionContext created by an embedding.
+static CHECK_SIGNAL_ACTION: OnceLock<usize> = OnceLock::new();
+
+fn check_signal_action() -> *mut CheckSignalAction {
+    CHECK_SIGNAL_ACTION.get().copied().unwrap_or(0) as *mut CheckSignalAction
+}
+
+/// Trace the object-space-owned signal action's managed `space` slot.  PyPy's
+/// translated object graph reaches it through `space.check_signal_action`;
+/// pyre's process-owned Rust allocation needs that edge forwarded explicitly.
+pub(crate) fn walk_check_signal_action_roots(
+    visitor: &mut dyn FnMut(&mut majit_ir::GcRef),
+) {
+    let action = check_signal_action();
+    if action.is_null() {
+        return;
+    }
+    let slot = unsafe { &mut (*action).base.base.space };
+    if !slot.is_null() {
+        visitor(unsafe { &mut *(slot as *mut PyObjectRef as *mut majit_ir::GcRef) });
+    }
+}
+
 /// moduledef.py:62-66 + app_main.py:926 — install the signal-checking
-/// action on the execution context and route SIGINT to
-/// `default_int_handler` (so Ctrl-C raises `KeyboardInterrupt`).  Called
-/// once at interpreter startup.  Idempotent: a second call is a no-op.
+/// action on the process object space, cache its pointer on this execution
+/// context, and route SIGINT to `default_int_handler` (so Ctrl-C raises
+/// `KeyboardInterrupt`).  Repeated top-level runtime setup reuses the same
+/// action, matching `space.check_signal_action` rather than registering a
+/// duplicate periodic action.
 pub fn install_signal_handling(ec: &mut ExecutionContext) {
     if ec.check_signal_action.is_some() {
         return;
     }
-    // moduledef.py:64-66 — register the periodic signal-check action.
-    // The action outlives the call (the EC and actionflag hold pointers
-    // into it for the whole run), so it is leaked deliberately.
-    let action: &'static mut CheckSignalAction = Box::leak(CheckSignalAction::new(ec.space));
-    let async_ptr: *mut dyn AsyncActionOps = &mut *action;
-    action.register_periodic_action(ec.actionflag.shared_mut(), false);
-    ec.check_signal_action = Some(async_ptr);
+    let action_addr = *CHECK_SIGNAL_ACTION.get_or_init(|| {
+        // moduledef.py:64-66 — construct and register the one signal action
+        // owned by the process object space.
+        let action: &'static mut CheckSignalAction =
+            Box::leak(CheckSignalAction::new(ec.space));
+        action.register_periodic_action(ec.actionflag.shared_mut(), false);
 
-    // Hand the ticker cell address to the OS handler so it can force the
-    // ticker negative (rsignal.py:31-32 `pypysig_getaddr_occurred`).
-    let ticker_addr = ec.actionflag.ticker_addr();
-    signalstate::register_ticker(ticker_addr);
+        // Hand the ticker cell address to the OS handler so it can force the
+        // ticker negative (rsignal.py:31-32 `pypysig_getaddr_occurred`).
+        let ticker_addr = ec.actionflag.ticker_addr();
+        signalstate::register_ticker(ticker_addr);
 
-    // app_main.py:926 — `signal.signal(SIGINT, default_int_handler)`.
-    #[cfg(unix)]
-    {
-        let sigint = libc::SIGINT;
-        if signalstate::pypysig_setflag(sigint) {
-            set_handler(sigint, default_int_handler_obj());
+        // app_main.py:926 — `signal.signal(SIGINT, default_int_handler)`.
+        #[cfg(unix)]
+        {
+            let sigint = libc::SIGINT;
+            if signalstate::pypysig_setflag(sigint) {
+                set_handler(sigint, default_int_handler_obj());
+            }
         }
-    }
+        action as *mut CheckSignalAction as usize
+    });
+    let action = action_addr as *mut CheckSignalAction;
+    let async_ptr: *mut dyn AsyncActionOps = action;
+    ec.check_signal_action = Some(async_ptr);
 }
 
 /// _signal module — PyPy: pypy/module/signal/.
diff --git a/pyre/pyrex/src/lib.rs b/pyre/pyrex/src/lib.rs
index da47134b48f..3014cc9f98f 100644
--- a/pyre/pyrex/src/lib.rs
+++ b/pyre/pyrex/src/lib.rs
@@ -1832,7 +1832,7 @@ fn run_source(source: &str, mode: Mode, filename: &str, no_site: bool) {
 
 #[cfg(test)]
 mod tests {
-    use super::parse_heapsize;
+    use super::{parse_heapsize, set_last_exec_ctx, setup_exec_context};
 
     #[test]
     fn heapsize_suffixes_and_validation() {
@@ -1846,4 +1846,22 @@ mod tests {
         assert!(parse_heapsize("abc").is_err());
         assert!(parse_heapsize("").is_err());
     }
+
+    #[test]
+    fn repeated_runtime_setup_reuses_space_signal_action() {
+        // pypy/module/signal/moduledef.py:64-66 owns this action on `space`,
+        // not on an ExecutionContext.  Embeddings may create more than one
+        // top-level EC in a process; each must cache the same action pointer
+        // without adding another process-lifetime Box/actionflag entry.
+        let first = setup_exec_context();
+        let first_action = first
+            .check_signal_action
+            .expect("runtime setup installs signal action");
+        let second = setup_exec_context();
+        let second_action = second
+            .check_signal_action
+            .expect("repeated runtime setup installs signal action");
+        assert!(std::ptr::addr_eq(first_action, second_action));
+        set_last_exec_ctx(std::ptr::null());
+    }
 }

From 7f2356c6af6a1cae1ad202b9aacce747e2cfaf2c Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 08:07:45 +0900
Subject: [PATCH 6/8] gc: root the pairwise iteration state across space.next
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`next`'s `itertools.pairwise` arm held `self` and `w_prev` in raw Rust locals
across two `space.next` calls. A minor collection inside either call forwards
the object but not the local, so the field stores and the returned tuple could
name pre-collection addresses.

The arm now claims four shadow-stack slots — self, iterator, w_prev, w_next —
before the first call and reloads each from its slot. The indices are fixed
rather than derived from how many roots the taken arm happened to push, so a
slot means the same thing on both paths; the two slots that start without a
value hold null, which the root walkers already read as "no root".

`interp_itertools` gains the field accessors that arm reads and writes through.
The setter runs the write barrier, because `W_Pairwise` is allocated old-gen
and an iterator may yield a nursery object.

The `W_Pairwise` unit test now asserts the GC descriptor's pointer offsets
cover `w_iterator` and `w_prev`, not just the object size.

Assisted-by: Claude
---
 pyre/pyre-interpreter/src/baseobjspace.rs | 46 ++++++++++++++++++-----
 pyre/pyre-object/src/interp_itertools.rs  | 42 ++++++++++++++++++++-
 2 files changed, 76 insertions(+), 12 deletions(-)

diff --git a/pyre/pyre-interpreter/src/baseobjspace.rs b/pyre/pyre-interpreter/src/baseobjspace.rs
index 87ba4db339d..a29c172d5c4 100644
--- a/pyre/pyre-interpreter/src/baseobjspace.rs
+++ b/pyre/pyre-interpreter/src/baseobjspace.rs
@@ -16261,18 +16261,44 @@ pub fn next(obj: PyObjectRef) -> PyResult {
         //         self.w_prev = w_next
         //         return space.newtuple2(w_prev, w_next)
         if pyre_object::interp_itertools::is_pairwise(obj) {
-            let it = &mut *(obj as *mut pyre_object::interp_itertools::W_Pairwise);
-            let mut w_prev = it.w_prev;
-            if w_prev.is_null() {
-                w_prev = next(it.w_iterator)?;
+            use pyre_object::interp_itertools as pairwise;
+
+            // `space.next` may allocate and move either yielded item. RPython's
+            // shadow-stack transform keeps `self` and `w_prev` live across the
+            // second call and reloads both before the final stores/newtuple2.
+            // Keep the same livevar set explicitly; in particular, the
+            // barriered `self.w_prev` field is forwarded by a minor collection
+            // but a raw Rust local copied before that collection is not.
+            // The bracket claims its whole livevar set up front, so a slot's
+            // index does not depend on which arm ran. `w_prev` is PY_NULL until
+            // the first result and `w_next` has no value yet, and reserving a
+            // slot for each is what lets the reloads below be plain `get`s; a
+            // null slot is what the root walkers already read as "no root".
+            const SELF: usize = 0;
+            const ITERATOR: usize = 1;
+            const PREV: usize = 2;
+            const NEXT: usize = 3;
+
+            let roots = pyre_object::gc_roots::push_roots();
+            let base = roots.base();
+            roots.pin_root(obj);
+            roots.pin_root(pairwise::w_pairwise_get_iterator(roots.get(base + SELF)));
+            roots.pin_root(pairwise::w_pairwise_get_prev(roots.get(base + SELF)));
+            roots.pin_root(std::ptr::null_mut());
+
+            if roots.get(base + PREV).is_null() {
+                let w_prev = next(roots.get(base + ITERATOR))?;
+                roots.set(base + PREV, w_prev);
                 // set before fetching w_next to handle reentrancy
-                it.w_prev = w_prev;
-                pyre_object::gc_hook::try_gc_write_barrier(obj as *mut u8);
+                pairwise::w_pairwise_set_prev(roots.get(base + SELF), roots.get(base + PREV));
             }
-            let w_next = next(it.w_iterator)?;
-            it.w_prev = w_next;
-            pyre_object::gc_hook::try_gc_write_barrier(obj as *mut u8);
-            return Ok(pyre_object::w_tuple_new(vec![w_prev, w_next]));
+            let w_next = next(roots.get(base + ITERATOR))?;
+            roots.set(base + NEXT, w_next);
+            pairwise::w_pairwise_set_prev(roots.get(base + SELF), roots.get(base + NEXT));
+            return Ok(pyre_object::w_tuple_new(vec![
+                roots.get(base + PREV),
+                roots.get(base + NEXT),
+            ]));
         }
         // itertools.cycle — interp_itertools.py W_Cycle.next_w
         //
diff --git a/pyre/pyre-object/src/interp_itertools.rs b/pyre/pyre-object/src/interp_itertools.rs
index 30882613958..5cd1acd87da 100644
--- a/pyre/pyre-object/src/interp_itertools.rs
+++ b/pyre/pyre-object/src/interp_itertools.rs
@@ -1060,6 +1060,37 @@ pub unsafe fn is_pairwise(obj: PyObjectRef) -> bool {
     unsafe { py_type_check(obj, &PAIRWISE_TYPE) }
 }
 
+/// Read the source iterator.
+///
+/// # Safety
+/// `obj` must point to a valid `W_Pairwise`.
+#[inline]
+pub unsafe fn w_pairwise_get_iterator(obj: PyObjectRef) -> PyObjectRef {
+    unsafe { (*(obj as *const W_Pairwise)).w_iterator }
+}
+
+/// Read the previous item (`PY_NULL` before the first result).
+///
+/// # Safety
+/// `obj` must point to a valid `W_Pairwise`.
+#[inline]
+pub unsafe fn w_pairwise_get_prev(obj: PyObjectRef) -> PyObjectRef {
+    unsafe { (*(obj as *const W_Pairwise)).w_prev }
+}
+
+/// Store the previous item. `W_Pairwise` is allocated in old-gen, while an
+/// iterator may return a nursery object, so this is an old-to-young store.
+///
+/// # Safety
+/// `obj` must point to a valid `W_Pairwise`.
+#[inline]
+pub unsafe fn w_pairwise_set_prev(obj: PyObjectRef, w_prev: PyObjectRef) {
+    unsafe {
+        (*(obj as *mut W_Pairwise)).w_prev = w_prev;
+        crate::gc_hook::try_gc_write_barrier(obj as *mut u8);
+    }
+}
+
 // ── W_Cycle — pypy/module/itertools/interp_itertools.py:class W_Cycle ──
 //
 // ```python
@@ -1523,8 +1554,15 @@ mod tests {
     }
 
     #[test]
-    fn w_pairwise_object_size_matches_descr() {
-        // Auto-id `allocate_stable` (GC-managed): tid assigned at JIT init.
+    fn w_pairwise_gc_descriptor_traces_iterator_and_previous_item() {
+        assert_eq!(
+            W_PAIRWISE_GC_PTR_OFFSETS,
+            [
+                std::mem::offset_of!(W_Pairwise, ob.w_class),
+                std::mem::offset_of!(W_Pairwise, w_iterator),
+                std::mem::offset_of!(W_Pairwise, w_prev),
+            ]
+        );
         assert_eq!(
             <W_Pairwise as crate::lltype::GcType>::SIZE,
             W_PAIRWISE_OBJECT_SIZE

From b1d1f4cbb833218244d5ded0e97c7591e7fd66a5 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 11:12:33 +0900
Subject: [PATCH 7/8] bench: record the win32 runner jitstats overlays
 windows-latest reports
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`pyre/check.py (windows-latest)` fails 18 rows across 10 fixtures — 9 on each
native backend — where ubuntu-24.04 and macos-latest both pass. Every failing
row is a jit-stats difference; no output snapshot mismatches, so the fixtures
still compute the same results there.

Values transcribed from the windows job of run 31724482401 (main
b0f34c0af3e). Transcription is exact rather than sampled: check.py states that
"the recorded surface and the gated surface are the same set", so a FAIL line
enumerates every counter that differs and each unnamed counter equals the
shared baseline. Each file was cross-checked against the `(observed
loops_compiled=N bridges_compiled=M)` parenthetical the same line prints.

The three runners were read back before adding these, as the overlay comment
requires: at that sha ubuntu reports these rows green (its own failures are
cranelift/str_fstring and wasm/exception_traceback_loop_forms) and macos-latest
is `success` for the whole job.

The divergence appeared with the #1189 squash, but the branch alone does not
produce it: that PR's own last windows run, at head 22ac8c9145b, failed only
str_fstring on both backends. Its CI merged into d953ddc7543, while the squash
landed on that plus #1184, #1196 and #1174; main at df365f91fb4 carries those
three without the branch and also lacks these rows. So it is an interaction
between the two sides, and which pair is responsible is not established here.

One caveat for whoever maintains these: inline_chain_depth_typeflip's windows
observation already moved once, 3843 -> 3798, between the squash and
b0f34c0af3e. The other eight fixtures reported identical numbers across both
runs.

Assisted-by: Claude
---
 ...frames.cranelift.win32.github-actions.jitstats | 14 ++++++++++++++
 ...tb_frames.dynasm.win32.github-actions.jitstats | 14 ++++++++++++++
 ..._chain.cranelift.win32.github-actions.jitstats | 14 ++++++++++++++
 ...eno_chain.dynasm.win32.github-actions.jitstats | 14 ++++++++++++++
 ...peflip.cranelift.win32.github-actions.jitstats | 14 ++++++++++++++
 ..._typeflip.dynasm.win32.github-actions.jitstats | 14 ++++++++++++++
 ...yforce.cranelift.win32.github-actions.jitstats | 15 +++++++++++++++
 ...erator.cranelift.win32.github-actions.jitstats | 14 ++++++++++++++
 ..._iterator.dynasm.win32.github-actions.jitstats | 14 ++++++++++++++
 ...urface.cranelift.win32.github-actions.jitstats | 15 +++++++++++++++
 ...e_surface.dynasm.win32.github-actions.jitstats | 15 +++++++++++++++
 ...ethods.cranelift.win32.github-actions.jitstats | 14 ++++++++++++++
 ...n_methods.dynasm.win32.github-actions.jitstats | 14 ++++++++++++++
 ...sm_min.cranelift.win32.github-actions.jitstats | 14 ++++++++++++++
 ..._wasm_min.dynasm.win32.github-actions.jitstats | 14 ++++++++++++++
 ...r_fstring.dynasm.win32.github-actions.jitstats | 15 +++++++++++++++
 ..._deopt.cranelift.win32.github-actions.jitstats | 14 ++++++++++++++
 ...nch_deopt.dynasm.win32.github-actions.jitstats | 14 ++++++++++++++
 18 files changed, 256 insertions(+)
 create mode 100644 pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats
 create mode 100644 pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats

diff --git a/pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..0153d21cf0f
--- /dev/null
+++ b/pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=603
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
diff --git a/pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..0153d21cf0f
--- /dev/null
+++ b/pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=603
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
diff --git a/pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..c9c196fe612
--- /dev/null
+++ b/pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=605
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=6
diff --git a/pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..c9c196fe612
--- /dev/null
+++ b/pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=605
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=6
diff --git a/pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..66f9d99b679
--- /dev/null
+++ b/pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=18
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=3798
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
diff --git a/pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..66f9d99b679
--- /dev/null
+++ b/pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=18
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=3798
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
diff --git a/pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..c9a022cc184
--- /dev/null
+++ b/pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,15 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=931
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
+retraces_compiled=0
diff --git a/pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..588d46fc191
--- /dev/null
+++ b/pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=2
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=409
+internal_compile_panics=0
+loops_aborted=1
+loops_compiled=3
diff --git a/pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..588d46fc191
--- /dev/null
+++ b/pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=2
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=409
+internal_compile_panics=0
+loops_aborted=1
+loops_compiled=3
diff --git a/pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..6af6687600c
--- /dev/null
+++ b/pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,15 @@
+bridges_compiled=3
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=601
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
+retraces_compiled=0
diff --git a/pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..6af6687600c
--- /dev/null
+++ b/pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,15 @@
+bridges_compiled=3
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=601
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
+retraces_compiled=0
diff --git a/pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..19f8267fba5
--- /dev/null
+++ b/pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=812
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
diff --git a/pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..19f8267fba5
--- /dev/null
+++ b/pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=812
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=7
diff --git a/pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..845b678880d
--- /dev/null
+++ b/pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=3
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=603
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=5
diff --git a/pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..845b678880d
--- /dev/null
+++ b/pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=3
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=603
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=5
diff --git a/pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..e45d14ff4ca
--- /dev/null
+++ b/pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,15 @@
+bridges_compiled=3
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=659
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=6
+retraces_compiled=0
diff --git a/pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats
new file mode 100644
index 00000000000..4ffd74bc61b
--- /dev/null
+++ b/pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=1
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=201
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=3
diff --git a/pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats
new file mode 100644
index 00000000000..4ffd74bc61b
--- /dev/null
+++ b/pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats
@@ -0,0 +1,14 @@
+bridges_compiled=1
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=201
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=3

From e03f82f31478848685690e2d99967f126e110f29 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 14 Aug 2026 13:42:18 +0900
Subject: [PATCH 8/8] Revert "bench: record the win32 runner jitstats overlays
 windows-latest reports"

An overlay records what a runner observes; it does not change what the runner
observes. The 18 files pinned the windows-latest numbers for those rows so the
gate would stop reporting them, leaving the divergence itself in place.

The pre-existing `str_fstring.cranelift.win32.github-actions.jitstats` is not
part of this and stays.

`pyre/check.py (windows-latest)` therefore still reports the 18 rows.

Assisted-by: Claude
---
 ...frames.cranelift.win32.github-actions.jitstats | 14 --------------
 ...tb_frames.dynasm.win32.github-actions.jitstats | 14 --------------
 ..._chain.cranelift.win32.github-actions.jitstats | 14 --------------
 ...eno_chain.dynasm.win32.github-actions.jitstats | 14 --------------
 ...peflip.cranelift.win32.github-actions.jitstats | 14 --------------
 ..._typeflip.dynasm.win32.github-actions.jitstats | 14 --------------
 ...yforce.cranelift.win32.github-actions.jitstats | 15 ---------------
 ...erator.cranelift.win32.github-actions.jitstats | 14 --------------
 ..._iterator.dynasm.win32.github-actions.jitstats | 14 --------------
 ...urface.cranelift.win32.github-actions.jitstats | 15 ---------------
 ...e_surface.dynasm.win32.github-actions.jitstats | 15 ---------------
 ...ethods.cranelift.win32.github-actions.jitstats | 14 --------------
 ...n_methods.dynasm.win32.github-actions.jitstats | 14 --------------
 ...sm_min.cranelift.win32.github-actions.jitstats | 14 --------------
 ..._wasm_min.dynasm.win32.github-actions.jitstats | 14 --------------
 ...r_fstring.dynasm.win32.github-actions.jitstats | 15 ---------------
 ..._deopt.cranelift.win32.github-actions.jitstats | 14 --------------
 ...nch_deopt.dynasm.win32.github-actions.jitstats | 14 --------------
 18 files changed, 256 deletions(-)
 delete mode 100644 pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats
 delete mode 100644 pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats

diff --git a/pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index 0153d21cf0f..00000000000
--- a/pyre/bench/synth/exception_inline_callee_tb_frames.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=4
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=603
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
diff --git a/pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index 0153d21cf0f..00000000000
--- a/pyre/bench/synth/exception_inline_callee_tb_frames.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=4
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=603
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
diff --git a/pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index c9c196fe612..00000000000
--- a/pyre/bench/synth/exception_traceback_lineno_chain.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=4
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=605
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=6
diff --git a/pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index c9c196fe612..00000000000
--- a/pyre/bench/synth/exception_traceback_lineno_chain.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=4
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=605
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=6
diff --git a/pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index 66f9d99b679..00000000000
--- a/pyre/bench/synth/inline_chain_depth_typeflip.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=18
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=3798
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
diff --git a/pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index 66f9d99b679..00000000000
--- a/pyre/bench/synth/inline_chain_depth_typeflip.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=18
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=3798
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
diff --git a/pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index c9a022cc184..00000000000
--- a/pyre/bench/synth/inline_freevar_after_mayforce.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,15 +0,0 @@
-bridges_compiled=4
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=931
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
-retraces_compiled=0
diff --git a/pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index 588d46fc191..00000000000
--- a/pyre/bench/synth/inline_subwalk_user_iterator.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=2
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=409
-internal_compile_panics=0
-loops_aborted=1
-loops_compiled=3
diff --git a/pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index 588d46fc191..00000000000
--- a/pyre/bench/synth/inline_subwalk_user_iterator.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=2
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=409
-internal_compile_panics=0
-loops_aborted=1
-loops_compiled=3
diff --git a/pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index 6af6687600c..00000000000
--- a/pyre/bench/synth/pypy_type_surface.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,15 +0,0 @@
-bridges_compiled=3
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=601
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
-retraces_compiled=0
diff --git a/pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index 6af6687600c..00000000000
--- a/pyre/bench/synth/pypy_type_surface.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,15 +0,0 @@
-bridges_compiled=3
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=601
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
-retraces_compiled=0
diff --git a/pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index 19f8267fba5..00000000000
--- a/pyre/bench/synth/sre_pattern_methods.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=4
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=812
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
diff --git a/pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index 19f8267fba5..00000000000
--- a/pyre/bench/synth/sre_pattern_methods.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=4
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=812
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=7
diff --git a/pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index 845b678880d..00000000000
--- a/pyre/bench/synth/sre_wasm_min.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=3
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=603
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=5
diff --git a/pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index 845b678880d..00000000000
--- a/pyre/bench/synth/sre_wasm_min.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=3
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=603
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=5
diff --git a/pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index e45d14ff4ca..00000000000
--- a/pyre/bench/synth/str_fstring.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,15 +0,0 @@
-bridges_compiled=3
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=659
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=6
-retraces_compiled=0
diff --git a/pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats b/pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats
deleted file mode 100644
index 4ffd74bc61b..00000000000
--- a/pyre/bench/synth/type_call_inline_init_branch_deopt.cranelift.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=1
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=201
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=3
diff --git a/pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats b/pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats
deleted file mode 100644
index 4ffd74bc61b..00000000000
--- a/pyre/bench/synth/type_call_inline_init_branch_deopt.dynasm.win32.github-actions.jitstats
+++ /dev/null
@@ -1,14 +0,0 @@
-bridges_compiled=1
-descr_set_absent=0
-descr_set_ambiguous=0
-descr_set_stale_absent=0
-fbw_blackhole_adopted_multi_frame=0
-fbw_blackhole_adopted_single_frame=0
-fbw_rolled_back_with_effects=0
-fbw_store_journal_rollback_failed=0
-field_pos_attached_misplaced=0
-field_pos_spec_misplaced=0
-guard_failures=201
-internal_compile_panics=0
-loops_aborted=0
-loops_compiled=3