WIP: test(lift): A64_PIN_REGS, guest registers in host registers across calls, kept as a game-free experiment apart from the build (measured no-go) #1981

Draft
siantm wants to merge 4 commits from siantm/Longshot:perf/lift-pin-regs into main
Contributor

Summary

An experiment kept for the record, apart from the game's build: nx2/pin_regs.py, a pass over lifted C that makes
every lifted function clang's preserve_none and hands up to 10 guest registers (A64_PIN_REGS) from call to call in
host registers, with a game-free fixture and a write-up. Measured as a no-go on the branch it comes from (342422dd): a
synthetic workload 2-4 % faster at best, within its spread. Nothing of the game's build runs it: the lift does not
import it and nx2/rtgen.py is main's, so a default build lifts and compiles exactly as main (the pinned runtime is
pin_regs.write_rt's, for the fixture only). With the review (futondestroyer, BeanBot): the build integration of the
first commit is taken out again, the pass checks its switches and every file before it writes, A64_PIN_ABI's
a64_run keeps what a call keeps, and the doc no longer carries figures taken over the game's lifted code.

Read first: nx2/pin_regs.py, tests/test_pin_regs.py, docs/dev/reference/pin-regs.md.

Testing

Tested: Windows 11, i7-9700, RTX 4060, llvm-mingw clang 23.1.5 (the Builder's, found through LONGSHOT_MINGW, no
--cc), Python 3.14.7 (the Builder's); game-free checks only, each in a hidden console of its own, through the PC's job
queue, on this branch rebased onto main @ f1f2dc5b:

  • python -I -B tests/test_pin_regs.py on the head (01cd59d8, queue job fb2-1981-2): exit 0, "all passed": the isolation, the switches' values and
    refusals (each in a folder of its own, left as it was), and seeds 1 to 3, any and AAPCS64 callees, O1 and O2, each
    set of pinned registers (x0; x0 sp; x0-x3 x19 x29 x30 sp; ten; ABI four; ABI ten): the same digest plain and pinned
    (e.g. "seed 3, AAPCS64 callees, O2, ABI ten: plain adaef4a828ee7dfb, pinned adaef4a828ee7dfb").
  • The same at the test commit (dfb8e913, the review's cases before their fix, same queue job): exit 1, 26 failed: the
    12 A64_PIN_ABI builds (seeds 1 to 3, O1 and O2, ABI four and ABI ten; e.g. "seed 3, AAPCS64 callees, O2, ABI
    four: plain adaef4a828ee7dfb, pinned a234a6e4ec7a62d6": the lowered SP read again after a site's miss), the gameplay
    HUD wrapper, a setjmp call in a later file and main's locals left on (not refused, or the folder rewritten), five
    A64_PIN_REGS values (31-0, 5-3, 0-, non-ASCII digits) and four A64_PIN_ABI values (0 taken as ABI;
    yes, true, 2 not refused). Its exact builds and the spliced function pass there.
  • The game's build untouched (queue job fb2-1981-1): make_game.lift_key over one fixed made-up exefs and work folder, lift_sources() and
    rtgen.write's a64.h and a64_rt.c, from main @ f1f2dc5b and from this branch (4cd8a394, which differs from the
    head by one line of tests/test_pin_regs.py): the same lift key (8509d8c7a558...), the same 49 lift sources
    (pin_regs.py none of them), the same a64.h and a64_rt.c (sha256 48c4a0f6b44c... and 3baf0ecb3403...). The
    branch's diff against main is docs/dev/reference/pin-regs.md, nx2/pin_regs.py and tests/test_pin_regs.py,
    and no other file names them.
  • python -I -B tests/run_all.py --strict --changed origin/main (3 files changed) on 4cd8a394 (queue job fb2-1981-1;
    the head differs from it by one line of tests/test_pin_regs.py, a FAIL message printed with ascii()): 2 passed
    (test_pin_regs.py, byte_compile_tracked.py), 0 failed, 0 skipped.

Still to test:

  • Linux: python3 -I -B tests/test_pin_regs.py, expecting it to pass (by hand)

Measurements

Verdict: a no-go, kept out of the game's build: a default build is main's (the table), so there is nothing to
measure in play; the only performance figures are the branch's synthetic ones (342422dd, in the doc and Summary), and a
pinned game cannot be built.

Setup: Windows 11, i7-9700; the lift key and the generated runtime computed from each tree through the PC's job queue
(make_game.lift_key over one made-up exefs, rtgen.write)

Before: main @ f1f2dc5b After: this PR @ 4cd8a394
lift key, default build 8509d8c7a558... 8509d8c7a558... (the same)
a64.h, a64_rt.c (sha256) 48c4a0f6b44c..., 3baf0ecb3403... the same

Risks

None for the game: no file the build reads changes, so the lift key and every object key stay main's, and an
installation updated to it translates and compiles nothing again because of it. The pass and its pinned runtime run
only in tests/test_pin_regs.py. Nothing a player keeps (saves, longshot_options.ini, caches) changes.

Checklist

Ready for review

  • One topic, on current main; the title is a Conventional Commit.
  • Tested on my own PC, in the game for a change the game runs, as Testing says.
  • mise run test passes (any failure that also fails on main is named).
  • Measured against main, or Measurements says why there is nothing to measure.
  • No game files, build output or hand-edited generated files; third_party/ untouched; nothing GPL-incompatible.

When it applies

  • A check under tests/ that reads changed source is updated, not weakened.
  • Docs updated.
  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.

Ready to merge

  • Everything in Still to test has run, its results in Tested.
  • Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers").
  • Approved in review, every comment answered.
  • CI passes on the head; on current main, measured again or a comment says why the numbers still hold.
## Summary An experiment kept for the record, apart from the game's build: `nx2/pin_regs.py`, a pass over lifted C that makes every lifted function clang's `preserve_none` and hands up to 10 guest registers (`A64_PIN_REGS`) from call to call in host registers, with a game-free fixture and a write-up. Measured as a no-go on the branch it comes from (342422dd): a synthetic workload 2-4 % faster at best, within its spread. Nothing of the game's build runs it: the lift does not import it and `nx2/rtgen.py` is main's, so a default build lifts and compiles exactly as `main` (the pinned runtime is `pin_regs.write_rt`'s, for the fixture only). With the review (futondestroyer, BeanBot): the build integration of the first commit is taken out again, the pass checks its switches and every file before it writes, `A64_PIN_ABI`'s `a64_run` keeps what a call keeps, and the doc no longer carries figures taken over the game's lifted code. Read first: `nx2/pin_regs.py`, `tests/test_pin_regs.py`, `docs/dev/reference/pin-regs.md`. ## Testing **Tested:** Windows 11, i7-9700, RTX 4060, llvm-mingw clang 23.1.5 (the Builder's, found through `LONGSHOT_MINGW`, no `--cc`), Python 3.14.7 (the Builder's); game-free checks only, each in a hidden console of its own, through the PC's job queue, on this branch rebased onto `main` @ f1f2dc5b: - `python -I -B tests/test_pin_regs.py` on the head (01cd59d8, queue job fb2-1981-2): exit 0, "all passed": the isolation, the switches' values and refusals (each in a folder of its own, left as it was), and seeds 1 to 3, any and AAPCS64 callees, O1 and O2, each set of pinned registers (x0; x0 sp; x0-x3 x19 x29 x30 sp; ten; ABI four; ABI ten): the same digest plain and pinned (e.g. "seed 3, AAPCS64 callees, O2, ABI ten: plain adaef4a828ee7dfb, pinned adaef4a828ee7dfb"). - The same at the test commit (dfb8e913, the review's cases before their fix, same queue job): exit 1, 26 failed: the 12 `A64_PIN_ABI` builds (seeds 1 to 3, O1 and O2, ABI four and ABI ten; e.g. "seed 3, AAPCS64 callees, O2, ABI four: plain adaef4a828ee7dfb, pinned a234a6e4ec7a62d6": the lowered SP read again after a site's miss), the gameplay HUD wrapper, a setjmp call in a later file and main's locals left on (not refused, or the folder rewritten), five `A64_PIN_REGS` values (`31-0`, `5-3`, `0-`, non-ASCII digits) and four `A64_PIN_ABI` values (`0` taken as ABI; `yes`, `true`, `2` not refused). Its exact builds and the spliced function pass there. - The game's build untouched (queue job fb2-1981-1): `make_game.lift_key` over one fixed made-up exefs and work folder, `lift_sources()` and `rtgen.write`'s `a64.h` and `a64_rt.c`, from `main` @ f1f2dc5b and from this branch (4cd8a394, which differs from the head by one line of `tests/test_pin_regs.py`): the same lift key (8509d8c7a558...), the same 49 lift sources (`pin_regs.py` none of them), the same `a64.h` and `a64_rt.c` (sha256 48c4a0f6b44c... and 3baf0ecb3403...). The branch's diff against `main` is `docs/dev/reference/pin-regs.md`, `nx2/pin_regs.py` and `tests/test_pin_regs.py`, and no other file names them. - `python -I -B tests/run_all.py --strict --changed origin/main` (3 files changed) on 4cd8a394 (queue job fb2-1981-1; the head differs from it by one line of `tests/test_pin_regs.py`, a FAIL message printed with `ascii()`): 2 passed (`test_pin_regs.py`, `byte_compile_tracked.py`), 0 failed, 0 skipped. **Still to test:** - Linux: `python3 -I -B tests/test_pin_regs.py`, expecting it to pass (by hand) ## Measurements **Verdict:** a no-go, kept out of the game's build: a default build is `main`'s (the table), so there is nothing to measure in play; the only performance figures are the branch's synthetic ones (342422dd, in the doc and Summary), and a pinned game cannot be built. Setup: Windows 11, i7-9700; the lift key and the generated runtime computed from each tree through the PC's job queue (`make_game.lift_key` over one made-up exefs, `rtgen.write`) | | Before: main @ f1f2dc5b | After: this PR @ 4cd8a394 | |---|---|---| | lift key, default build | 8509d8c7a558... | 8509d8c7a558... (the same) | | `a64.h`, `a64_rt.c` (sha256) | 48c4a0f6b44c..., 3baf0ecb3403... | the same | ## Risks None for the game: no file the build reads changes, so the lift key and every object key stay `main`'s, and an installation updated to it translates and compiles nothing again because of it. The pass and its pinned runtime run only in `tests/test_pin_regs.py`. Nothing a player keeps (saves, `longshot_options.ini`, caches) changes. ## Checklist ### Ready for review - [x] One topic, on current `main`; the title is a Conventional Commit. - [ ] Tested on my own PC, in the game for a change the game runs, as Testing says. - [ ] `mise run test` passes (any failure that also fails on `main` is named). - [x] Measured against `main`, or Measurements says why there is nothing to measure. - [x] No game files, build output or hand-edited generated files; `third_party/` untouched; nothing GPL-incompatible. ### When it applies - [x] A check under `tests/` that reads changed source is updated, not weakened. - [x] Docs updated. - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. ### Ready to merge - [ ] Everything in Still to test has run, its results in Tested. - [ ] Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers"). - [ ] Approved in review, every comment answered. - [ ] CI passes on the head; on current `main`, measured again or a comment says why the numbers still hold.
perf(lift): A64_PIN_REGS, guest registers in host registers across calls (experiment, off: measured no-go)
Some checks failed
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 4s
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
CI / Website build and checks (pull_request) Has been cancelled
Guide screenshots / Guide images and local UI source review (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
Website / Website on Cloudflare (pull_request) Has been cancelled
5b3b49fc3f
nx2/pin_regs.py, a pass over the finished lifted C (after every edit the game's patches make): every lifted function
becomes clang's preserve_none `A64Ret f(Ctx *, <pinned registers>)`, and direct calls, musttail tail calls and
site-cached indirect calls hand up to 10 guest registers on in host registers; the context is written back only at
SVCs, traps, site misses and HLE hooks. A64_PIN_ABI=1 trusts AAPCS64 across calls. nx2/rtgen.py gives the runtime
a64_run(c, f), the host's way into lifted code ((f)(c) without a pinned lift), and the pinned site-call macros behind
A64_PIN; nx2/lifted_c.py finds pinned heads too; nx2/guest_locals.py turns main's default locals off in a pinned lift
(one owner of the registers). Off (A64_PIN_REGS unset, the default) the lifted C is byte for byte main's.

Kept for the record, not for use: on the branch it comes from, a synthetic workload gained 2-4 % at best, within its
spread, and the game's 46 hottest functions grew in every variant (+1.5 % to +12 % instructions at -O2, spills up to
+250 %). The game cannot be built with it on yet: the pass stops at setjmp callers and the host's callers of lifted
functions need a64_run; docs/dev/reference/pin-regs.md has the measurements (labelled as the branch's) and the list.

tests/test_pin_regs.py: register lists, the text pass and its refusals, the generated header, and whole made-up
programs emitted by the real lifter, built plain and pinned (exact and A64_PIN_ABI) at -O1/-O2 and run from the same
states: same context, memory and SVC/hook log. tests/test_lift_cache.py: the switches change the lift key.

From 342422dd on exp/x86-asm-sync (and the later fixes to its local-switch check and lifted_c's scanner).

Assisted-by: Claude Code
Member

Possibly related, for context:

  • PR #1469 WIP: perf(lift): a function's 6 most-used registers and its flags as C locals by default (A64_LOCAL_REGS=6, A64_LOCAL_FLAGS=1) — Earlier guest-register localization experiment; describes patch and lift pitfalls
Possibly related, for context: - PR #1469 WIP: perf(lift): a function's 6 most-used registers and its flags as C locals by default (A64_LOCAL_REGS=6, A64_LOCAL_FLAGS=1) — Earlier guest-register localization experiment; describes patch and lift pitfalls
BeanBot left a comment

Recommendation: Close. The experiment has no demonstrated gameplay gain, cannot build the supported game with pinning on, and invalidates the lifted-object cache with pinning off. Keep the synthetic findings in a docs-only change and leave the experimental ABI out of the production build.

The pass moves selected guest registers into host registers across lifted calls. It adds a second calling convention, runtime dispatch paths, and compiler requirements without giving players a usable improvement.

@fix will do (19)

  1. L1 (its part an edit can do) nx2/rtgen.py:143: Keep the experiment out of the default lift and runtime generator so their output and cache inputs stay stable.
  2. L2 nx2/rtgen.py:123: ABI mode can corrupt SP or x19 on an indirect call. (more on the line)
  3. L3 nx2/lift.py:255: The normal Builder accepts the option and starts translating the supported game, then fails at the known setjmp callers. (more on the line)
  4. L4 nx2/rtgen.py:82: Header discovery alone activates the pinned ABI in every consumer. (more on the line)
  5. L5 nx2/rtgen.py:152: Disabling host lookup sends ordinary NVN calls through a64_call_miss. (more on the line)
  6. L6 nx2/rtgen.py:90: An older Clang can ignore preserve_none while the build and fixture suppress its warning. (more on the line)
  7. L7 nx2/pin_regs.py:76: The parser materializes a range before checking its endpoints. (more on the line)
  8. L8 nx2/pin_regs.py:199: The pass rewrites chunks before validating later ones. (more on the line)
  9. L9 (minor) nx2/pin_regs.py:84: A64_PIN_ABI=0 selects ABI mode and drops exact return state. (more on the line)
  10. L10 tests/test_pin_regs.py:151: The conflicting-switch check points the mutating pass at the system temporary directory. (more on the line)
  11. L11 (minor) tests/test_pin_regs.py:40: The suite forces --cc clang, bypassing the script's CC and LONGSHOT_MINGW selection. (more on the line)
  12. L12 (minor) tests/test_pin_regs.py:325: The test inherits lift settings outside the four variables cleared by env(). (more on the line)
  13. L13 (minor) tests/test_pin_regs.py:398: The off comparison applies pin_dir to output that was already emitted without importing guest_locals or using lift.py. (more on the line)
  14. L14 (minor) tests/test_lift_cache.py:51: Both cases compare to the unpinned key, so the ABI case still passes if the key ignores A64_PIN_ABI. (more on the line)
  15. L15 docs/dev/reference/pin-regs.md:94: The hot-function tables are sampled outputs from compiled game code, and the following paragraph includes a game trace. (more on the line)
  16. L16 (minor) docs/dev/reference/pin-regs.md:65: The measurement setup says every build used exact mode, but both timing tables include ABI variants. (more on the line)
  17. L17 (minor): The Measurements table compares a missing module on an older main with successful fixture execution. That establishes that the experiment exists. Put those results in Testing and report the missing merge-base performance comparison in Measurements. The Risks section also needs to account for lift and object cache invalidation while pinning is off.
  18. L18 (its part an edit can do) docs/dev/reference/build.md:70: Remove the production build integration and switch entries. Keep a compliant record of the synthetic experiment.
  19. L19 (its part an edit can do): A docs-only change removes the game-run requirement. For another experiment, isolate the pinning harness until the host ABI works end to end.

For the author (3) (a run, a measurement or a decision)

  • L1 nx2/rtgen.py:143: With pinning unset, an update from main still discards reuse of every lifted object. (more on the line)
  • L18 docs/dev/reference/build.md:70: The production build carries an opt-in ABI whose reported gain is within noise and whose enabled mode cannot build the game. (more on the line)
  • L19 (minor): The game-run requirement remains open. If production integration remains, verify the default build and gameplay on the head on Windows and Linux, including affected Tier 1 systems. A future playable pinned variant needs interleaved same-scene runs against its merge base, with frame times and lows as well as build time and size.

Checks: Still running: CI / Conventional Commit title (pull_request), CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request), CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request), CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request), CI / Workflow lint (actionlint) (pull_request), CI / Website build and checks (pull_request), Guide screenshots / Guide images and local UI source review (pull_request), Third-party parts / As their notes say (pull_request), Third-party parts / The same as upstream (pull_request), Website / Website on Cloudflare (pull_request).

More: does it help, other systems, switches, what was read

Does it help: Unproven on this PR. On predecessor 342422dd, the best synthetic timings were roughly 2–4% faster within run-to-run spread. Exact ten-register pinning was 12.9% slower in the hot synthetic run. Windows digest matches on the earlier PR head establish equivalence for the exercised fixtures. There are no comparable gameplay or build timings against 6e1521a70a.

Other systems: Both Windows and Linux rebuild cached lifted objects after the generated header changes. Pinning would also affect NVN host dispatch, guest thread state and crash diagnostics, the emulator DLL ABI, and Linux Tracy instrumentation. The renderer interface, shader formats, save code, audio, and input code are outside the diff. No Tier 1 gameplay run was reported, including on Steam Deck.

Switches: A64_PIN_REGS is unset by default. A64_PIN_ABI is unset for exact mode, but any nonempty value currently enables ABI mode, including 0. A nonblank register list changes the defaults of A64_LOCAL_REGS from six to zero and A64_LOCAL_FLAGS from on to off. Leaving pinning unset is the only usable game default. These are lift-time options documented in the build table and covered by the lift key's A64_ prefix. They do not belong in the game's runtime switch table.

Reviewed: 5b3b49fc3f against 6e1521a70a: Read all nine changed files in full and revisited each. Read AGENTS.md, CONTRIBUTING.md, the standards, the Forgejo template, and the commit message and trailers. No local review checklist or adjacent Tooling checkout was present. Read relevant sections of the build, cache, chunking, emitter, runtime, host, profiling, test runner, and CI code. Two unrelated recorded-run sets and the rest of the unchanged tree were outside the review. No translations or generated files changed.; nothing run (a code review).

Checked and fine:

  • Both lift-time names are included by the existing A64_ cache-key rule, and the lift source walk includes pin_regs.py.
  • The scanner recognizes the existing plain definition format and the pinned format for both text and byte input.
  • The pinned inline site cache reads its packed target and offset atomically, matching the runtime's packed atomic writes.
  • The pin pass waits for the table generation to finish before rewriting the output.
  • The required Assisted-by trailer is present. Third-party code, shader sources and generated headers, and the renderer API version were untouched.

Testing: Read-only review. git diff --check was clean. The author reports passing Windows synthetic digests on the earlier rebased head. Seven named failures were reproduced on its base, and one check skipped. Exact-head CI was pending. Linux fixture execution and in-game testing were unverified.

Overlaps and merge order: No overlapping open pull request was identified in the supplied review data or local refs. The merged giant-splitting work in #1727 shares the calling-convention technique and is already in the base.


Automated code review by BeanBot (gpt-6.2-sol), on the pull request's opening. Nothing was run; a maintainer decides.

**Recommendation: Close.** The experiment has no demonstrated gameplay gain, cannot build the supported game with pinning on, and invalidates the lifted-object cache with pinning off. Keep the synthetic findings in a docs-only change and leave the experimental ABI out of the production build. The pass moves selected guest registers into host registers across lifted calls. It adds a second calling convention, runtime dispatch paths, and compiler requirements without giving players a usable improvement. **`@fix` will do (19)** 1. **L1** (its part an edit can do) `nx2/rtgen.py:143`: Keep the experiment out of the default lift and runtime generator so their output and cache inputs stay stable. 2. **L2** `nx2/rtgen.py:123`: ABI mode can corrupt SP or x19 on an indirect call. (more on the line) 3. **L3** `nx2/lift.py:255`: The normal Builder accepts the option and starts translating the supported game, then fails at the known setjmp callers. (more on the line) 4. **L4** `nx2/rtgen.py:82`: Header discovery alone activates the pinned ABI in every consumer. (more on the line) 5. **L5** `nx2/rtgen.py:152`: Disabling host lookup sends ordinary NVN calls through `a64_call_miss`. (more on the line) 6. **L6** `nx2/rtgen.py:90`: An older Clang can ignore `preserve_none` while the build and fixture suppress its warning. (more on the line) 7. **L7** `nx2/pin_regs.py:76`: The parser materializes a range before checking its endpoints. (more on the line) 8. **L8** `nx2/pin_regs.py:199`: The pass rewrites chunks before validating later ones. (more on the line) 9. **L9** (minor) `nx2/pin_regs.py:84`: `A64_PIN_ABI=0` selects ABI mode and drops exact return state. (more on the line) 10. **L10** `tests/test_pin_regs.py:151`: The conflicting-switch check points the mutating pass at the system temporary directory. (more on the line) 11. **L11** (minor) `tests/test_pin_regs.py:40`: The suite forces `--cc clang`, bypassing the script's `CC` and `LONGSHOT_MINGW` selection. (more on the line) 12. **L12** (minor) `tests/test_pin_regs.py:325`: The test inherits lift settings outside the four variables cleared by `env()`. (more on the line) 13. **L13** (minor) `tests/test_pin_regs.py:398`: The off comparison applies `pin_dir` to output that was already emitted without importing `guest_locals` or using `lift.py`. (more on the line) 14. **L14** (minor) `tests/test_lift_cache.py:51`: Both cases compare to the unpinned key, so the ABI case still passes if the key ignores `A64_PIN_ABI`. (more on the line) 15. **L15** `docs/dev/reference/pin-regs.md:94`: The hot-function tables are sampled outputs from compiled game code, and the following paragraph includes a game trace. (more on the line) 16. **L16** (minor) `docs/dev/reference/pin-regs.md:65`: The measurement setup says every build used exact mode, but both timing tables include ABI variants. (more on the line) 17. **L17** (minor): The Measurements table compares a missing module on an older main with successful fixture execution. That establishes that the experiment exists. Put those results in Testing and report the missing merge-base performance comparison in Measurements. The Risks section also needs to account for lift and object cache invalidation while pinning is off. 18. **L18** (its part an edit can do) `docs/dev/reference/build.md:70`: Remove the production build integration and switch entries. Keep a compliant record of the synthetic experiment. 19. **L19** (its part an edit can do): A docs-only change removes the game-run requirement. For another experiment, isolate the pinning harness until the host ABI works end to end. **For the author (3)** (a run, a measurement or a decision) - **L1** `nx2/rtgen.py:143`: With pinning unset, an update from main still discards reuse of every lifted object. (more on the line) - **L18** `docs/dev/reference/build.md:70`: The production build carries an opt-in ABI whose reported gain is within noise and whose enabled mode cannot build the game. (more on the line) - **L19** (minor): The game-run requirement remains open. If production integration remains, verify the default build and gameplay on the head on Windows and Linux, including affected Tier 1 systems. A future playable pinned variant needs interleaved same-scene runs against its merge base, with frame times and lows as well as build time and size. **Checks:** Still running: `CI / Conventional Commit title (pull_request)`, `CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request)`, `CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request)`, `CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request)`, `CI / Workflow lint (actionlint) (pull_request)`, `CI / Website build and checks (pull_request)`, `Guide screenshots / Guide images and local UI source review (pull_request)`, `Third-party parts / As their notes say (pull_request)`, `Third-party parts / The same as upstream (pull_request)`, `Website / Website on Cloudflare (pull_request)`. <details> <summary>More: does it help, other systems, switches, what was read</summary> **Does it help:** Unproven on this PR. On predecessor 342422dd, the best synthetic timings were roughly 2–4% faster within run-to-run spread. Exact ten-register pinning was 12.9% slower in the hot synthetic run. Windows digest matches on the earlier PR head establish equivalence for the exercised fixtures. There are no comparable gameplay or build timings against 6e1521a70a32. **Other systems:** Both Windows and Linux rebuild cached lifted objects after the generated header changes. Pinning would also affect NVN host dispatch, guest thread state and crash diagnostics, the emulator DLL ABI, and Linux Tracy instrumentation. The renderer interface, shader formats, save code, audio, and input code are outside the diff. No Tier 1 gameplay run was reported, including on Steam Deck. **Switches:** A64_PIN_REGS is unset by default. A64_PIN_ABI is unset for exact mode, but any nonempty value currently enables ABI mode, including 0. A nonblank register list changes the defaults of A64_LOCAL_REGS from six to zero and A64_LOCAL_FLAGS from on to off. Leaving pinning unset is the only usable game default. These are lift-time options documented in the build table and covered by the lift key's A64_ prefix. They do not belong in the game's runtime switch table. **Reviewed:** 5b3b49fc3f6c against 6e1521a70a32: Read all nine changed files in full and revisited each. Read AGENTS.md, CONTRIBUTING.md, the standards, the Forgejo template, and the commit message and trailers. No local review checklist or adjacent Tooling checkout was present. Read relevant sections of the build, cache, chunking, emitter, runtime, host, profiling, test runner, and CI code. Two unrelated recorded-run sets and the rest of the unchanged tree were outside the review. No translations or generated files changed.; nothing run (a code review). **Checked and fine:** - Both lift-time names are included by the existing A64_ cache-key rule, and the lift source walk includes pin_regs.py. - The scanner recognizes the existing plain definition format and the pinned format for both text and byte input. - The pinned inline site cache reads its packed target and offset atomically, matching the runtime's packed atomic writes. - The pin pass waits for the table generation to finish before rewriting the output. - The required Assisted-by trailer is present. Third-party code, shader sources and generated headers, and the renderer API version were untouched. **Testing:** Read-only review. `git diff --check` was clean. The author reports passing Windows synthetic digests on the earlier rebased head. Seven named failures were reproduced on its base, and one check skipped. Exact-head CI was pending. Linux fixture execution and in-game testing were unverified. **Overlaps and merge order:** No overlapping open pull request was identified in the supplied review data or local refs. The merged giant-splitting work in #1727 shares the calling-convention technique and is already in the base. </details> --- <sub>Automated code review by BeanBot (gpt-6.2-sol), on the pull request's opening. Nothing was run; a maintainer decides.</sub>
@ -67,6 +67,7 @@ Read by the build, not the game, so they are not in `switches.def`.
| `LONGSHOT_THIRD_PARTY_OBJECTS=0` or `<dir>` | The prebuilt third-party objects a release ships (`0`: compile them) |
| `LONGSHOT_TRACY=1` | A Tracy build ([profiling](profiling.md#tracy)) |
| `LONGSHOT_NGX_SDK=<dir>`, `LONGSHOT_FSR=1` | Build with NVIDIA DLSS, AMD FSR 4 ([setup](../setup.md#upscaler-sdks-optional)) |
| `A64_PIN_REGS=<regs>`, `A64_PIN_ABI=1` | An experiment, off, measured as a no-go: lifted functions take the context and up to 10 guest registers (`0,31`, `0-7,30,31`: numbers, ranges, `sp`) in host registers, clang's `preserve_none`, and hand them on in calls and tail calls (`nx2/pin_regs.py`, a pass after the lift's last edit; [pinned registers](pin-regs.md)). It turns the default locals off. The game cannot be built with it yet ([what it still needs](pin-regs.md#what-a-full-integration-still-needs)). Off, the lifted C is byte for byte as before. Lift-time switches: they change the lift key |
Member

L18: The production build carries an opt-in ABI whose reported gain is within noise and whose enabled mode cannot build the game. It also bypasses pinned hot-call grouping and giant splitting, and the Linux Tracy wrappers still assume the plain signature. Preserve the findings without enrolling the production lifter and runtime in the experiment.

**L18**: The production build carries an opt-in ABI whose reported gain is within noise and whose enabled mode cannot build the game. It also bypasses pinned hot-call grouping and giant splitting, and the Linux Tracy wrappers still assume the plain signature. Preserve the findings without enrolling the production lifter and runtime in the experiment.
@ -0,0 +62,4 @@
These are the measurements of the branch this comes from (exp/x86-asm-sync, 342422dd), not repeated on main; that branch
had no locals by default then, and `A64_LOCAL_REGS` below is its earlier hot-list form. 2026-11-17, Windows, clang
22.1.8 (`--target=x86_64-w64-windows-gnu -march=native`, the build's lifted-code flags), another PC (RX 9070 XT), no
game run. Every build below is exact: against Unicorn on a synthetic workload (`work/lift-probe`, a scratch harness not
Member

L16 (minor): The measurement setup says every build used exact mode, but both timing tables include ABI variants. It also says the experiment is kept so the measurements can be repeated, while the measured harnesses are absent. Label the variant contracts accurately and identify which results the committed fixture can reproduce.

**L16** (minor): The measurement setup says every build used exact mode, but both timing tables include ABI variants. It also says the experiment is kept so the measurements can be repeated, while the measured harnesses are absent. Label the variant contracts accurately and identify which results the committed fixture can reproduce.
@ -0,0 +91,4 @@
pinning live guest registers gives part of it back: every one a function keeps live across a call is spilled
(`preserve_none` preserves nothing), and Win64 returns the second register through memory.
The game's 46 hottest functions under 150 KB of C (the head of `hot_funcs.txt`, 2.8 MB of real lifted C copied out of
Member

L15: The hot-function tables are sampled outputs from compiled game code, and the following paragraph includes a game trace. The repository rule covers these derived outputs. Remove them and the corresponding derived figures from the commit message. Keep the synthetic results and use an authored fixture for instruction and spill comparisons.

**L15**: The hot-function tables are sampled outputs from compiled game code, and the following paragraph includes a game trace. The repository rule covers these derived outputs. Remove them and the corresponding derived figures from the commit message. Keep the synthetic results and use an authored fixture for instruction and spill comparisons.
nx2/lift.py Outdated
@ -251,6 +252,11 @@ def main():
L.stats["locals_kept_for_patches"], local_regs.check_patched(gen)))
took("locals check")
print("\n".join(chunks.end_side(side, tables)), flush=True)
pinned = pin_regs.pin_dir(gen) # (A64_PIN_REGS: after the last edit of the C, whose patches anchor on its plain text)
Member

L3: The normal Builder accepts the option and starts translating the supported game, then fails at the known setjmp callers. Removing that refusal alone still leaves direct host calls such as host/oot_voice.c:61 using the old signature. Keep the option in the standalone fixture or reject it at the build entry before translating. Exposing it for play requires both setjmp handling and host caller conversion.

**L3**: The normal Builder accepts the option and starts translating the supported game, then fails at the known setjmp callers. Removing that refusal alone still leaves direct host calls such as `host/oot_voice.c:61` using the old signature. Keep the option in the standalone fixture or reject it at the build entry before translating. Exposing it for play requires both setjmp handling and host caller conversion.
nx2/pin_regs.py Outdated
@ -0,0 +73,4 @@
lo, _, hi = part.lower().replace("sp", "31").replace("x", "").partition("-")
if not lo.isdigit() or (hi and not hi.isdigit()):
raise SystemExit("A64_PIN_REGS=%s: registers are numbers, ranges or sp (0-7,29-31)" % v)
out += range(int(lo), int(hi or lo) + 1)
Member

L7: The parser materializes a range before checking its endpoints. 0-1000000000 attempts a huge allocation. A reversed range such as 31-0 gives an empty pin set while its nonblank value still disables the usual locals. Validate ASCII endpoints and ascending order before expansion, and use the parsed mode for the locals defaults.

**L7**: The parser materializes a range before checking its endpoints. `0-1000000000` attempts a huge allocation. A reversed range such as `31-0` gives an empty pin set while its nonblank value still disables the usual locals. Validate ASCII endpoints and ascending order before expansion, and use the parsed mode for the locals defaults.
nx2/pin_regs.py Outdated
@ -0,0 +81,4 @@
def abi():
return bool(os.environ.get("A64_PIN_ABI"))
Member

L9 (minor): A64_PIN_ABI=0 selects ABI mode and drops exact return state. Parse the documented 1 explicitly and test that 0 selects exact mode.

**L9** (minor): `A64_PIN_ABI=0` selects ABI mode and drops exact return state. Parse the documented `1` explicitly and test that `0` selects exact mode.
nx2/pin_regs.py Outdated
@ -0,0 +196,4 @@
p = os.path.join(gen, name)
with open(p, encoding="utf-8") as f:
s = f.read()
t = pin_file(s, pins, stats)
Member

L8: The pass rewrites chunks before validating later ones. A setjmp wrapper in a later chunk leaves the table and early chunks pinned and later chunks plain. A direct lift.py run also can leave the previous pin header behind. Validate the input before modifying it and stage a complete output set before publishing it.

**L8**: The pass rewrites chunks before validating later ones. A setjmp wrapper in a later chunk leaves the table and early chunks pinned and later chunks plain. A direct `lift.py` run also can leave the previous pin header behind. Validate the input before modifying it and stage a complete output set before publishing it.
nx2/rtgen.py Outdated
@ -78,0 +79,4 @@
# to its C when it pins, and nothing changes without one. a64_run is how the host's void f(Ctx *) world calls a lifted
# function either way.
A64FN = "typedef void (*A64Fn)(Ctx *A64_NOESC);"
PIN_FN = r"""#if defined(__has_include)
Member

L4: Header discovery alone activates the pinned ABI in every consumer. A pinned DLL that gets through the lift can return a pinned entry from mkw_recomp_lookup, which the emulator calls using the old one-argument MkwFn. Its A64_POLL_CTX callback also lacks register synchronization. Gate pinning explicitly and reject pinned DLL builds unless the exported ABI and poll boundary are adapted together.

**L4**: Header discovery alone activates the pinned ABI in every consumer. A pinned DLL that gets through the lift can return a pinned entry from `mkw_recomp_lookup`, which the emulator calls using the old one-argument `MkwFn`. Its `A64_POLL_CTX` callback also lacks register synchronization. Gate pinning explicitly and reject pinned DLL builds unless the exported ABI and poll boundary are adapted together.
nx2/rtgen.py Outdated
@ -78,0 +87,4 @@
#ifdef A64_PIN
/* (nx2/pin_regs.py) clang's preserve_none: the context and up to 11 guest registers in host registers. musttail needs the
one signature everywhere; the pinned registers are the caller's xN_ (A64_PIN_ARGS) */
#define A64_PFN __attribute__((preserve_none))
Member

L6: An older Clang can ignore preserve_none while the build and fixture suppress its warning. Equality can then pass without exercising the intended convention, or a different compiler can reject the indirect tail call. Require the attributes and probe a representative indirect musttail with the selected compiler and target before starting a pinned build. Run the compiled check with a capable compiler on both CI platforms.

**L6**: An older Clang can ignore `preserve_none` while the build and fixture suppress its warning. Equality can then pass without exercising the intended convention, or a different compiler can reject the indirect tail call. Require the attributes and probe a representative indirect `musttail` with the selected compiler and target before starting a pinned build. Run the compiled check with a capable compiler on both CI platforms.
nx2/rtgen.py Outdated
@ -78,0 +120,4 @@
const int a64_site_hit_ = __builtin_expect(a64_site_e_ >> 32 == a64_site_t_ && a64_site_e_ != 0, 1)
#define A64_PIN_SITE_FN ((A64Fn)((intptr_t)&a64_lookup + (int32_t)(uint32_t)a64_site_e_))
#define A64_ICALL(c, t) do { A64_PIN_SITE(t); if (a64_site_hit_) A64_PCALL(A64_PIN_SITE_FN); \
else { A64_PIN_STORE(c); a64_icall_site(c, a64_site_t_, a64_site_); A64_PIN_LOAD(c); } } while (0)
Member

L2: ABI mode can corrupt SP or x19 on an indirect call. A conforming callee can allocate a stack frame, issue an SVC that publishes the lowered SP, then restore its pinned SP before returning. The ABI return leaves the lowered SP in the context, and the cold or second-slot path reloads it into the caller. The first-slot hit keeps the correct caller SP. Preserve callee-saved pins across the slow guest-call path and restore them at the host entry boundary. Exercise both cache paths with an SVC inside the callee's frame.

**L2**: ABI mode can corrupt SP or x19 on an indirect call. A conforming callee can allocate a stack frame, issue an SVC that publishes the lowered SP, then restore its pinned SP before returning. The ABI return leaves the lowered SP in the context, and the cold or second-slot path reloads it into the caller. The first-slot hit keeps the correct caller SP. Preserve callee-saved pins across the slow guest-call path and restore them at the host entry boundary. Exercise both cache paths with an SVC inside the callee's frame.
nx2/rtgen.py Outdated
@ -82,11 +140,16 @@ SUBST = {
(RET_MISMATCH, RET_MISMATCH + POLL_DECL),
("#define A64_PTR(a) (A64_MEM + (uint32_t)(a))", ADDR64),
(MARK_NATIVE, MARK_NATIVE_64),
(A64FN, PIN_FN),
Member

L1: With pinning unset, an update from main still discards reuse of every lifted object. build.py hashes the full generated a64.h into every lifted object's key. The lifter source key also moves, so the updater repeats translation even if the chunks come out identical. Time a warm update from the merge base with pinning unset.

**L1**: With pinning unset, an update from main still discards reuse of every lifted object. `build.py` hashes the full generated `a64.h` into every lifted object's key. The lifter source key also moves, so the updater repeats translation even if the chunks come out identical. Time a warm update from the merge base with pinning unset.
nx2/rtgen.py Outdated
@ -89,1 +149,4 @@
("uint8_t a64_dirty[1u << 20];", "uint8_t a64_dirty[A64_DIRTY_PAGES];"),
(RT_CALL, " a64_run(c, f);\n}", 3), # (a64_icall, a64_ijump, site_call)
(RT_SITE2, "a64_run(c, ((A64Fn)((intptr_t)&a64_lookup + (int32_t)(uint32_t)e)));"),
(RT_HOST, "#ifdef A64_PIN\n A64Fn h = NULL;\n#else\n" + RT_HOST + "\n#endif"),
Member

L5: Disabling host lookup sends ordinary NVN calls through a64_call_miss. Two recording threads entering that path can concurrently initialize the plain static int stats in host/hos_hostcall.c:92, even with profiling disabled. Keep the normal fast path through compatible thunks or leave pinned host dispatch disabled. If the slow path is used, synchronize its one-time initialization and host-slot publication.

**L5**: Disabling host lookup sends ordinary NVN calls through `a64_call_miss`. Two recording threads entering that path can concurrently initialize the plain `static int stats` in `host/hos_hostcall.c:92`, even with profiling disabled. Keep the normal fast path through compatible thunks or leave pinned host dispatch disabled. If the slow path is used, synchronize its one-time initialization and host-slot publication.
@ -48,6 +48,11 @@ def main():
check("another lift setting changes the key", make_game.lift_key(str(exefs), str(work), dict(env, A64_HOT_CHUNK="")) != key)
with mock.patch.dict(os.environ, {"A64_KEEP_FLAGS": "1"}):
check("a lifter switch in the environment changes the key", make_game.lift_key(str(exefs), str(work), env) != key)
for pin in ({"A64_PIN_REGS": "0,31"}, {"A64_PIN_REGS": "0,31", "A64_PIN_ABI": "1"}): # (nx2/pin_regs.py: lifts again)
Member

L14 (minor): Both cases compare to the unpinned key, so the ABI case still passes if the key ignores A64_PIN_ABI. Compare exact and ABI keys with the same pinned register list.

**L14** (minor): Both cases compare to the unpinned key, so the ABI case still passes if the key ignores `A64_PIN_ABI`. Compare exact and ABI keys with the same pinned register list.
@ -0,0 +37,4 @@
import kit # noqa: E402,F401 (a64-kit on the path)
import pin_regs # noqa: E402
RUN_ALL_ARGS = ["--cc", "clang"]
Member

L11 (minor): The suite forces --cc clang, bypassing the script's CC and LONGSHOT_MINGW selection. A Windows setup with bundled llvm-mingw and no clang on PATH skips or fails before that selection runs. Resolve the compiler consistently in the runner and test, honoring explicit selection and using the configured native toolchain.

**L11** (minor): The suite forces `--cc clang`, bypassing the script's `CC` and `LONGSHOT_MINGW` selection. A Windows setup with bundled llvm-mingw and no `clang` on PATH skips or fails before that selection runs. Resolve the compiler consistently in the runner and test, honoring explicit selection and using the configured native toolchain.
@ -0,0 +148,4 @@
pass
with env(A64_PIN_REGS="0", A64_LOCAL_REGS="4"):
try:
pin_regs.pin_dir(tempfile.gettempdir())
Member

L10: The conflicting-switch check points the mutating pass at the system temporary directory. If the guard regresses, the test can write a64_pin.h there and rewrite matching C files owned by another run. Give the negative test its own temporary directory and verify refusal leaves it untouched.

**L10**: The conflicting-switch check points the mutating pass at the system temporary directory. If the guard regresses, the test can write `a64_pin.h` there and rewrite matching C files owned by another run. Give the negative test its own temporary directory and verify refusal leaves it untouched.
@ -0,0 +322,4 @@
import poll
poll.install()
words, texts = made_up_program(random.Random(seed), 40, conforming)
L = a64_lift.Lifter(_Image(words, (MAIN, CALLEE, JUMPER, TAIL, VIRT, VIRT + 0x100, VIRT + 0x200), {HOOK: "hos_test_hook"}))
Member

L12 (minor): The test inherits lift settings outside the four variables cleared by env(). A stale A64_DEVIRT file path can fail fixture construction, and A64_HOT_FUNCS or A64_KEEP_FLAGS can change the lift. Clear lift and runtime switches before constructing the lifter and pass a controlled environment to the generated executable.

**L12** (minor): The test inherits lift settings outside the four variables cleared by `env()`. A stale `A64_DEVIRT` file path can fail fixture construction, and `A64_HOT_FUNCS` or `A64_KEEP_FLAGS` can change the lift. Clear lift and runtime switches before constructing the lifter and pass a controlled environment to the generated executable.
@ -0,0 +395,4 @@
check({"bl", "blr", "br", "svc", "ret", "b", "cbz"} <= kinds, "the program has every transfer: %s" % sorted(kinds))
plain = {name: open(os.path.join(gen, name), "rb").read() for name in os.listdir(gen)}
with env():
pin_regs.pin_dir(gen)
Member

L13 (minor): The off comparison applies pin_dir to output that was already emitted without importing guest_locals or using lift.py. It would pass if the change accidentally disabled normal locals in every build. Add a game-free fixture through the production option and emission path that checks the ordinary register and flag locals with pinning off and their absence with it on. Compile and run a context-based body from the real entry-hook splice as well, since it is currently checked only by string matches.

**L13** (minor): The off comparison applies `pin_dir` to output that was already emitted without importing `guest_locals` or using `lift.py`. It would pass if the change accidentally disabled normal locals in every build. Add a game-free fixture through the production option and emission path that checks the ordinary register and flag locals with pinning off and their absence with it on. Compile and run a context-based body from the real entry-hook splice as well, since it is currently checked only by string matches.
Author
Contributor

Description: removed a statement about the game's hottest lifted functions (a figure taken over the game's lifted code, which the contributing rules ask to leave out) and the pointer to the doc's list; nothing else changed.

Description: removed a statement about the game's hottest lifted functions (a figure taken over the game's lifted code, which the contributing rules ask to leave out) and the pointer to the doc's list; nothing else changed.
futondestroyer left a comment

Recommendation: Close. Keep a short record of the synthetic experiment. The enabled build cannot translate the supported game, and shipping the code off still makes existing installations translate and compile lifted code again.

Does it help? No measured improvement supports merging. On the earlier 342422dd experiment, the best synthetic timing gains were about 2–4%, within the reported spread. Exact ten-register pinning was 12.9% slower in the hot synthetic case. The current head has no gameplay or update-time comparison with 6e1521a7. Matching synthetic digests on the earlier rebased head exercise the chosen call patterns. Existing review

Even after setjmp support and the direct host calls are addressed, the gameplay HUD wrapper still breaks the pinned build. The source rewrite treats its separately named callback as part of the preceding lifted function. It inserts pinned return or transfer macros into a helper without pinned parameters, leaves that helper incompatible with A64Fn, and makes the wrapper return no A64Ret value. An isolated synthetic follow-up should cover the wrapper and callback as separate functions. Source

Other systems and defaults. A64_PIN_REGS is unset and A64_PIN_ABI defaults to exact mode. Enabling pinning disables the default guest register and flag locals. The enabled path spans Windows and Linux compiler conventions, standalone guest thread entry, host dispatch, and the emulator DLL's callback and poll boundaries. With pinning unset, the ordinary call still invokes f(c), but the production header and lifter inputs change, so existing object and translation keys move. A docs-only record should contain authored synthetic results and omit game-derived measurements from both the proposed text and its commit message. Default build cost · Documentation review

Testing. The author reports Windows synthetic checks on 0b62ed8b and seven focused failures reproduced on that head's base, with one check skipped. The description check passed on 5b3b49fc. The source checks were blocked by required conditions, and Beanstalk showed no plan, targets, or reports. The enabled game is blocked at translation, so a farm run of the default build would leave the performance hypothesis unanswered. Checks · Beanstalk

Overlap. The poll convention experiment shares the runtime generator, and compare fusion shares the lift and guest-local defaults. The synthetic writeup needs no source merge order. Poll convention · Compare fusion

Reviewed 5b3b49fc against 6e1521a7. Read all nine changed files and traced the lift, runtime dispatch, Windows and Linux build paths, host and emulator entry points, and translation/object reuse with revision-matched Graphify maps and source. Source review only. No PR code was run.

**Recommendation: Close.** Keep a short record of the synthetic experiment. The enabled build cannot translate the supported game, and shipping the code off still makes existing installations translate and compile lifted code again. **Does it help?** No measured improvement supports merging. On the earlier `342422dd` experiment, the best synthetic timing gains were about 2–4%, within the reported spread. Exact ten-register pinning was 12.9% slower in the hot synthetic case. The current head has no gameplay or update-time comparison with `6e1521a7`. Matching synthetic digests on the earlier rebased head exercise the chosen call patterns. [Existing review](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62577) Even after setjmp support and the direct host calls are addressed, the gameplay HUD wrapper still breaks the pinned build. The source rewrite treats its separately named callback as part of the preceding lifted function. It inserts pinned return or transfer macros into a helper without pinned parameters, leaves that helper incompatible with `A64Fn`, and makes the wrapper return no `A64Ret` value. An isolated synthetic follow-up should cover the wrapper and callback as separate functions. [Source](https://git.magicbean.dev/MagicBeanDev/Longshot/src/commit/5b3b49fc3f6ce320333f46be8b8fb8d6430646b0/nx2/pin_regs.py#L172) **Other systems and defaults.** `A64_PIN_REGS` is unset and `A64_PIN_ABI` defaults to exact mode. Enabling pinning disables the default guest register and flag locals. The enabled path spans Windows and Linux compiler conventions, standalone guest thread entry, host dispatch, and the emulator DLL's callback and poll boundaries. With pinning unset, the ordinary call still invokes `f(c)`, but the production header and lifter inputs change, so existing object and translation keys move. A docs-only record should contain authored synthetic results and omit game-derived measurements from both the proposed text and its commit message. [Default build cost](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62560) · [Documentation review](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62574) **Testing.** The author reports Windows synthetic checks on `0b62ed8b` and seven focused failures reproduced on that head's base, with one check skipped. The description check passed on `5b3b49fc`. The source checks were blocked by required conditions, and Beanstalk showed no plan, targets, or reports. The enabled game is blocked at translation, so a farm run of the default build would leave the performance hypothesis unanswered. [Checks](https://git.magicbean.dev/MagicBeanDev/Longshot/actions/runs/44459) · [Beanstalk](https://beanstalk.magicbean.dev/prs/1981) **Overlap.** The poll convention experiment shares the runtime generator, and compare fusion shares the lift and guest-local defaults. The synthetic writeup needs no source merge order. [Poll convention](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1985) · [Compare fusion](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1980) **Reviewed** `5b3b49fc` against `6e1521a7`. Read all nine changed files and traced the lift, runtime dispatch, Windows and Linux build paths, host and emulator entry points, and translation/object reuse with revision-matched Graphify maps and source. Source review only. No PR code was run.
nx2/pin_regs.py Outdated
@ -0,0 +169,4 @@
raise SystemExit("A64_PIN_REGS: a call of a setjmp owner: its host setjmp frame would come back with stale "
"pinned registers (docs/dev/reference/pin-regs.md)")
s = HOOK.sub(PIN_HOOK, DECL.sub(PIN_DECL, s))
starts = [m.start() for m in HEAD.finditer(s)]
Member

The gameplay HUD patch (nx2/oot_patches.py:312) inserts a plain gameplay_hud_update_game(Ctx *) definition before the next f_... head. This slice includes both bodies. pin_function rewrites the helper's returns and transfers to macros that need the wrapper's pinned parameters, and leaves the wrapper itself falling through without an A64Ret value. The plain helper pointer also cannot satisfy pinned A64Fn, even after host/hos_wide_ui.c migrates its callers. Keep the experiment isolated, or handle the wrapper and named helper as separate functions with explicit signatures and returns.

The gameplay HUD patch (`nx2/oot_patches.py:312`) inserts a plain `gameplay_hud_update_game(Ctx *)` definition before the next `f_...` head. This slice includes both bodies. `pin_function` rewrites the helper's returns and transfers to macros that need the wrapper's pinned parameters, and leaves the wrapper itself falling through without an `A64Ret` value. The plain helper pointer also cannot satisfy pinned `A64Fn`, even after `host/hos_wide_ui.c` migrates its callers. Keep the experiment isolated, or handle the wrapper and named helper as separate functions with explicit signatures and returns.
siantm force-pushed perf/lift-pin-regs from 5b3b49fc3f
Some checks failed
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 4s
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
CI / Website build and checks (pull_request) Has been cancelled
Guide screenshots / Guide images and local UI source review (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
Website / Website on Cloudflare (pull_request) Has been cancelled
to 01cd59d894
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
CI / Website build and checks (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 5s
2026-11-21 04:05:43 +00:00
Compare
siantm changed title from WIP: perf(lift): A64_PIN_REGS, guest registers in host registers across calls (experiment, off: measured no-go) to WIP: test(lift): A64_PIN_REGS, guest registers in host registers across calls, kept as a game-free experiment apart from the build (measured no-go) 2026-11-21 04:06:07 +00:00
Author
Contributor

Pushed 01cd59d8 (rebased onto main @ f1f2dc5b), answering futondestroyer's review and BeanBot's: the experiment is taken out of the game's build (17218569: nx2/lift.py, nx2/rtgen.py, nx2/guest_locals.py, nx2/lifted_c.py, build.md and tests/test_lift_cache.py are main's again; the pinned runtime is pin_regs.write_rt's, for the fixture only), the review's cases as failing checks (dfb8e913) and their fixes (01cd59d8). The counts over the game's lifted functions are removed from the doc and from the first commit's message (978a155c, reworded in the rebase). Title, Summary, Testing, Measurements and Risks rewritten for that: a default build now has main's lift key and runtime (checked, in Testing), so the in-game item is gone from Still to test. Nothing is closed; that stays the maintainers' decision.

Pushed 01cd59d8 (rebased onto `main` @ f1f2dc5b), answering futondestroyer's review and BeanBot's: the experiment is taken out of the game's build (17218569: `nx2/lift.py`, `nx2/rtgen.py`, `nx2/guest_locals.py`, `nx2/lifted_c.py`, `build.md` and `tests/test_lift_cache.py` are main's again; the pinned runtime is `pin_regs.write_rt`'s, for the fixture only), the review's cases as failing checks (dfb8e913) and their fixes (01cd59d8). The counts over the game's lifted functions are removed from the doc and from the first commit's message (978a155c, reworded in the rebase). Title, Summary, Testing, Measurements and Risks rewritten for that: a default build now has `main`'s lift key and runtime (checked, in Testing), so the in-game item is gone from Still to test. Nothing is closed; that stays the maintainers' decision.
Author
Contributor

Re #1981 (comment) (futondestroyer): done as you put it, without closing: 17218569 takes the experiment out of the game's build. nx2/lift.py, nx2/rtgen.py, nx2/guest_locals.py, nx2/lifted_c.py, build.md and tests/test_lift_cache.py are main's again, so a default build has main's lift key and runtime (checked from main @ f1f2dc5b and this branch: the same make_game.lift_key and the same rtgen a64.h/a64_rt.c, in Testing); what stays is the pass, its game-free fixture (the pinned runtime is pin_regs.write_rt's, for the fixture only) and the synthetic record, with the counts over the game's lifted functions removed from the doc and from the first commit's message (reworded in the rebase, 978a155c: a forced change). The HUD wrapper is answered on your inline comment; keeping this record or closing it is the maintainers' call.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62894 (futondestroyer): done as you put it, without closing: 17218569 takes the experiment out of the game's build. `nx2/lift.py`, `nx2/rtgen.py`, `nx2/guest_locals.py`, `nx2/lifted_c.py`, `build.md` and `tests/test_lift_cache.py` are main's again, so a default build has main's lift key and runtime (checked from `main` @ f1f2dc5b and this branch: the same `make_game.lift_key` and the same `rtgen` `a64.h`/`a64_rt.c`, in Testing); what stays is the pass, its game-free fixture (the pinned runtime is `pin_regs.write_rt`'s, for the fixture only) and the synthetic record, with the counts over the game's lifted functions removed from the doc and from the first commit's message (reworded in the rebase, 978a155c: a forced change). The HUD wrapper is answered on your inline comment; keeping this record or closing it is the maintainers' call.
Author
Contributor

Re #1981 (comment) (futondestroyer): right, the slice from one f_ head to the next took the helper in. The pass now stops on any definition between lifted functions (01cd59d8), and the fixture runs oot_patches.patch_gameplay_hud_screen on made-up C and checks the refusal leaves the folder as it was (it fails at dfb8e913 and passes at 01cd59d8). With the pass out of the game's build (17218569), handling the wrapper and the helper as separate functions with their own signatures and returns is in docs/dev/reference/pin-regs.md's integration list, for an isolated follow-up.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62893 (futondestroyer): right, the slice from one `f_` head to the next took the helper in. The pass now stops on any definition between lifted functions (01cd59d8), and the fixture runs `oot_patches.patch_gameplay_hud_screen` on made-up C and checks the refusal leaves the folder as it was (it fails at dfb8e913 and passes at 01cd59d8). With the pass out of the game's build (17218569), handling the wrapper and the helper as separate functions with their own signatures and returns is in `docs/dev/reference/pin-regs.md`'s integration list, for an isolated follow-up.
Author
Contributor

Re #1981 (comment) (L1): 17218569 takes the pass out of the lift and the runtime generator, so an update from main no longer moves either key: from main @ f1f2dc5b and this branch, make_game.lift_key over one made-up exefs, the 49 lift sources and rtgen's a64.h/a64_rt.c came out identical (queue job fb2-1981-1, in Testing). With no key moving there is no warm-update cost left to time.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62560 (L1): 17218569 takes the pass out of the lift and the runtime generator, so an update from `main` no longer moves either key: from `main` @ f1f2dc5b and this branch, `make_game.lift_key` over one made-up exefs, the 49 lift sources and `rtgen`'s `a64.h`/`a64_rt.c` came out identical (queue job fb2-1981-1, in Testing). With no key moving there is no warm-update cost left to time.
Author
Contributor

Re #1981 (comment) (L2): fixed in 01cd59d8: a64_run, the host's way in and the runtime's miss and second-slot path, keeps the pinned registers an A64_PIN_ABI call does not hand back and puts them back after it. The fixture's callees now lower SP, make an SVC in that frame and restore SP before RET; with four BLR targets on a two-entry site that covers the hit, second-slot and miss paths. At dfb8e913 all 12 ABI builds gave other digests than the plain ones (e.g. seed 3, O2, ABI four: plain adaef4a828ee7dfb, pinned a234a6e4ec7a62d6); at 01cd59d8 every build matches (queue job fb2-1981-2).

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62561 (L2): fixed in 01cd59d8: `a64_run`, the host's way in and the runtime's miss and second-slot path, keeps the pinned registers an `A64_PIN_ABI` call does not hand back and puts them back after it. The fixture's callees now lower SP, make an SVC in that frame and restore SP before RET; with four BLR targets on a two-entry site that covers the hit, second-slot and miss paths. At dfb8e913 all 12 ABI builds gave other digests than the plain ones (e.g. seed 3, O2, ABI four: plain adaef4a828ee7dfb, pinned a234a6e4ec7a62d6); at 01cd59d8 every build matches (queue job fb2-1981-2).
Author
Contributor

Re #1981 (comment) (L3): the Builder no longer meets the option: 17218569 removes the pass from nx2/lift.py (as futondestroyer asked), so A64_PIN_REGS reaches it only through tests/test_pin_regs.py. setjmp handling and the host's direct callers (host/oot_voice.c among them) stay in the doc's list of what a playable version needs.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62562 (L3): the Builder no longer meets the option: 17218569 removes the pass from `nx2/lift.py` (as futondestroyer asked), so `A64_PIN_REGS` reaches it only through `tests/test_pin_regs.py`. setjmp handling and the host's direct callers (`host/oot_voice.c` among them) stay in the doc's list of what a playable version needs.
Author
Contributor

Re #1981 (comment) (L4): no more discovery: pin_regs.write_rt (17218569) writes a separate pinned runtime that includes a64_pin.h outright, and only the fixture builds with it; rtgen's a64.h, the one the game and the emulator DLL use, has none of the pinned forms, which the test checks. The DLL's MkwFn and its A64_POLL_CTX callback are now in the doc's integration list.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62563 (L4): no more discovery: `pin_regs.write_rt` (17218569) writes a separate pinned runtime that includes `a64_pin.h` outright, and only the fixture builds with it; `rtgen`'s `a64.h`, the one the game and the emulator DLL use, has none of the pinned forms, which the test checks. The DLL's `MkwFn` and its `A64_POLL_CTX` callback are now in the doc's integration list.
Author
Contributor

Re #1981 (comment) (L5): with the pass out of the game's build (17218569), no build sends NVN calls through a64_call_miss: the h = NULL lookup exists only in the fixture's pinned runtime, which links no host code. The doc's integration list now names pinned thunks and the one-time initialisation of host/hos_hostcall.c's stats as prerequisites for any pinned host dispatch.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62564 (L5): with the pass out of the game's build (17218569), no build sends NVN calls through `a64_call_miss`: the `h = NULL` lookup exists only in the fixture's pinned runtime, which links no host code. The doc's integration list now names pinned thunks and the one-time initialisation of `host/hos_hostcall.c`'s `stats` as prerequisites for any pinned host dispatch.
Author
Contributor

Re #1981 (comment) (L6): tests/test_pin_regs.py now probes the selected compiler before building anything: preserve_none under -Werror -Wignored-attributes and an indirect musttail with the context and ten registers; a compiler that ignores or rejects either fails the check (17218569). It no longer declares RUN_ALL_ARGS, so a CI leg without a capable Clang shows a failure rather than a skip.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62565 (L6): `tests/test_pin_regs.py` now probes the selected compiler before building anything: `preserve_none` under `-Werror -Wignored-attributes` and an indirect `musttail` with the context and ten registers; a compiler that ignores or rejects either fails the check (17218569). It no longer declares `RUN_ALL_ARGS`, so a CI leg without a capable Clang shows a failure rather than a skip.
Author
Contributor

Re #1981 (comment) (L7): fixed in 01cd59d8: each range's ends are checked (ASCII digits, at most 31, ascending) before the range is made, so 0-1000000000 is refused at once and 31-0 is refused. The locals now follow main's own defaults (guest_locals.py is main's again) and the pass refuses C lifted with them on unless both are set to 0; the test covers 31-0, 5-3, non-ASCII digits, partial ranges and the huge one.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62566 (L7): fixed in 01cd59d8: each range's ends are checked (ASCII digits, at most 31, ascending) before the range is made, so `0-1000000000` is refused at once and `31-0` is refused. The locals now follow main's own defaults (`guest_locals.py` is main's again) and the pass refuses C lifted with them on unless both are set to 0; the test covers `31-0`, `5-3`, non-ASCII digits, partial ranges and the huge one.
Author
Contributor

Re #1981 (comment) (L8): fixed in 01cd59d8: pin_dir pins every file in memory and writes only once all of them passed; the fixture puts a setjmp owner's call in a later file and checks the folder is byte for byte as before (fails at dfb8e913, passes at 01cd59d8). nx2/lift.py no longer runs the pass (17218569), so no stale header is left there.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62567 (L8): fixed in 01cd59d8: `pin_dir` pins every file in memory and writes only once all of them passed; the fixture puts a setjmp owner's call in a later file and checks the folder is byte for byte as before (fails at dfb8e913, passes at 01cd59d8). `nx2/lift.py` no longer runs the pass (17218569), so no stale header is left there.
Author
Contributor

Re #1981 (comment) (L9): fixed in 01cd59d8: A64_PIN_ABI is 1 for AAPCS64, unset, empty or 0 for the exact contract, and anything else is refused; the test covers 1, 0, empty and three other values.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62568 (L9): fixed in 01cd59d8: `A64_PIN_ABI` is `1` for AAPCS64, unset, empty or `0` for the exact contract, and anything else is refused; the test covers `1`, `0`, empty and three other values.
Author
Contributor

Re #1981 (comment) (L10): fixed in 17218569: each refusal case runs in a temporary folder of its own, and the test checks the folder is unchanged after the refusal.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62569 (L10): fixed in 17218569: each refusal case runs in a temporary folder of its own, and the test checks the folder is unchanged after the refusal.
Author
Contributor

Re #1981 (comment) (L11): fixed in 17218569: RUN_ALL_ARGS is gone and the test picks --cc, then $CC, then LONGSHOT_MINGW's clang (which run_all.py sets to the clone's llvm-mingw), then clang on PATH. The queue runs used the Builder's llvm-mingw that way, with no --cc.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62570 (L11): fixed in 17218569: `RUN_ALL_ARGS` is gone and the test picks `--cc`, then `$CC`, then `LONGSHOT_MINGW`'s clang (which `run_all.py` sets to the clone's llvm-mingw), then clang on PATH. The queue runs used the Builder's llvm-mingw that way, with no `--cc`.
Author
Contributor

Re #1981 (comment) (L12): fixed in 17218569: every A64_, HOS_ and RX_ variable is cleared for the lifter, the compiler and the built programs, and main's locals are set to 0 explicitly for the pass.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62571 (L12): fixed in 17218569: every `A64_`, `HOS_` and `RX_` variable is cleared for the lifter, the compiler and the built programs, and main's locals are set to 0 explicitly for the pass.
Author
Contributor

Re #1981 (comment) (L13): guest_locals.py and lift.py are main's again (17218569), so this PR can no longer turn the normal locals off. The compiled fixture now has a function whose C starts with a real nx2/entry_hooks.py splice (entry_hooks.install and line), built and run plain and pinned with every variant, and the test checks its pinned body is context-based (dfb8e913).

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62572 (L13): `guest_locals.py` and `lift.py` are main's again (17218569), so this PR can no longer turn the normal locals off. The compiled fixture now has a function whose C starts with a real `nx2/entry_hooks.py` splice (`entry_hooks.install` and `line`), built and run plain and pinned with every variant, and the test checks its pinned body is context-based (dfb8e913).
Author
Contributor

Re #1981 (comment) (L14): the tests/test_lift_cache.py change is reverted with the rest of the build integration (17218569): the pin switches no longer reach the game's lift beyond the existing A64_ prefix rule, which that test already covers.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62573 (L14): the `tests/test_lift_cache.py` change is reverted with the rest of the build integration (17218569): the pin switches no longer reach the game's lift beyond the existing `A64_` prefix rule, which that test already covers.
Author
Contributor

Re #1981 (comment) (L15): removed: the doc's tables over the game's lifted functions and the figures from a trace of its lifted code (17218569), and the counts in the first commit's message (reworded in the rebase, 978a155c, a forced change). The no-go keeps them in words: the per-function counts were taken locally and are not published; the synthetic workload's results stay. An instruction and spill comparison on the fixture's made-up programs was not run in this round.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62574 (L15): removed: the doc's tables over the game's lifted functions and the figures from a trace of its lifted code (17218569), and the counts in the first commit's message (reworded in the rebase, 978a155c, a forced change). The no-go keeps them in words: the per-function counts were taken locally and are not published; the synthetic workload's results stay. An instruction and spill comparison on the fixture's made-up programs was not run in this round.
Author
Contributor

Re #1981 (comment) (L16): fixed in 17218569: the setup no longer says every build was exact; each variant is named with its contract (ABI marked), and the page says the two timing harnesses are not in the tree, so the timings cannot be repeated from it, while tests/test_pin_regs.py reproduces the plain/pinned equivalence for each contract.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62575 (L16): fixed in 17218569: the setup no longer says every build was exact; each variant is named with its contract (ABI marked), and the page says the two timing harnesses are not in the tree, so the timings cannot be repeated from it, while `tests/test_pin_regs.py` reproduces the plain/pinned equivalence for each contract.
Author
Contributor

Re #1981 (comment) (L18): the build integration and the build.md row are gone (17218569, as futondestroyer asked too); what remains is the pass, its fixture and the synthetic record. What the PR's own numbers show: a synthetic best of about 2-4 % faster, within the run spread, exact ten-register pinning 12.9 % slower in the hot run, and no game build possible with it on; it is now outside the game's build entirely. Whether to keep this record in the tree or close the PR is the maintainers' decision.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62576 (L18): the build integration and the `build.md` row are gone (17218569, as futondestroyer asked too); what remains is the pass, its fixture and the synthetic record. What the PR's own numbers show: a synthetic best of about 2-4 % faster, within the run spread, exact ten-register pinning 12.9 % slower in the hot run, and no game build possible with it on; it is now outside the game's build entirely. Whether to keep this record in the tree or close the PR is the maintainers' decision.
Author
Contributor

Re #1981 (comment) (L17): Measurements now compares main @ f1f2dc5b with this branch on what a default build reads (the lift key and the generated runtime: identical), the fixture results are under Testing, and Risks says no file the build reads changes, so no translation or object cache moves. The only performance figures are the branch's synthetic ones, labelled as such.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62577 (L17): Measurements now compares `main` @ f1f2dc5b with this branch on what a default build reads (the lift key and the generated runtime: identical), the fixture results are under Testing, and Risks says no file the build reads changes, so no translation or object cache moves. The only performance figures are the branch's synthetic ones, labelled as such.
Author
Contributor

Re #1981 (comment) (L19): with the experiment out of the game's build (17218569) a default build is main's (same lift key and runtime, in Testing), so there is no game change to run; the Linux fixture run stays in Still to test. A playable pinned variant would need the interleaved same-scene A/B you describe; that is noted for any follow-up.

Re https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1981#issuecomment-62577 (L19): with the experiment out of the game's build (17218569) a default build is `main`'s (same lift key and runtime, in Testing), so there is no game change to run; the Linux fixture run stays in Still to test. A playable pinned variant would need the interleaved same-scene A/B you describe; that is noted for any follow-up.
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
CI / Website build and checks (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 5s
This pull request is marked as a work in progress.
Some workflows are waiting to be reviewed.
This branch is out-of-date with the base branch
View command line instructions

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u 'perf/lift-pin-regs:siantm-perf/lift-pin-regs'
git switch 'siantm-perf/lift-pin-regs'
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
3 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!1981
No description provided.