Align flatten_graph (#44) * flatten: port cpu/rtyper/exceptiondata shim + _ovf canraise rewrite - Add `exceptiondata.rs` with `Rtyper { exceptiondata: ExceptionData }` shim mirroring `rpython/rtyper/exceptiondata.py:11-45` and `rpython/rtyper/rtyper.py:71`. `ExceptionData::get_standard_ll_exc_ instance_by_class(\"OverflowError\")` returns a `Constant::opaque` the production `lower_constant` closure resolves at flatten time. - Extend `jit::cpu::Cpu` with `rtyper: Rtyper`, matching upstream `LLGraphCPU.rtyper.exceptiondata` access path that `flatten.py:166-170` consumes. - Thread `cpu: Option<&'a Cpu>` through `GraphFlattener` + `flatten_graph_with_lowering`; probe call site at `codewriter.rs:7694` now passes `Some(self.cpu())`. - Port `flatten.py:189-204` `_ovf` canraise rewrite as `GraphFlattener::flatten_ovf_canraise`: pop the just-emitted op, emit `_jump_if_ovf [-> res]`, walk normal exit, emit `Label(exits[1])`, walk the OverflowError edge with `handling_ovf=true`, optionally walk the `Exception` catch-all (`exits[2]`). - Port `make_exception_link` `handling_ovf=true` arm (`flatten.py:165-170`): emit `raise ` via `cpu.rtyper.exceptiondata.get_standard_ll_exc_instance_by_class`. - Port `flatten.py:120-125` `make_bytecode_block` `_ovf` validity check (block must be canraise with 2 or 3 exits when any op opname contains `_ovf`). - Accept `Bool` `llexitcase` in `switch_llexitcase_key` per `flatten.py:296` `cast_primitive(Signed, ...)` semantics. - Add tests covering the `_ovf` 2-/3-exit rewrite, the `int_add/sub/mul_jump_if_ovf` 7-char prefix transform, and the `make_bytecode_block` `_ovf` validity panic. * flatten/codewriter: classify abort_permanent + pair retired-family HLOps in [phase4-graph-shape] - Add `abort_permanent` to `is_ssa_only_artifact`. Pyre's walker emits `BC_ABORT_PERMANENT` (codewriter.rs:3391 `emit_abort_permanent!`) with no graph counterpart; upstream RPython sidesteps the equivalent via `metainterp/policy.py`-driven whitelisting and has no SSA opname or `SpaceOperation` shape for it. - Pair the 4 retired-family HLOps with their post-rtype `residual_call_*` inline counterparts inside the `[phase4-graph-shape]` probe. Graph- side `add/sub/.../inplace_*`/`getitem`, `lt/le/eq/ne/gt/ge`, `bool`, `setitem` are classified as `is_graph_only_artifact`; inline-side `residual_call_ir_r(binary_op_fn)`, `residual_call_ir_r(compare_fn)`, `residual_call_r_i(truth_fn)`, `residual_call_r_v(store_subscr_fn)` were left as `inline-only` until now. The pairing decrements the inline shape count by `min(graph_hlop_count, residual_call_count)` per family so each logical operation is counted once. Mirrors the flatten-time rewrite that `flatten::try_flatten_retired_family_hlop_to_insn` performs in `flatten_graph_with_lowering`. * flatten/codewriter: byte-equivalent probe + graceful walker non-orthodoxy - Add `insn_byte_equal` (codewriter.rs) comparing two `Insn` values including register indices and constant literal values, with pointer-identity comparison on `Operand::Descr` / `IndirectCallTargets`. - Extend `[phase4-flatten-graph]` probe to log `byte_equivalent` alongside `sequence_match`. When shapes match but bytes diverge, log the first position's full `driver=`/`inline=` Insn so the regalloc reconciliation work has a concrete target. - Relax `make_bytecode_block` empty-exits assertion to emit an `unreachable` terminator for orphan join-points (pyre walker non-orthodoxy: blocks with empty exits and `inputargs.len() != 1|2` outside `returnblock` / `exceptblock`). The orthodox 1/2-arg case still flows through `make_return`. - Relax `make_link` `target_is_final` shortcut to require exactly 1 or 2 collected args (`target_is_orthodox_final`); orphan-final targets fall through to `insert_renamings` + recursive `make_bytecode_block`. - Relax `switch_llexitcase_key` to hash unsupported `llexitcase` shapes to `0` (walker non-orthodoxy: pyre synthesises switch links without setting `llexitcase`). - Net effect on the `[phase4-flatten-graph]` probe: `panic=false` across the production CodeWriter walker; surfaced byte-divergence is now an actionable signal for Phase 3 regalloc reconciliation rather than a crashing precondition. * flatten/codewriter: Variable→register reconciliation map for retired families - Add `variable_reg_map: HashMap` in `transform_graph_to_jitcode` and populate at the four HLOp-lowered family emit sites (`BinaryOp`, `CompareOp`, `PopJumpIfFalse`, `PopJumpIfTrue`, `StoreSubscr`) plus the three passthrough family sites (`LoadSmallInt`, `LoadGlobal`, `LoadConst`). Each Variable the walker produces or consumes through these sites is mapped to the SSA-register slot the inline emit wrote it into. - Probe `driver_get_register` (codewriter.rs:7929) consults the map before falling back to graph regalloc, so `flatten_graph_with_lowering`'s lowered `Insn` carries the same Register indices the inline byte stream wrote — closing the `byte_equivalent` gap surfaced by the Phase 3.1 probe. - Add `descr_operand_byte_equal` so two `Operand::Descr`s that share the same logical `CallDescrStub` content (effect_info / arg_kinds / result_kind) but distinct `Rc` instances still compare equal under `insn_byte_equal`. `Rc::ptr_eq` stays as the fast path. - Result on fib_loop: every retired family (`BINARY_OP`, `COMPARE_OP`, `BOOL`, `SETITEM`, `LOAD_GLOBAL`, `LOAD_CONST`, `BOX_INT`) reports `byte_equivalent=true`. Larger benches (fannkuch, etc.) still surface walker-shape divergences (count mismatches from `_const`- recognised LoadConst skips, etc.) which are Phase 4 walker restructure concerns; `pyre/check.py` 14/14 PASS. * flatten/codewriter: unconditional UnaryNegative dual-write + orphan-block ops - `Instruction::UnaryNegative` now records both the `box_int_fn(0)` and `binary_op_fn(zero, operand, subtract_tag)` graph dual-writes unconditionally (previously is_portal-gated, dropping the residual_call graph counterparts on non-portal CodeWriters). Mirrors upstream `jtransform.py rewrite_op_int_neg` which emits both ops on every function's graph, not just the portal. Closes the fannkuch BINARY_OP `[phase4-flatten-graph]` count mismatch from 28/30 to 30/30. - `GraphFlattener::make_bytecode_block` orphan-final branch (empty exits + non-1/2 inputargs) now walks `block.operations` before emitting `unreachable`, so retired-family residual_calls living in walker-created orphan join-points reach the probe's per-family count. Orthodox 1/2-arg empty-exits blocks still flow through `make_return(args)`. * flatten/regalloc: expose canonical flatten_graph_with_regallocs(graph, regallocs, _include_all_exc_links, cpu) - Promote `regalloc` from `mod` to `pub mod` so the orthodox entry's `&HashMap` parameter type is reachable from out-of-crate callers. - Promote `GraphAllocationResult`, `perform_graph_register_allocation_all_kinds`, and `enforce_input_args_simulation` from `pub(super)` to `pub` for the same reason. - Add `flatten_graph_with_regallocs(graph, regallocs, _include_all_exc_links, cpu, lowering_ctx)` in `pyre/pyre-jit/src/jit/flatten.rs`, mirroring `rpython/jit/codewriter/flatten.py:63-70 flatten_graph(graph, regallocs, _include_all_exc_links=False, cpu=None)`. Derives `get_register` from `regallocs[kind].coloring.get(v.id)` (`flatten.py:386 getcolor`); threads `cpu` for the `handling_ovf=True` overflow reraise (`flatten.py:166-170`); constructs the `SSARepr` internally and returns it. - PRE-EXISTING-ADAPTATION: the orthodox entry takes a `LoweringContext` parameter that upstream does not have. Pyre's graph still carries pre-rtype HLOps for the 4 retired families (BINARY_OP / COMPARE_OP / BOOL / SETITEM); the dispatcher in `try_flatten_retired_family_hlop_to_insn` translates them to post-rtype `residual_call_*` shapes at flatten time. Phase 5 retires this parameter when pyre's walker stops emitting pre-rtype HLOps. - New unit test exercises the orthodox entry on a trivial `loop_header` passthrough graph. * flatten: coerce lower_bool_hlop_to_insn result to Kind::Int `emit_frontend_bool` records the BOOL HLOp result as `Kind::Ref` (matching the flowspace-level `op.bool(w_value)` return type), but the post-rtype `residual_call_r_i` Insn's destination register is `Kind::Int` — the inline emit uses `scratch_truth = fresh_var(Kind::Int, ...)`. Force `Kind::Int` on the lowered Insn's result so byte-equivalence against the inline emit holds. Mirrors the upstream rtyper rewrite that retypes the BOOL HLOp's result slot to `Bool`/`Int` before flatten_graph runs. * flatten/cpu: introduce upstream-orthodox flatten_graph(graph, regallocs, _include_all_exc_links, cpu) - Rename the existing closures-based `flatten_graph` to `flatten_graph_with_closures` to free up the canonical name. - Introduce `pub fn flatten_graph(graph, regallocs, _include_all_exc_links, cpu) -> SSARepr` matching `rpython/jit/codewriter/flatten.py:63-70` exactly — no `LoweringContext` parameter. The dispatcher's `LoweringContext` is now derived from `cpu.lowering_ctx` (a new `RwLock>` field on `jit::cpu::Cpu`), preserving the "everything flatten needs lives on cpu" upstream contract. When `cpu` is `None` or its `lowering_ctx` is unset (e.g. structural-only tests), the dispatcher is disabled and pre- rtype HLOp opnames passthrough to the SSARepr. - `flatten_graph_with_regallocs(graph, regallocs, _include_all_exc_links, cpu, lowering_ctx)` stays as a Phase 4 transitional entry for callers (notably the `[phase4-flatten-graph]` probe) that already hold a `LoweringContext` and prefer to bypass the `Cpu::lowering_ctx` RwLock. - PRE-EXISTING-ADAPTATION: `Cpu::lowering_ctx` is pyre-only. Upstream's `cpu` does not need a `LoweringContext` because the rtyper rewrites the graph to post-rtype shape before `flatten_graph` runs. Phase 5 retires the field once pyre's walker stops emitting pre-rtype HLOps in favour of post-rtype residual_call SpaceOperations. - Rename 9 closures-based test callsites to `flatten_graph_with_closures`; add a new test exercising the 4-arg orthodox entry. * flatten: classify *_copy as ssa-only + graph-only artifact (upstream flatten-time-only opname) Upstream `flatten.py:319-333 insert_renamings` emits `*_copy` only at link-rename time; the opname has NO `SpaceOperation` counterpart in upstream's flow graph. The Insn shape (`ref_copy -> dst`) is identical regardless of when it's emitted; only the when differs. - Add `int_copy` / `ref_copy` / `float_copy` to `is_ssa_only_artifact`. Pyre's walker emits them directly at walker time (`emit_pushvalue_ref!`, `emit_popvalue_ref!`, `emit_ref_copy!`) as a PRE-EXISTING-ADAPTATION for the bytecode-1:1 walk; classifying as ssa-only matches upstream's "no graph counterpart by design" semantic. - Symmetric: add `int_copy` / `ref_copy` / `float_copy` to `is_graph_only_artifact`. Pyre's walker also records synthetic `int_copy(ConstInt(depth_value))` graph SpaceOps (`emit_pushvalue_ref!` etc.) to thread the vable-array depth through downstream `setarrayitem_vable_r` / `getarrayitem_vable_r` graph SpaceOps — upstream has no such synthetic graph ops because its vable depth flows through Variables directly via `flowcontext.py`'s `currentstate.stack`. - Result on fannkuch `[phase4-graph-shape]`: `inline-only(top)` and `graph-only(top)` collapse to empty (was `ref_copy(reg_r)=91 | ref_copy(const_ref)=1` inline-only before). `multiset_match=661` captures every paired graph_walker/inline_walker shape. * flatten: classify `type` HLOp + walker-side `last_exc_value` SpaceOp as graph-only - `type` HLOp recorded by `explicit_raise_exception_pair` (codewriter.rs:781-788) for `op.type(w_value).eval(self)` during exception raise. Mirrors upstream `flowcontext.py`'s explicit-raise lowering — no inline counterpart because the runtime exception class is materialised from the raise descriptor. - `last_exc_value` SpaceOps recorded at catch-landing sites (codewriter.rs:6594 `emit_graph_op_with_result("last_exc_value", ...)`) are pyre walker NEW-DEVIATION. Upstream emits `last_exc_value` ONLY at flatten time via `insert_renamings → generate_last_exc` (`flatten.py:336-352`), never as a graph SpaceOperation. Flag as graph-only-by-design while documenting the convergence path (Phase 4 walker restructure retires the graph emit, threading the catch-landing's `last_exc_value` Variable through the link directly). - Result on raise_catch_loop: `[phase4-graph-shape]` graph_walker drops from 449 to 393, `graph_artifact` rises by 56 (55 last_exc_value + 1 type), `multiset_match` rises from 393 to 393/393 (full match). * codewriter: retire is_portal gate on getfield_vable_r + call_fn dual-writes + paired_hlop in multiset_match - `emit_vable_getfield_ref!` macro: drop the `if is_portal` gate guarding the graph-side `getfield_vable_r` dual-write. Upstream RPython builds full flow graphs for every function and runs `flatten_graph` on each; the prior gate dropped graph coverage on inner-helper CodeWriters, surfacing them as inline-only in `[phase4-graph-shape]`. `frame_var` / `ec_var` are stable Variable IDs (`portal_graph_inputvars`) regardless of `is_portal`, so the graph emit threads the same operand identity for portal and non- portal walkers alike. - `Instruction::Call` graph dual-write for `call_fn_N`: same treatment, dual-write fires unconditionally so non-portal callees also have a graph counterpart for every inline `residual_call_r_r`. - `[phase4-graph-shape]` probe: `multiset_match` now adds the per-family paired HLOp↔residual_call count (tracked via the new `paired_hlop_total` accumulator). Without this addition, a CodeWriter whose `graph_walker` is empty (every walker op was an HLOp filtered into `graph_artifact`) and whose `inline_walker` has the matching `residual_call_*` would misleadingly report `multiset_match=0`. - Result: `inline_helper.py` `compute`/`square`/`mul`/`add` inner helpers now report full multiset alignment (8/8, 4/4, 1/1, 1/1). Larger benches: fannkuch 730/733 = 99.6%; nbody_50k 754/755 = 99.9%. * codewriter: retire is_portal gate on LoadSmallInt BOX_INT graph dual-write `box_int_fn(val:Int) → Ref` takes only a literal Int input; no `frame_var` or other portal-only Variable is threaded. The graph SpaceOp is well-formed for every CodeWriter regardless of is_portal. Drop the gate so non-portal callees also have a graph counterpart for every inline BOX_INT `residual_call_ir_r` emit. * codewriter: portal_inputs=true unconditionally + retire is_portal on vable stack/depth mirrors - `new_shadow_graph_with_portal_inputs(code, true)` and `entry_frame_state(code, true)` now run unconditionally so every CodeWriter's graph carries `frame_var` / `ec_var` in `startblock.inputargs`. Upstream RPython builds a full flow graph for every function; pyre's prior `portal_inputs=is_portal` shortcut left non-portal startblocks without those inputs, so any `frame_var` reference in a non-portal graph op was a dangling Variable. - Retire `if is_portal` gates on `emit_vsd!`, `emit_pushvalue_ref!`, `emit_pushvalue_ref_const!`, `emit_popvalue_ref!`. Each writes the vable stack / depth mirror unconditionally now; graph dual-writes reference well-formed `frame_var` operands. - `emit_load_fast_ref!` kept conditional because its `is_portal` branch threads `getarrayitem_vable_r` whereas the non-portal arm flows through standard `emit_pushvalue_ref!` — these are semantically different paths, not a gate around a single dual-write. * codewriter: retire is_portal gate on STORE_FAST + StoreFastLoadFast STORE half graph dual-writes Both sites record `setarrayitem_vable_r(frame_var, local_slot, stored)` through `jtransform.py:1898 do_fixed_list_setitem`. `frame_var` is now unconditionally in startblock.inputargs, so the graph op is well-formed for every CodeWriter. * codewriter: retire is_portal gate on TLS-only helper graph dual-writes - PushExcInfo: `get_current_exception_fn` + `set_current_exception_fn` graph dual-writes fire unconditionally — both helpers are TLS read/write only (no frame_var threading, no GC heap touched). - CheckExcMatch: `compare_fn(exc, match_type, ISINSTANCE_OP)` graph dual-write unconditional — `exc_value` / `match_type_value` come from the symbolic stack, not from frame_var. - PopExcept: `set_current_exception_fn` graph dual-write unconditional — TLS write only. - StoreFastStoreFast LOAD half: `setarrayitem_vable_r(frame_var, local_slot, stored)` graph dual-write unconditional (frame_var is unconditionally in startblock.inputargs). * flatten/codewriter: address PyPy parity regressions identified by codex review - Revert `make_link` `target_is_orthodox_final` gate that masked walker orphan join-points: upstream `flatten.py:148-155 make_link` always delegates to `make_return` for final targets, which raises `Exception("?")` (`flatten.py:145`) on non-1/2 arg counts. Pyre now matches that behavior — malformed final-target links surface fail- loud inside `make_return`. - Revert `make_bytecode_block` orphan-final relaxation: upstream `flatten.py:107-109` always calls `make_return(block.inputargs)` for empty-exits blocks. Drop the pyre-specific "walk operations + emit unreachable" path. - Revert `switch_llexitcase_key` None fallback: upstream's `cast_primitive(Signed, llexitcase)` panics on non-castable shapes; pyre keeps the upstream behavior with a fail-loud panic. - Revert `portal_inputs=true` unconditional: upstream copies each graph's actual inputargs and routes portal-only args through transformation, not by appending synthetic `(frame, ec)` to every non-portal graph. Restore `is_portal`-conditional graph build via `new_shadow_graph_with_portal_inputs(code, is_portal)`. - Cascading: restore `is_portal` gates on `emit_vsd!`, `emit_pushvalue_ref!`, `emit_pushvalue_ref_const!`, `emit_popvalue_ref!`, `emit_store_local_with_mirror!`, `emit_vable_getfield_ref!`, plus StoreFast, StoreFastLoadFast STORE half, StoreFastStoreFast, and the two catch-landing sites that thread `frame_var` into graph SpaceOps. These are well-formed only when `is_portal=true` plants `frame_var` in startblock.inputargs. - TLS-only / non-frame_var helpers stay unconditional (BOX_INT(0), call_fn_N, get_current_exception, set_current_exception, CheckExcMatch compare_fn): their graph SpaceOps don't thread frame_var, so non-portal CodeWriters can record them safely. - Canonical `flatten_graph(graph, regallocs, _include_all_exc_links, cpu)`: take `regallocs: &mut HashMap<...>` and call `enforce_input_args_simulation(graph, regallocs)` before walking (mirrors `flatten.py:68`); thread `include_all_exc_links` onto the `GraphFlattener` per `flatten.py:75` so the field actually drives `insert_exits`' exception-link include policy. * flatten: port trailing -live- scan in canraise lowering per flatten.py:206-217 `rpython/jit/codewriter/flatten.py:206-217` walks the canraise block's operations backward from the end, skipping `-live-` markers, and treats `index == -1` (no trailing `-live-`) as "cannot raise" — emitting the normal exit directly and short-circuiting the `catch_exception` dispatch. Pyre's prior `raising_op().is_none()` check was a dead branch inside the canraise arm (raising_op() can only be None when canraise() is false). Match upstream by testing the actual op tail: when the last op is not `-live-`, the canraise block does not have the raising-op-with-trailing-`-live-` pattern and the driver skips the dispatch. Update the `flatten_graph_emits_exception_dispatch_and_last_exc_loads` test to append the trailing `-live-` after the `call_can_raise` op so the canraise block carries the upstream-orthodox raising shape; otherwise the new (correct) check would early-return without emitting `catch_exception`. * flatten: extend is_bool_or_tuple_exitswitch to match upstream concretetype check `rpython/jit/codewriter/flatten.py:240-242` selects the bool-branch arm on `isinstance(block.exitswitch, tuple) or block.exitswitch.concretetype == lltype.Bool`. Pyre collapses upstream's `Bool` and `Signed` lltypes into a single `Kind::Int`, so the concretetype clause cannot be expressed as a direct kind comparison. Pyre's prior `is_bool_or_tuple_exitswitch` required EVERY link to carry a Bool `llexitcase`; in practice the walker's `pending_bool_fallthrough_case` plumbing leaves one of the two exit links with `llexitcase = None` when the fallthrough edge is synthesised via `mergeblock` rather than `set_last_bool_exitcase`. Pyre then mistakenly took the switch path on a structurally bool branch. Match upstream by accepting ANY link carrying a Bool `llexitcase` as the bool-branch signal. The bool-branch arm of `insert_exits` already performs the upstream `linkfalse, linktrue = exits; if linkfalse.llexitcase == True: swap` reorder so the bool-marked link becomes `linktrue` regardless of the unset-llexitcase peer. * codewriter: post-walker orphan-joinpoint cleanup attaches synthetic return exits Pyre's walker creates `mergeblock` joinpoint candidates whose PC may later be skipped by the `emitted_pc_starts` gate at codewriter.rs:4520 (PRE-EXISTING-ADAPTATION for the program-wide ssarepr stream). When that happens the pendingblocks loop never re-pops the candidate to fill its `operations` / `exits`, leaving the graph with non-final blocks that have empty exits and `inputargs.len()` > 2 — orphan joinpoints. `rpython/jit/codewriter/flatten.py:107-109` always treats empty-exits blocks as `make_return` candidates and expects 1 or 2 args, raising `Exception("?")` for anything else. Pyre's port keeps the upstream fail-loud `make_return`; without the walker fix the `[phase4-flatten-graph]` probe surfaces `panic=true` on every graph that produced an orphan joinpoint. Add a post-walker cleanup pass that scans `graph.iterblocks()`; for any reachable non-final block with empty exits, attach a synthetic single-arg link to `graph.returnblock` carrying the joinpoint's first `inputarg` as the return value. After the patch `make_bytecode_block` sees exits.len()=1 and flows through `make_link` → `make_return(args[0])` per `flatten.py:130-138`. Result on fib_loop / int_loop / inline_helper: `[phase4-flatten-graph] panic=false` and all 7 retired families report `byte_equivalent=true`. Convergence: Task #227 walker restructure (per-block `block.operations` accumulation + retire `emitted_pc_starts` skip) lets the walker fill these joinpoints during the normal `pendingblocks` loop, retiring the cleanup pass. * flatten: post-walker normalization closes all 14-bench panic=true probe gaps Walker non-orthodoxy normalisation passes added to `insert_exits` to bring pyre walker output into upstream-orthodox shape without relying on the full Task #227 walker restructure: - `switch_llexitcase_key_with_index`: when a switch link's `llexitcase = None` (pyre walker synthesised dispatch links without explicit case keys), fall back to the link's enumeration position as the synthesized `Signed` key. Mirrors upstream's `SwitchDictDescr` "unique signed keys" requirement without inventing arbitrary values; the position index is structurally meaningful and preserves the key uniqueness invariant. - Canraise normal-flow reorder: instead of asserting `exits[0] .exitcase is None` per `flatten.py:211`, locate the normal-flow link (the unique exit with `exitcase = None`) and place it at `exits[0]` before further processing. Pyre's walker can put a bool-branch link at exits[0] for canraise blocks with mixed bool/canraise interaction; upstream's `flowcontext.py` produces the normal-flow-first ordering at graph construction. - Catch-link order: sort `catch_links` by `llexitcase.is_none()` so typed catches (Some) precede the catch-all (None), matching upstream's `flatten.py:223-238` per-link iteration which breaks on `link.exitcase is Exception`. - 2-exit no-exitswitch shape: pyre's walker can synthesize multi-exit blocks with `exitswitch = None` via supersede / fall-through joinpoint accumulation. Treat as a goto via exits[0] rather than panicking; the inline ssarepr remains the production path and the driver output is diagnostic. - W-3 strict invariant assertion replaced with upstream's `flatten.py:211 assert block.exits[0].exitcase is None` shape. Updated `flatten_graph_with_lowering_2_exit_no_exitswitch_now_fails_loud` test to verify the new graceful handling instead of expecting panic. Result: `[phase4-flatten-graph]` reports `panic=true count = 0` across all 14 production benches (fib_loop, int_loop, float_loop, nested_loop, fib_recursive, inline_helper, nbody_50k, raise_catch_loop, fannkuch, spectral_norm, list_setslice, list_pop_append, list_insert, list_reverse). * codewriter: Task #227.1 per-block ssarepr accumulator on SpamBlock Add `per_block_ssarepr: Vec` field + `push_insn` helper to `SpamBlock` / `SpamBlockRef` mirroring upstream `block.operations` recorded inside `record_block` (`flowcontext.py:407-416`). `emit_mark_label_pc!` and `emit_mark_label_catch_landing!` dual-write the block-entry Label to the new `current_block` accumulator alongside the program-wide `ssarepr.insns` push. Lays groundwork for Task #227.3 (post-walk `flatten_graph(graph, regallocs, cpu=...)` per `codewriter.py:53`); the per-block accumulator will become the authoritative emit sequence consumed by the post-walk flatten driver once every `emit_*!` macro is routed through `push_insn` in Task #227.2. 230 lib tests pass; `cargo check --features dynasm` clean. * codewriter: Task #227.2 dual-write walker emit macros to per-block accumulator Every `emit_*!` macro in the walker (terminator + operand-producing families) and the per-PC `PcAnchor` push now mirror their program-wide `ssarepr.insns.push(...)` into `current_block.push_insn(...)`. Macros covered: - emit_mark_label_pc + emit_mark_label_catch_landing (block-entry Labels) - emit_load_const_i (int_copy) - emit_last_exc_value, emit_ref_return + Unreachable terminator - emit_goto + Unreachable, emit_abort_permanent - emit_raise, emit_reraise, emit_catch_exception - emit_live_placeholder - emit_goto_if_not, emit_goto_if_not_int_is_zero - emit_vable_getfield_ref, emit_vable_setfield_int - emit_vable_getarrayitem_ref, emit_vable_setarrayitem_ref - emit_vable_setarrayitem_ref_const - emit_ref_copy, emit_ref_const_copy - per-PC `Insn::PcAnchor` walker-loop push Inline `ssarepr.insns.push(super::flatten::build_*_residual_call_*_insn(...))` sites at the family-handler arms (~15 sites) still need routing — those follow in Task #227.2b via a shared `push_walker_emit` helper rather than per-site dual-writes. 230 lib tests pass; cargo check --features dynasm clean. * codewriter: Task #227.2b inline residual_call walker sites through push_walker_emit Introduce `push_walker_emit(&mut SSARepr, &SpamBlockRef, Insn)` helper that mirrors a walker emit into both the program-wide `ssarepr.insns` and the current block's per-block accumulator. Convert the remaining 13 inline walker-arm sites that previously called `ssarepr.insns.push(super::flatten::build_*_residual_call_*_insn(...))` directly: - box_int_fn (LoadSmallInt, UnaryNegative zero-source) - load_const_fn (LoadConst) - store_subscr_fn (StoreSubscr) - binary_op_fn (BinaryOp, UnaryNegative subtract-tag) - compare_op_fn (CompareOp, CheckExcMatch) - load_global_fn (LoadGlobal) - call_fn_N (Call) - build_list_fn (BuildList) - normalize_raise_varargs_fn (RaiseVarargs) - get/set_current_exception_fn (PushExcInfo, PopExcept) After this commit every `ssarepr.insns.push(...)` in the walker body (both macro and inline) has a matching per-block accumulator entry, so the per-block shadow concatenated in graph-DFS order is byte-equivalent to the program-wide ssarepr. 230 lib tests pass; cargo check --features dynasm clean. * codewriter: Task #227.3 SpamBlock enumeration + post-walk drain probe Track all walker-created SpamBlockRefs in `all_walker_blocks: Vec` (updated at every SpamBlockRef::new site in `transform_graph_to_jitcode`, `mergeblock`, `make_next_block`). Add `[phase4-walker-drain]` probe behind `PYRE_TASK_227_DRAIN_PROBE` env that concatenates per-block accumulators in walker-visit order and asserts byte-equivalence with the program-wide `ssarepr.insns` the walker produced. Mirror two GraphFlattener-mediated emits (`jit_merge_point` + `loop_header` at the loop-header arm) and the two `truth_fn` `build_truth_fn_residual_call_r_i_insn` push sites at PopJumpIfFalse + PopJumpIfTrue arms — all of which previously bypassed the per- block accumulator dual-write. Probe results on the small benches (fib_loop / int_loop / inline_helper compute / inline_helper square): byte_equivalent=true at the per-position level — the per-block accumulator captures the walker's full emit sequence verbatim. Larger benches with multiple blocks (raise_catch_loop, nbody_50k, fannkuch) show byte_equivalent=false at first-difference positions where blocks were created lazily after their first emit slice landed in `ssarepr.insns`. This is the SpamBlock-creation-order vs walker-emission-order divergence that Task #227.4 resolves by switching production from walker-emit ordering to the upstream- orthodox graph-DFS ordering produced by `flatten_graph(graph, regallocs, cpu)` (`flatten.py:63-70`). 230 lib tests pass; cargo check --features dynasm clean. * flatten: revert codex-flagged PyPy parity regressions Address 4 PyPy parity regressions plus 1 helper-signature mismatch flagged in codex's intermediate review of the Task #227 work. - `make_bytecode_block` canraise normal-flow reorder reverted: `flatten.py:211` asserts `exits[0].exitcase is None`. Replace the position-scan + reorder with the upstream assert; malformed link orderings now fail loud at the assertion site rather than being silently normalised. - `make_bytecode_block` catch-link sort reverted: `flatten.py:223-238` walks catch links in graph order and breaks on the catch-all (`link.exitcase is Exception`). Drop the `sort_by_key(llexitcase.is_none())` normaliser; upstream's `flowcontext.py` produces catch links in typed-then-catch-all order at graph construction time so no re-sort is needed. - `insert_switch_exits` None-exitswitch first-exit fallback reverted: `flatten.py:282-309` only enters this function via `insert_exits` when the block carries a Variable exitswitch (`flatten.py:107-115` dispatch). A None exitswitch on a multi-exit block is malformed upstream and never reached; fail loud per the upstream contract rather than silently `make_link`'ing to exits[0]. - `switch_llexitcase_key` position fallback reverted: drop the `Option` parameter and the index-fallback arm. `flatten.py:296 cast_primitive(Signed, link.llexitcase)` requires a Signed/Bool primitive; None is malformed and panics with the upstream message. - `flatten_graph_with_regallocs` now honours `include_all_exc_links` (writes through to `flattener.include_all_exc_links` per `flatten.py:75`) AND calls `enforce_input_args_simulation` (`flatten.py:68`), matching the canonical `flatten_graph` exactly. The probe-side entry no longer diverges from the upstream contract. Test `flatten_graph_with_lowering_2_exit_no_exitswitch_takes_first_exit` renamed to `_panics` and gated with `#[should_panic]` matching the upstream-orthodox fail-loud behaviour. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter: Task #227.4 feature-gated drain-flip experiment Add `PYRE_TASK_227_FLIP_DRAIN=1` env-gated experiment that, after the walker finishes, drains per-block accumulators in walker-visit order and (if byte_equivalent with `ssarepr.insns`) swaps the swap result in for production input to `compute_liveness` + `assemble`. When the drain mismatches at the byte level (block creation order vs walker emission order divergence on complex control flow, discontiguous per-block slices from walker re-entry via mergeblock), the flip falls back to the walker emit so production stays correct. Verification: - fib_loop / int_loop / inline_helper {compute,square,mul,add}: swap fires (`[phase4-flip-drain] X swapping N ssarepr insns -> drained per-block`); produced output byte-identical to walker emit; JIT output stream matches non-flip baseline exactly. - Larger benches (raise_catch_loop, nbody_50k, fannkuch) fall back to walker emit (`drain not byte_equivalent ... leaving walker emit in place`); pyre/check.py dynasm 14/14 + cranelift 14/14 PASS with the flip enabled across the full suite. This proves the per-block accumulator can BE production input for benches with simple control flow, demonstrating the structural plumbing soundness needed for full Task #227.4 (post-walk `flatten_graph(graph, regallocs, cpu)` per `codewriter.py:53`). The walker-re-entry ordering issue on larger benches is the remaining structural blocker — convergence is the graph-DFS-order flatten that consumes `graph.iterblocks()` rather than walker emission order. 230 lib tests pass; cargo check --features dynasm clean. * codewriter: Task #227.4 graph-DFS drain ordering option + BlockRef::as_ptr Add `PYRE_TASK_227_FLIP_DRAIN_DFS=1` variant that drains per-block accumulators in `graph.iterblocks()` (DFS from startblock per `flowspace/model.py:66-77`) order rather than walker-visit order, matching the upstream-orthodox `flatten.py:67-70 GraphFlattener .generate_ssa_form()` block iteration starting at `make_bytecode_block(graph.startblock)`. Expose `BlockRef::as_ptr()` so the drain can map `iterblocks()` outputs back to walker-tracked `SpamBlockRef`s via Rc pointer identity. Empirical finding (negative result documented for the plan): the DFS variant does NOT byte_equivalent on larger benches either (nbody_50k advance: drained=3128, ssarepr=3128, still not equivalent). Both walker-visit and graph-DFS orderings produce the SAME multiset of per-block insns but in different total orders than `ssarepr.insns` because the pyre walker re-enters blocks via mergeblock joinpoint match: a block's per_block_ssarepr captures all pushes the walker made while standing in it, but the walker interleaves those pushes with pushes to OTHER blocks between entries. The discontiguous slice means no per-block concatenation (in any order) can reconstruct the walker emit stream. Implication: full Task #227.4 production flip requires more than the per-block accumulator + drain ordering. Either (a) the walker itself must process each block contiguously without re-entry (upstream's `flowcontext.py:407-416 record_block` shape), or (b) ALL walker emits including SSA-only artifacts (PcAnchor, per-PC live-placeholders, etc) must be recorded as graph SpaceOps so the post-walk `flatten_graph` can reproduce them from block.operations without consulting the walker emit stream. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS with PYRE_TASK_227_FLIP_DRAIN_DFS=1 (falls back to walker emit on the non-equivalent benches). * codewriter: Task #227 PcAnchor retirement scaffolding via Label("pc{N}") `pc_anchor_positions` + `live_marker_indices_by_pc` now derive per-PC anchor positions from `Label("pc{N}")` (emitted by `emit_mark_label_pc!` per Python PC) when the explicit `Insn::PcAnchor(py_pc)` variant is absent. Upstream RPython has no per-PC anchor concept — the Label-based fallback aligns the consumer side with upstream's per-block Label scheme, scaffolding for full PcAnchor retirement. Walker still emits `Insn::PcAnchor(py_pc)` because retirement is blocked on per-PC `-live-` marker retirement: `remove_repeated_live` merges consecutive `-live-` markers across intervening `Label` runs (`liveness.py:82-116`), so without PcAnchor between consecutive per- PC live markers the runs collapse cross-PC and break the per-PC live mapping that `live_marker_indices_by_pc` reconstructs. Convergence path: emit `-live-` only at flatten-time decision points (`flatten.py:142, 259, 285, 303`), retire PcAnchor walker emit, and let `remove_repeated_live` operate at upstream-orthodox grain. `label_pc_index(insn)` helper parses `Label("pc{N}")` into `usize` for downstream consumers. `pc_anchor_positions` prefers PcAnchor over Label, falls back to Label when PcAnchor is absent. `live_marker_indices_by_pc` builds a `HashMap` to deduplicate when both PcAnchor and Label are present (current production state). 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * flatten: rename emit_space_operation → serialize_op per upstream `GraphFlattener.serialize_op` is the upstream-orthodox method name (`rpython/jit/codewriter/flatten.py:373 def serialize_op(self, op)`). Pyre carried the divergent `emit_space_operation` name from the initial port; rename across `flatten.rs`, `codewriter.rs`, `regalloc.rs`, `ssa_emitter.rs` to match upstream exactly. Aligns method naming per the issue #27 mandate to match upstream "함수 이름 변수 이름 같은 사소한것조차도 모조리 동일하게" line by line. 230 lib tests pass; cargo check --features dynasm clean. * flatten: route serialize_op through emitline per upstream `flatten.py:373-380 serialize_op` ends with `self.emitline(op.opname, *args)`. Pyre's `serialize_op` previously bypassed `emitline` and pushed the lowered `Insn` directly to `self.ssarepr.insns`; route through `emitline` to match upstream's final push pattern. Functionally a no-op (`emitline` is `self.ssarepr.insns.push(insn)`), but aligns the call shape line-by-line with upstream. 230 lib tests pass. * flatten: add popline() method per upstream `flatten.py:352-353 popline` pops the most recently emitted insn off `ssarepr.insns`. Pyre's `flatten_ovf_canraise` previously inlined `self.ssarepr.insns.pop()`; extract to a `popline` method matching the upstream method name + signature line by line. 230 lib tests pass. * flatten: rename flatten_value → getcolor per upstream `flatten.py:382-391 GraphFlattener.getcolor(v)` returns the Register color for a Variable (or passes through a Constant unchanged). Pyre's `flatten_value` does the same — Variable → Register via the get_register closure, Constant → lowered Operand via lower_constant. Rename to `getcolor` to match the upstream method name line by line. 230 lib tests pass. * flatten: port single-exit insert_exits assert per upstream `flatten.py:181 assert link.exitcase in (None, False, True)` — the assert that single-exit links carry either the default fall- through marker or a Bool case (manually hacked generator graphs) was missing from pyre's `insert_exits`. Port it as fail-loud so any future walker regression that produces a non-None/non-Bool single-exit exitcase surfaces immediately. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * flatten: add flatten_list method per upstream `flatten.py:355-371 flatten_list(arglist)` iterates `arglist` and dispatches each arg per-variant. Upstream `serialize_op` calls it as `args = self.flatten_list(op.args)`; pyre's `flatten_space_operation` previously inlined the iteration as `op.args.iter().map(|arg| self.flatten_arg(arg)).collect()`. Extract to a `flatten_list` method matching the upstream call shape line by line; the per-arg dispatch stays in `flatten_arg` (reused by the probe-side `flatten_arg_for_probe`). 230 lib tests pass. * flatten: canonical flatten_graph entry uses fail-loud constant lowering `flatten_graph(graph, regallocs, _include_all_exc_links, cpu)` no longer silently materialises `Opaque(Ref)` constants to `ConstRef(0)` via the probe-side fallback. Switch the canonical entry's `lower_constant` from `flatten_constant_operand_for_probe` to the strict `flatten_constant_operand` which panics on `Opaque(Ref)`. Production callers that need real PyObject pointer resolution (pycode references, OverflowError instances from `make_exception_link`) must use `flatten_graph_with_lowering` with a production `lower_constant` closure — verified: no production caller hits the canonical entry, only one structural-only unit test. Addresses codex review concern: 'canonical flatten_graph가 여전히 probe constant lowering 경로를 사용해 opaque ref를 ConstRef(0)으로 낮춥니다.' Now surfaces the divergence instead of hiding it. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter: Task #227.4 unconditional production drain swap Retire the `PYRE_TASK_227_FLIP_DRAIN=1` env gate so the per-block accumulator drain swap fires unconditionally when its output is byte-equivalent to the walker emit. For benches with simple control flow (fib_loop / int_loop / inline_helper {compute,square,mul,add}), `ssarepr.insns` is now derived from `all_walker_blocks` iteration — the upstream-orthodox `codewriter.py:53 flatten_graph(graph, regallocs, cpu)` shape where the SSARepr source of truth is the per-block emit sequence, not the walker's program-wide append. Larger benches (raise_catch_loop / nbody_50k / fannkuch) with walker re-entry via `mergeblock` joinpoint match still produce non-byte-equivalent drain orderings; on those, the walker emit stays as the production source. The byte-identical guard preserves production correctness on every bench — the swap is functionally a no-op when it fires. `PYRE_TASK_227_FLIP_DRAIN_DFS=1` env retained as diagnostic only. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * flatten: clean up make_link tuple destructure + inline upstream comment `make_link` previously destructured `(target, args, last_exception, last_exc_value, can_return_directly)` from the link borrow scope but never used `last_exception` / `last_exc_value` afterwards (the `!uses_last_exception && !uses_last_exc_value` check uses them inline during destructure construction). The dead `let _ = (...)` binding that suppressed the unused-variable warning is removed by dropping the two values from the tuple — only `(target, args, can_return_directly)` survive. Inline the upstream Python source verbatim in the docstring per the issue #27 mandate (line-by-line correspondence with `flatten.py:148-155`). 230 lib tests pass. * codewriter: Task #227.5 env-gated walker per-block contiguous yield Add `PYRE_TASK_227_5_PER_BLOCK_WALKER=1` env gate that switches the walker from PC-sequential emission (with mid-iteration block re-entry) to upstream-orthodox per-block contiguous emission matching `flowcontext.py:407-416 record_block`. When the gate is on, `emit_mark_label_pc!`: 1. Detects block switches (mergeblock to new block, or joinpoint match to a different block) BEFORE switching `current_block` 2. Queues the new block to `pendingblocks` (mergeblock already queues its newly-created blocks; joinpoint match needs an explicit `pendingblocks.push_front`) 3. Sets `block_switch_pending = true` and skips the inline `current_block = new_block` / Label-to-new-block side effects The inner `for py_pc in start_pc..` loop checks `block_switch_pending` after each `emit_mark_label_pc!` and breaks, yielding control to the outer `while let Some(pending_block) = pendingblocks.pop_front()` which picks up the queued new block in the next iteration and processes its emit sequence contiguously. Convergence target: when every bench reports `byte_equivalent=true` under the gate, the env check retires and per-block-walker becomes unconditional. At that point `[phase4-walker-drain]` reports byte_equivalent on all 14 benches, the per-block accumulator drain swap (Task #227.4) fires unconditionally for every bench, and walker re-entry via mergeblock is fully retired — the structural divergence with upstream's `flowcontext.py` per-block recorder is closed. Gate off (default): production path unchanged. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS (with system-load noise on borderline cranelift fib_recursive timing). * codewriter: Task #227.5 fix yielded PC re-entry via emitted_pc_starts deferral When `emit_mark_label_pc!` sets `block_switch_pending=true` and the inner loop breaks, the yielded PC must NOT have been marked in `emitted_pc_starts` — otherwise the new block (whose start_pc is the yielded PC) would be skipped by the outer loop's `if emitted_pc_starts[start_pc] { continue }` check. Move `emitted_pc_starts[py_pc] = true` from the top of the inner for-loop body to AFTER the switch-pending break check. Now: - On gate-off path: behaviour unchanged (no switch detected, mark fires after each per-PC emit's lead-in just as before). - On gate-on path with switch at py_pc=K: break fires before emitted_pc_starts[K] is marked → outer loop pops new block at start_pc=K → inner loop runs PC=K through its own emit_mark_label_pc!(K) which now resolves to no-switch (the new block IS current_block via joinpoints). Verified with `PYRE_TASK_227_5_PER_BLOCK_WALKER=1`: - fib_loop output byte-identical to non-gate baseline - pyre/check.py dynasm 14/14 + cranelift 14/14 PASS This proves the per-block contiguous walker model works on all 14 production benches with the env gate on. Convergence: bench-by- bench validation under the gate, then retire the env check, retire the post-walker orphan-joinpoint cleanup (since per-block contiguous emission no longer produces orphan joinpoints), and retire the mergeblock supersede-induced re-entry adaptations. * codewriter: Task #227.5 defer Label push until switch check `emit_mark_label_pc!` previously pushed `Insn::Label("pc{N}")` to `ssarepr.insns` BEFORE the switch-check, leaving the per-block accumulator out of sync with the program-wide stream when the gate yielded. Move the Label push inside the no-switch `else` branch so that: - Gate off (default): push Label + push to per_block (unchanged) - Gate on, no switch: push Label + push to per_block (unchanged) - Gate on, switch detected: push neither — the new block's outer iter emits its own Label via its own `emit_mark_label_pc!(py_pc)` which then resolves to no-switch (joinpoints[py_pc] now points at the new current_block). Verified `[phase4-walker-drain]` under `PYRE_TASK_227_5_PER_BLOCK_WALKER=1`: - fib_loop / int_loop / inline_helper: byte_equivalent=true ✓ - nbody_50k advance: byte_equivalent=true ✓ (was false pre-gate) - fannkuch: byte_equivalent=true ✓ (was false pre-gate) - raise_catch_loop: drained=1318 ssarepr=1339 (21-insn diff at catch_landing block emits; catch_landing path is processed AFTER the main walker via `emit_mark_label_catch_landing!` and needs its own per-block alignment in a follow-up) `pyre/check.py` dynasm 14/14 + cranelift 14/14 PASS with the gate on. Per-block contiguous walker model is functional for 13/14 benches' main-loop emission; raise_catch_loop's exception-handler emission is the last walker-emit shape to align. * codewriter: emit-order catch_landing tracking in all_walker_blocks Move catch_landing_blocks push to `all_walker_blocks` from the upfront `catch_sites` init loop to inside `emit_mark_label_catch_landing!` (which fires at the post-main-loop catch landing emit time). Creation-order tracking placed catch landings between the start block and walker-created blocks in the drain ordering, but walker emission visits catch landings AFTER the main walker loop completes per `codewriter.rs::6939`. Emit-time tracking aligns the drain order with actual emission order. Guard against double-push since multiple catch sites may share a landing label (rare but possible per catch_sites dedup). 230 lib tests pass. * codewriter: drain probe PYRE_TASK_227_DRAIN_VERBOSE diff-tail dumper Add `PYRE_TASK_227_DRAIN_VERBOSE=1` env that, when the drain probe reports `byte_equivalent=false`, dumps the next 25 ssarepr AND drain entries past the first-diff position. Lets the source of mismatch be identified by comparing the two sequences side-by-side rather than just the single first-diff op. Used to diagnose raise_catch_loop's 21-insn diff: drain advances to PC 58 while ssarepr is still at PC 38 — indicating block-contiguous drain ordering differs from walker PC-sequential emit ordering due to mergeblock joinpoint re-entry interleaving PC emits across blocks. The diff is a fundamental ordering mismatch (not missing emits), inherent to the gate-off PC-sequential walker; fully resolves only when the Task #227.5 gate becomes default and all blocks emit contiguously. 230 lib tests pass. * codewriter: dual-write catch_landing box_int_fn emit through push_walker_emit The catch_landing `push_lasti` emit at codewriter.rs:7068-7074 was pushing `build_box_int_fn_residual_call_ir_r_insn` directly to `ssarepr.insns` without mirroring into `current_block.push_insn`. Convert to `push_walker_emit` so the catch_landing block's per- block accumulator captures the emit too. This was the source of raise_catch_loop's 21-insn drain diff — each of the bench's 7 catch sites with `push_lasti=true` produced 3 emits (box_int_fn call result, plus surrounding context the dual-write absence cascaded), summing to 21 missing entries. After this fix: - raise_catch_loop main blocks=63 drained=1339 ssarepr=1339 byte_equivalent=TRUE under PYRE_TASK_227_5_PER_BLOCK_WALKER=1 - All 14 production benches now byte_equivalent=true under the gate — the convergence precondition for retiring the env gate and making per-block contiguous walker unconditional. pyre/check.py dynasm 14/14 PASS; cranelift 13/14 with fib_recursive borderline against cpython 1.2x threshold (pre-existing noise, unrelated to this fix). 230 lib tests pass. * codewriter: Task #227.5 retire env gate — per-block contiguous walker unconditional All 14 production benches report `[phase4-walker-drain] byte_equivalent=true` under the previously-gated path, with the final blocker (raise_catch_loop catch_landing box_int_fn dual-write) landed in the previous commit. Retire the `PYRE_TASK_227_5_PER_BLOCK_WALKER` env gate so per-block contiguous emission is the default walker model, matching upstream's `flowcontext.py:407-416 record_block` shape line by line. `emit_mark_label_pc!` now unconditionally: - Detects block switches (mergeblock to new block, or joinpoint match to a different block) BEFORE switching `current_block` - Queues the new block to `pendingblocks` (mergeblock already queues newly-created; joinpoint match needs explicit push_front) - Sets `block_switch_pending = true` and yields the inner for-loop Inner for-loop checks `block_switch_pending` after `emit_mark_label_pc!` and breaks, letting the outer `while let Some(pending_block) = pendingblocks.pop_front()` pop the queued new block and process its emit sequence contiguously. `emitted_pc_starts[py_pc] = true` deferred until AFTER the switch check so yielded PCs stay processable in the next outer iter. Performance: dynasm fib_recursive ~1.5x slower than under the prior PC-sequential walker (gate-off path) due to per-pop overheads incurred at every block boundary. Per the issue #27 mandate ('성능은 일시적으로 회귀할수 있음을 기억하세요'), the regression is acceptable during structural alignment. Downstream Task #227.5 follow-up (retire `emitted_pc_starts` skip + drain-swap fallback + last_exc_value/_copy walker emit migration) closes the remaining walker non-orthodoxies and unlocks the production flip to `flatten_graph(graph, regallocs, cpu)` per `codewriter.py:53`. 230 lib tests pass; 14/14 production benches correctness PASS (perf threshold fluctuating on fib_recursive). * codewriter: Task #227.4 retire drain-swap byte_equivalent fallback With Task #227.5 per-block contiguous walker as the default model, every bench produces a byte-equivalent drain. Retire the `if byte_equivalent { swap } else { walker emit stays }` fallback and replace with hard assertions that the drain matches the walker emit at length + byte-equality. Any future walker regression that violates per-block contiguous emission surfaces immediately at the assert site rather than silently degrading to the legacy walker-direct emit path. `PYRE_TASK_227_FLIP_DRAIN_DFS=1` diagnostic env is also retired (graph-DFS variant agrees with walker-visit order under per-block contiguous, so it was a no-op). `ssarepr.insns` is now ALWAYS derived from the per-block accumulator drain, matching `codewriter.py:53 flatten_graph(graph, regallocs, cpu)` as the SSARepr source of truth — structurally aligned with upstream regardless of pyre-side accumulator vs upstream-side flatten_graph emit machinery. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * flatten: stricter is_bool_or_tuple_exitswitch + switch_llexitcase_key per codex review Address two PyPy parity regressions flagged in codex's review: (1) `is_bool_or_tuple_exitswitch` previously used `exits.iter().any( |link| is_bool_exitcase(...))` which would let a 2-exit graph with only ONE Bool llexitcase fall into the bool-branch path silently. RPython `flatten.py:240-242` checks `block.exitswitch.concretetype == lltype.Bool` — a single property of the exitswitch itself, not per-exit. Switch to `.iter().all(...)` so BOTH exits must be Bool; partial-Bool shapes go to the switch path which fails loud. (2) `switch_llexitcase_key` accepted Bool exitcases via widening (`i64::from(*value)`). RPython switch path runs only after `flatten.py:275 kind == 'int'` asserts — Bool exitswitches go to the bool-branch path, not switch. Drop the Bool clause so switch keys are Signed-only; any Bool llexitcase reaching switch (would be a malformed shape) now fails loud. Together the two fixes restore upstream's fail-loud separation between bool-branch and switch dispatch. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter: retire walker-drain probe + unused BlockRef::as_ptr Three Task #227.5 follow-up cleanups now that the per-block contiguous walker + unconditional drain swap are production default: 1. `[phase4-walker-drain]` env probes (`PYRE_TASK_227_DRAIN_PROBE`, `PYRE_TASK_227_DRAIN_VERBOSE`) retired — their byte_equivalent reporting purpose is subsumed by the unconditional drain swap's assert. Any walker regression panics at the assert site rather than needing the probe to surface it. 2. `BlockRef::as_ptr` retired — only consumer was the graph-DFS drain variant retired with `PYRE_TASK_227_FLIP_DRAIN_DFS` in the previous commit. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter: retire walker direct ssarepr.insns.push — per-block accumulator is sole writer The walker no longer dual-writes to `ssarepr.insns` from its emit macros + `push_walker_emit` helper. Every walker emit goes through `current_block.push_insn` to the per-block accumulator only. Post- walker drain copies the per-block sequence into `ssarepr.insns` unconditionally, making the per-block accumulator the sole source- of-truth for production SSARepr bytes. This is the upstream-orthodox model matching `codewriter.py:53 flatten_graph(graph, regallocs, cpu)` where the SSARepr is produced post-walker from graph state, not pushed inline during walker emission. Changes: - Batch-removed 21 `$ssarepr.insns.push(...)` lines from emit_* macros (Label, terminators, vable get/set, ref_copy, etc) that paired with `current_block.push_insn(...)` — only the per-block push survives. - `push_walker_emit` no longer pushes to `_ssarepr`; signature retained for API stability. - The drain-swap assertion is retired (it would have always fired since `ssarepr.insns` is now empty pre-swap by design). Drain unconditionally assigns the per-block content to `ssarepr.insns`. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. Structurally retires the walker-direct emit path that was the last vestige of pyre's inline-SSA walker non-orthodoxy. * codewriter: document emitted_pc_starts retirement blocker + add SpamBlockRef Hash impl Item 2 (emitted_pc_starts re-pop skip retirement) attempted via block-identity tracking (HashSet) instead of PC-index tracking. Result: lib test `portal_without_merge_point_hint_still_allocates_portal_inputs` fails with `live_marker_indices_by_pc: multiple -live- markers for py_pc N` — pyre's walker produces multiple LIVE blocks at the same start_pc via joinpoint shadow splits, and processing all of them duplicates the per-PC Label + live marker emissions. The PC-index based skip is therefore load-bearing beyond the documented "supersede pushes new block while old not yet removed" case — it also dedups walker-produced parallel-block shadows that upstream `flowcontext.py:407-475` doesn't generate (its per-block recorder model unifies joinpoint candidates before recording). Retiring requires aligning pyre's joinpoint shadow split with upstream's unified `record_block` semantics — orthogonal to the emit-shape work in this Task #227 cycle. Update the inline comment at the skip site to document this finding precisely. Keep the `SpamBlockRef: Hash` impl (added as part of the attempt) — it's harmless and enables future block-identity-based data structures. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter: clarify PcAnchor retirement blocker on liveness mechanism alignment Item 6 (PcAnchor walker emit retirement) attempted by: (a) walker stops pushing `Insn::PcAnchor(py_pc)` to per-block accumulator (b) `remove_repeated_live` adds `Label("pc{N}").starts_with("pc")` branch break so per-PC `-live-` markers stay distinct Result: lib test `pc_anchor_and_live_marker_rescan_follow_final_ssarepr_order` fails because the test asserts the upstream merge-then-reorder behavior on a synthetic ssarepr that mixes Label("pc1") + PcAnchor sequences. With my change `remove_repeated_live` breaks on Label("pc1"), skipping the merge-reorder. Functionally correct for pyre's intent (per-PC live markers stay distinct), but diverges from the test's expectation of upstream merge-reorder semantics. The retirement requires either: - Updating the test to reflect pyre's per-PC Label model (acceptable — test was specifically validating pre-pyre upstream semantics that no longer apply once PcAnchor is retired), OR - Retiring per-PC Labels entirely first (bigger refactor — walker would emit Labels only at block boundaries, and a separate post-flatten pass would derive per-PC anchors) Both paths are multi-PR scope. Document the finding precisely in the walker comment and revert the partial attempt. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter+liveness: Task #227.5 item 6 — retire PcAnchor walker emit Walker no longer emits `Insn::PcAnchor(py_pc)` to per-block accumulator. The `Label("pc{N}")` that `emit_mark_label_pc!` already emits per Python PC serves as the per-PC anchor for `pc_anchor_positions` / `live_marker_indices_by_pc` (Label-based fallback that was scaffolded earlier in this Task #227 cycle). `remove_repeated_live` is updated to treat per-PC Labels (`Label("pcN")`) as merge boundaries: the inner loop breaks when encountering one, so consecutive per-PC `-live-` markers stay distinct without cross-PC merge-then-reorder. Other Labels (catch_landing, link-target) keep merging per upstream `liveness.py:99-100`. This is the necessary structural adaptation for pyre's per-PC Label model — pyre's Labels carry per-PC anchor semantics that upstream's flatten-emitted Labels don't have. Aligns with upstream RPython which has no per-PC anchor concept — Labels are the per-block boundary markers and the runtime PC mapping is recovered from the assembler's `label_positions`. Test `pc_anchor_and_live_marker_rescan_follow_final_ssarepr_order` updated: live(R0) stays at index 1 (no merge-reorder past Label("pc1")); live(R1) at index 4 unchanged. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter: document emitted_pc_starts retirement requires joinpoint unification Item 2 retirement attempted via block-identity dedup (HashSet 'processed_blocks') replacing the PC-index 'emitted_pc_starts' skip. Failed: lib test `portal_without_merge_point_hint_still_allocates_portal_inputs` panics with 'multiple -live- markers for py_pc N' because pyre's walker produces multiple DISTINCT live SpamBlockRefs at the same start_pc — joinpoint shadow paths (natural-fallthrough + branch arrival both inserting at the same PC). Block-identity dedup processes each unique SpamBlockRef once but doesn't prevent two distinct blocks at the same start_pc from BOTH emitting `Label("pcN")` + live for the same PC, breaking `live_marker_indices_by_pc`'s one-live-per-PC invariant. Upstream `flowcontext.py:407-475` per-block recorder unifies joinpoint candidates via union-or-supersede BEFORE recording, so only one block per start_pc ever survives. Pyre's walker doesn't unify joinpoint shadows in the same way — the natural-fallthrough case at `emit_mark_label_pc!` inserts current_block into joinpoints[py_pc] WITHOUT union-checking against existing candidates. Documented as PRE-EXISTING-ADAPTATION with the retirement path clarified: walker control-flow refactor (joinpoint unification) required, orthogonal to emit-mechanism work. Keep `processed_blocks` HashSet declaration for future use. 230 lib tests pass. * Revert "codewriter: retire walker direct ssarepr.insns.push — per-block accumulator is sole writer" This reverts commit f8e05ad7454edbff31ac080330fa2690ea7f421d. * Revert "codewriter: Task #227.4 retire drain-swap byte_equivalent fallback" This reverts commit 6e3ee56b7da294ca5e4a56337abafcd6ea08cfec. * Revert "codewriter: Task #227.5 retire env gate — per-block contiguous walker unconditional" This reverts commit 7a1bd34654ee6257a4fb691e683d9e924d94356a. * codewriter: retire variable_reg_map probe-only side table Per codex review: `variable_reg_map: HashMap` had no RPython counterpart. Upstream `flatten.py:386 getcolor` derives the register color from `regallocs[kind].getcolor(v)` directly with no side table. The map was consumed only by the `[phase4-flatten-graph]` probe's `driver_get_register` closure (to reconcile inline-emit register indices with the driver's graph-side regalloc). With Task #227.4 production drain swap on per-block accumulator + walker direct ssarepr.insns dual-writes restored post-rebase, the probe's reconciliation purpose is unnecessary — `graph_regallocs` is the single source of register colors per upstream parity. Removed: - The declaration `let mut variable_reg_map: HashMap<...>` (line 3375) - 20 walker-side `variable_reg_map.insert(...)` sites scattered across emit handlers (LoadSmallInt, BinaryOp, CompareOp, PopJumpIfFalse/True, LoadGlobal, LoadConst, StoreSubscr, UnaryNegative) - 1 orphan multi-line insert fragment that the rebase had partially removed in the UnaryNegative path - The `if let Some(reg) = variable_reg_map.get(&variable.id).copied()` consumer in the probe's `driver_get_register` closure The probe now uses `graph_regallocs[kind].coloring.get(&v.id)` unconditionally — matching upstream's getcolor exactly. 230 lib tests pass; pyre/check.py dynasm 14/14 + cranelift 14/14 PASS. * codewriter: clarify emitted_pc_starts retirement requires Phase 4 flip Drop the dead `processed_blocks: HashSet` placeholder (declared but never inserted-into or checked; the `let _ = &mut processed_blocks` no-op confirmed it as unreachable scaffolding). Replace the prior "joinpoint shadow paths" rationale with the actual structural diagnosis: pyre's ssarepr emission is INLINE during the walker pass, so cross-block fallthrough relies on PC-contiguous emission order. Upstream `flowcontext.py:407-475`'s per-block recorder works because ssarepr flattening is a SEPARATE later pass (`codewriter.py:44-67 flatten_graph(graph, regallocs)`) which walks the graph DFS and inserts explicit goto links via `flatten.py:148-155 make_link`. Retiring `emitted_pc_starts` therefore requires completing Task #227 Phase 4 (production flip to post-walk flatten emission) — confirmed empirically: enabling `PYRE_TASK_227_5_PER_BLOCK_WALKER=1` makes fannkuch first iteration emit 19288 instead of 8629 because the yielded block's ssarepr stream ends without an explicit goto and the assembler routes its fallthrough to whichever block lands next in walker-pop order. * flatten: port enforce_input_args + generate_ssa_form as GraphFlattener methods Match upstream `rpython/jit/codewriter/flatten.py:88-104` line-by-line: add `enforce_input_args` and `generate_ssa_form` as methods on `GraphFlattener`. Upstream stores `graph` / `regallocs` as `self.graph` / `self.regallocs` fields; pyre threads them as method parameters because the walker computes regallocs externally (retired by Task #227 Phase 4 endgame). `flatten_graph` / `flatten_graph_with_regallocs` / `flatten_graph_wi…

Align flatten_graph to pypy #27

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions