majit: stop inheriting a previous compile's target tokens

majit/majit-backend-cranelift/src/compiler.rs

@@ -4364,7 +4364,7 @@ thread_local! {
 }
 
 fn opref_is_op_result_var(opref: OpRef) -> bool {
-    // history.py:213 `Const.is_constant()` returns True; inline-Const
+    // history.py:220 `Const.is_constant()` returns True; inline-Const
     // variants are constants, never op results — short-circuit before
     // `.raw()` (which panics on inline variants).
     if opref.inline_const_bits().is_some() {
@@ -4706,7 +4706,7 @@ fn validate_oprefs_for_compile(
         }
         if op_dereferences_first_arg(op.opcode) {
             let arg = op.arg(0);
-            // history.py:213 `Const.is_constant()` — Const operands are
+            // history.py:220 `Const.is_constant()` — Const operands are
             // always "bound" by the value carried inline.
             let bound = arg.is_none()
                 || arg.is_constant()

majit/majit-backend-dynasm/src/regalloc.rs

@@ -3683,7 +3683,7 @@ impl<'a> RegAlloc<'a> {
         ) {
             return false;
         }
-        // history.py:213 `Const.is_constant()` — Const operands are not
+        // history.py:220 `Const.is_constant()` — Const operands are not
         // op-result identities; comparison via raw position is invalid.
         if next_op.num_args() == 0
             || next_op.arg(0).is_constant()

majit/majit-backend-dynasm/src/runner.rs

@@ -50,7 +50,7 @@ struct DynasmCaTarget {
     /// `model.py:292-338` `CompiledLoopToken` — Arc-shared with the
     /// owning `JitCellToken` once the real target registers.
     compiled_loop_token: Arc<majit_backend::CompiledLoopToken>,
-    /// `pyjitpl.py:3605` `outermost_jitdriver_sd.index_of_virtualizable`.
+    /// `pyjitpl.py:3629` `outermost_jitdriver_sd.index_of_virtualizable`.
     /// Captured from `JitCellToken.virtualizable_arg_index` when the compiled
     /// target registers.
     index_of_virtualizable: i32,

majit/majit-backend-wasm/src/codegen.rs

@@ -6425,7 +6425,7 @@ fn next_op_can_accept_cc<'a>(
     if !matches!(next_op.opcode, OpCode::GuardTrue | OpCode::GuardFalse) {
         return None;
     }
-    // history.py:213 `Const.is_constant()` — a Const operand is not an
+    // history.py:220 `Const.is_constant()` — a Const operand is not an
     // op-result identity, so comparing raw positions against it is invalid.
     if next_op.num_args() == 0 || next_op.arg(0).is_constant() {
         return None;

majit/majit-backend/src/lib.rs

@@ -1183,12 +1183,12 @@ pub struct JitCellToken {
     bridge_invalidation_flags: parking_lot::Mutex<Vec<Arc<AtomicBool>>>,
     /// Alternative loop versions to compile immediately after the main loop.
     pub version_info: Option<LoopVersionInfo>,
-    /// history.py:449: _keepalive_jitcell_tokens — set of other tokens
+    /// history.py:455: _keepalive_jitcell_tokens — set of other tokens
     /// that this loop can jump to (via CALL_ASSEMBLER or JUMP).
     /// Upstream prevents the target from being evicted while this loop
     /// is alive by holding the actual `JitCellToken` object reference
-    /// (`history.py:441 _keepalive_jitcell_tokens = {}` keyed on the
-    /// token object itself, with `:451 record_jump_to` writing
+    /// (`history.py:455 _keepalive_jitcell_tokens = {}` keyed on the
+    /// token object itself, with `:457 record_jump_to` writing
     /// `self._keepalive_jitcell_tokens[target] = None`).  Pyre keeps the
     /// same shape: an `Arc<JitCellToken>` set keyed on token number.
     ///
@@ -1248,7 +1248,7 @@ pub struct JitCellToken {
     /// covered by the existing `unsafe impl Sync for JitCellToken`
     /// at line 1130 — single-threaded JIT scheduler invariant.
     pub generation: Cell<i64>,
-    /// `history.py:431-435 JitCellToken.retraced_count` parity slot.
+    /// `history.py:442 JitCellToken.retraced_count` parity slot.
     ///
     /// RPython packs two pieces of state into this u-int:
     ///   * bit 0 = `FORCE_BRIDGE_SEGMENTING` flag.
@@ -1291,18 +1291,25 @@ pub struct JitCellToken {
     /// use the accessors (not `.get()` / `.set()` directly) to keep
     /// the bit-packing invariant.
     pub retraced_count: Cell<u32>,
-    /// `history.py:433` `JitCellToken.target_tokens = None` (lazily
-    /// populated to a `list[TargetToken]` in `compile.py:286-296` /
-    /// `:312-323` once the loop is compiled).  `pyjitpl.py:3898`
+    /// `history.py:440` `JitCellToken.target_tokens = None`, the class
+    /// default, assigned a `list[TargetToken]` at exactly two sites:
+    /// `compile.py:245` in `compile_simple_loop` and `:290` in
+    /// `compile_loop`.  Those are the only writers, so a token minted
+    /// anywhere else — `compile_retrace`'s no-resumekey arm mints at
+    /// `:1013` — keeps the `None` default.  `pyjitpl.py:3922-3923`
     /// `has_compiled_targets(token)` reads this list — `bool(token)
     /// and bool(token.target_tokens)`.
     ///
     /// Pyre stores the descr-side projection of TargetToken
     /// (`LoopTargetDescr` Arc; `TargetToken IS-A AbstractDescr` in
     /// PyPy, so a `DescrRef` is the matching identity).  Each
     /// successful loop / retrace populates this through
-    /// `record_target_token` so `has_compiled_loop` reads the same
-    /// signal PyPy's `has_compiled_targets` does.  The metainterp-side
+    /// `record_target_token`.  Its one reader is
+    /// [`Self::first_target_token`], the descr a bridge closes onto:
+    /// neither `has_compiled_loop` (token presence) nor pyre's
+    /// `has_compiled_targets` (the `compiled_loops` side table) reads
+    /// this list, so it is not pyre's `has_compiled_targets` signal
+    /// despite mirroring what upstream's reads.  The metainterp-side
     /// `TargetToken` value (with `virtual_state` / `short_preamble`)
     /// stays on the `CompiledEntry::front_target_tokens` list per
     /// the F.6 retirement plan — the per-target descr identity is the
@@ -1311,7 +1318,7 @@ pub struct JitCellToken {
 }
 
 impl JitCellToken {
-    /// `history.py:431` `FORCE_BRIDGE_SEGMENTING = 1` — bit packed
+    /// `history.py:438` `FORCE_BRIDGE_SEGMENTING = 1` — bit packed
     /// into `retraced_count`.  Set at `pyjitpl.py:2833` (pyre:
     /// `MetaInterp::blackhole_trace_too_long_slow`) when a bridge
     /// trace aborts without an inlinable function; read at
@@ -1357,9 +1364,9 @@ impl JitCellToken {
             _ll_function_addr: AtomicUsize::new(0),
             // memmgr.py:38 default; first keep_loop_alive overwrites this.
             generation: Cell::new(0),
-            // history.py:435 `retraced_count = 0` (class attribute default).
+            // history.py:442 `retraced_count = 0` (class attribute default).
             retraced_count: Cell::new(0),
-            // history.py:433 `target_tokens = None` — pyre uses the
+            // history.py:440 `target_tokens = None` — pyre uses the
             // empty-Vec equivalent so `has_target_tokens` is one
             // `is_empty()` check away.
             target_tokens: parking_lot::Mutex::new(Vec::new()),
@@ -1544,31 +1551,42 @@ impl JitCellToken {
         self.bridge_invalidation_flags.lock().last().cloned()
     }
 
-    /// `pyjitpl.py:3898` `has_compiled_targets(token)` —
+    /// `pyjitpl.py:3922-3923` `has_compiled_targets(token)` —
     /// `bool(token) and bool(token.target_tokens)`.  PyPy reads
-    /// `token.target_tokens` (a `list[TargetToken]` populated at
-    /// `compile.py:286-296`) and treats a non-empty list as the signal
-    /// that the loop has been compiled.
+    /// `token.target_tokens` (a `list[TargetToken]` assigned at
+    /// `compile.py:245` / `:290`) and treats a non-empty list as the
+    /// signal that the loop has been compiled.
     #[inline]
     pub fn has_target_tokens(&self) -> bool {
         !self.target_tokens.lock().is_empty()
     }
 
     /// The head of `token.target_tokens` — the descr `compile.py:290`
-    /// seeds the list with, and the one `pyjitpl.py:3007` closes a bridge
-    /// onto once `has_compiled_targets` has admitted the token.  Reading it
-    /// from the token rather than from a side table keeps the target and the
-    /// gate that admitted it the same object, which is what makes the
-    /// `warmstate.py:191-196` invalidation filter cover both.
+    /// seeds the list with.  Reading it from the token rather than from a
+    /// side table keeps the target and the gate that admitted it the same
+    /// object, which is what makes the `warmstate.py:191-196` invalidation
+    /// filter cover both.
+    ///
+    /// Upstream resolves the close target later and differently:
+    /// `pyjitpl.py:3007` hands `compile_trace` the JitCellToken itself, the
+    /// JUMP carries that token as its descr, and `unroll.py:320-340` picks
+    /// among `target_tokens` by matching each one's `virtual_state`,
+    /// skipping `VirtualStatesCantMatch`.  Taking the head here is
+    /// unconditional, so a list longer than one is a list of one for
+    /// close-target purposes.
     #[inline]
     pub fn first_target_token(&self) -> Option<majit_ir::DescrRef> {
         self.target_tokens.lock().first().cloned()
     }
 
-    /// `compile.py:286-296` / `:312-323` — append a freshly minted
-    /// TargetToken's descr to `token.target_tokens`.  Idempotent on
-    /// `Arc::ptr_eq` so retrace paths that reuse `prior_front_target_tokens`
-    /// across `compile_loop` and `compile_retrace` do not duplicate.
+    /// Append a freshly minted TargetToken's descr to
+    /// `token.target_tokens`.  Idempotent on `Arc::ptr_eq` so retrace
+    /// paths that reuse `prior_front_target_tokens` do not duplicate.
+    ///
+    /// This has no single upstream counterpart: `compile.py:245` /
+    /// `:290` assign the list outright, and both are in
+    /// `compile_simple_loop` / `compile_loop`, so neither describes
+    /// what happens on the retrace path this method also serves.
     pub fn record_target_token(&self, descr: majit_ir::DescrRef) {
         let mut guard = self.target_tokens.lock();
         if !guard.iter().any(|existing| Arc::ptr_eq(existing, &descr)) {

majit/majit-backend/src/resume_guard_descr.rs

@@ -550,7 +550,7 @@ impl FailDescr for ResumeGuardDescr {
         self.external_jump_target.get().is_some()
     }
 
-    /// `history.py:470` `TargetToken._ll_loop_code` parity: when this
+    /// `history.py:478` `TargetToken._ll_loop_code` parity: when this
     /// descr is the synthesised cross-loop JUMP exit, surface the target
     /// `DescrRef` the dispatcher re-enters via.  `None` for regular
     /// guard descrs.

majit/majit-ir/src/descr.rs

@@ -3108,7 +3108,7 @@ struct BasicLoopTargetDescrState {
 struct BasicLoopTargetDescr {
     token_id: u64,
     is_preamble_target: bool,
-    /// `history.py:470` `TargetToken._ll_loop_code` parity: a single
+    /// `history.py:478` `TargetToken._ll_loop_code` parity: a single
     /// integer recording the address of the loop's compiled entry
     /// point.  RPython sets this with a plain `setattr` (atomic w.r.t.
     /// the GIL); pyre uses `AtomicUsize` so cranelift-emitted in-code
@@ -3406,7 +3406,7 @@ pub trait Descr: Send + Sync + std::fmt::Debug {
         false
     }
 
-    /// compile.py:919-920: `invent_fail_descr_for_op` mints
+    /// compile.py:924-927: `invent_fail_descr_for_op` mints
     /// `ResumeGuardForcedDescr` for `GUARD_NOT_FORCED` /
     /// `GUARD_NOT_FORCED_2`.  Allows descr-level dispatch in places
     /// that today switch on opcode (e.g. `handle_fail` for forced

majit/majit-ir/src/resoperation.rs

@@ -252,7 +252,7 @@ impl OpRef {
     }
 
     /// resoperation.py:47 `AbstractValue.is_constant()` returns False;
-    /// history.py:213 `Const.is_constant()` returns True. The
+    /// history.py:220 `Const.is_constant()` returns True. The
     /// dispatch is class-based — typed body variants
     /// (`IntOp/RefOp/FloatOp/VoidOp/InputArg*`) correspond to
     /// `AbstractValue` subclasses and are NOT constants.

majit/majit-metainterp/src/blackhole.rs

@@ -5393,27 +5393,27 @@ fn bhimpl_int_ne(a: i64, b: i64) -> i64 {
     (a != b) as i64
 }
 
-/// blackhole.py:551 `bhimpl_int_gt(a, b): return int(a > b)`.
+/// blackhole.py:548 `bhimpl_int_gt(a, b): return int(a > b)`.
 fn bhimpl_int_gt(a: i64, b: i64) -> i64 {
     (a > b) as i64
 }
 
-/// blackhole.py:555 `bhimpl_int_ge(a, b): return int(a >= b)`.
+/// blackhole.py:551 `bhimpl_int_ge(a, b): return int(a >= b)`.
 fn bhimpl_int_ge(a: i64, b: i64) -> i64 {
     (a >= b) as i64
 }
 
-/// blackhole.py:559 `bhimpl_int_is_true(a): return int(bool(a))`.
+/// blackhole.py:557 `bhimpl_int_is_true(a): return int(bool(a))`.
 fn bhimpl_int_is_true(a: i64) -> i64 {
     (a != 0) as i64
 }
 
-/// blackhole.py:563 `bhimpl_int_is_zero(a): return int(not a)`.
+/// blackhole.py:554 `bhimpl_int_is_zero(a): return int(not a)`.
 fn bhimpl_int_is_zero(a: i64) -> i64 {
     (a == 0) as i64
 }
 
-/// blackhole.py:567 `bhimpl_int_force_ge_zero(a): if a < 0: return 0; return a`.
+/// blackhole.py:563 `bhimpl_int_force_ge_zero(a): if a < 0: return 0; return a`.
 fn bhimpl_int_force_ge_zero(a: i64) -> i64 {
     if a < 0 { 0 } else { a }
 }
@@ -9688,7 +9688,7 @@ fn handler_copystrcontent(
     }
     Ok(p + 5)
 }
-/// RPython `blackhole.py:1580-1583` `bhimpl_copyunicodecontent`.
+/// RPython `blackhole.py:1593-1595` `bhimpl_copyunicodecontent`.
 fn handler_copyunicodecontent(
     bh: &mut BlackholeInterpreter,
     code: &[u8],

majit/majit-metainterp/src/compile.rs

@@ -4423,7 +4423,7 @@ impl FailDescr for ResumeGuardCopiedDescr {
              copied descrs share their donor's type vector via prev"
         );
     }
-    /// history.py:143 `AbstractFailDescr.attach_vector_info`: writes
+    /// history.py:150 `AbstractFailDescr.attach_vector_info`: writes
     /// `self.rd_vector_info`, never `self.prev`.  `prev` is for resume
     /// storage only (compile.py:849 `get_resumestorage`); vector info
     /// lives on the copied descr itself.

majit/majit-metainterp/src/history.rs

@@ -53,10 +53,6 @@ pub struct TargetToken {
     pub virtual_state: Option<crate::optimizeopt::virtualstate::VirtualState>,
     /// Short preamble: ops to replay when entering from a bridge.
     pub short_preamble: Option<crate::optimizeopt::shortpreamble::ShortPreamble>,
-    /// RPython unroll.py: active ExtendedShortPreambleBuilder for the target
-    /// token currently being finalized.
-    pub short_preamble_producer:
-        Option<crate::optimizeopt::shortpreamble::ExtendedShortPreambleBuilder>,
     jump_target_descr: Arc<LoopTargetDescr>,
 }
 
@@ -73,7 +69,6 @@ impl TargetToken {
             is_preamble_target: false,
             virtual_state: None,
             short_preamble: None,
-            short_preamble_producer: None,
             jump_target_descr: Arc::new(LoopTargetDescr::new(0, false)),
         }
     }
@@ -122,7 +117,7 @@ struct LoopTargetDescrState {
 struct LoopTargetDescr {
     token_id: u64,
     is_preamble_target: bool,
-    /// `history.py:470` `TargetToken._ll_loop_code` parity (PyPy stores
+    /// `history.py:478` `TargetToken._ll_loop_code` parity (PyPy stores
     /// a plain integer GIL-atomic; pyre uses `AtomicUsize` so the
     /// cranelift backend's in-code `closing_jump` dispatch can read
     /// the slot via a baked address without taking a Mutex).

majit/majit-metainterp/src/jitcode/assembler.rs

@@ -6077,7 +6077,7 @@ impl JitCodeBuilder {
     }
 }
 
-/// pyjitpl.py:3675 `effectinfo.call_release_gil_target` parity.
+/// pyjitpl.py:3699 `effectinfo.call_release_gil_target` parity.
 ///
 /// PyPy populates `(realfuncaddr, saveerr)` at descr creation time:
 /// `codewriter/call.py:252-258` reads `_call_aroundstate_target_` off

majit/majit-metainterp/src/optimizeopt/mod.rs

@@ -755,7 +755,7 @@ pub struct OptContext {
     /// info.py:788-790 `ConstPtrInfo._unpack_str(mode)` — runtime hook for
     /// extracting character data from a constant string GcRef.
     pub string_content_resolver: Option<StringContentResolver>,
-    /// history.py:377 `get_const_ptr_for_string(s)` — runtime hook for
+    /// history.py:384 `get_const_ptr_for_string(s)` — runtime hook for
     /// creating a constant string GcRef from char values (used by
     /// force_box constant-folding path, vstring.py:79-90).
     pub string_constant_alloc: Option<StringConstantAllocator>,

majit/majit-metainterp/src/optimizeopt/optimizer.rs

@@ -399,6 +399,15 @@ pub struct Optimizer {
     /// producer for the target token currently being compiled.
     pub imported_short_preamble_builder:
         Option<crate::optimizeopt::shortpreamble::ShortPreambleBuilder>,
+    /// RPython `unroll.py:298` `self.short_preamble_producer = ...`.
+    ///
+    /// `imported_short_preamble_builder` above ports `unroll.py:507`.
+    /// Upstream stage-switches one slot in time, overwriting the imported
+    /// plain builder with this extended builder. Pyre keeps both stages live
+    /// as distinct Rust types; relocating this field to `Optimizer` changes
+    /// the extended builder's home without merging those stages.
+    pub short_preamble_producer:
+        Option<crate::optimizeopt::shortpreamble::ExtendedShortPreambleBuilder>,
     /// RPython unroll.py: `label_args = import_state(...)`.
     /// The peeled loop's LABEL must use these args, not the phase-1 end_args.
     pub imported_label_args: Option<Vec<OpRef>>,
@@ -1480,6 +1489,7 @@ impl Optimizer {
             imported_short_aliases: Vec::new(),
             imported_short_preamble: None,
             imported_short_preamble_builder: None,
+            short_preamble_producer: None,
             imported_label_args: None,
             patchguardop: None,
             skip_flush: false,

majit/majit-metainterp/src/optimizeopt/pure.rs

@@ -2376,7 +2376,7 @@ mod tests {
     }
 
     /// pure.py:62 / :72-74 same_box semantics for constant args.
-    /// history.py:204-205 / :244 — `same_box(a, b) == same_constant(a, b)`
+    /// history.py:211-212 / :251 — `same_box(a, b) == same_constant(a, b)`
     /// for Const subclasses, so cache hits are value-equality. With
     /// inline `ConstInt.value`, two `make_constant_int(5)` calls return
     /// the same `OpRef::ConstInt(5)` and the cache hit is by

majit/majit-metainterp/src/optimizeopt/rewrite.rs

@@ -397,13 +397,13 @@ impl OptRewrite {
     // ── Unary operations ──
 
     /// Constant fold INT_IS_ZERO.
-    /// rewrite.py:512-513 `optimize_INT_IS_ZERO`:
+    /// rewrite.py:522-523 `optimize_INT_IS_ZERO`:
     ///     return self._optimize_nullness(op, op.getarg(0), False)
     fn optimize_int_is_zero(&self, op: &Op, ctx: &mut OptContext) -> OptimizationResult {
         self.optimize_nullness(op, op.arg(0).to_opref(), false, ctx)
     }
 
-    /// rewrite.py:505-510 `optimize_INT_IS_TRUE`:
+    /// rewrite.py:515-520 `optimize_INT_IS_TRUE`:
     ///     if (not self.is_raw_ptr(op.getarg(0)) and
     ///         self.getintbound(op.getarg(0)).is_bool()):
     ///         self.make_equal_to(op, op.getarg(0))