mirror of
https://github.com/RetroPortingToolKit/psxrecomp
synced 2026-10-26 02:11:36 -04:00
Matthew Stanley
4e932d05fe
The MIPS->sljit emitter, paralleling dirty_ram_interp.c's exec_one but
emitting host code. First slice = single-block LEAF functions ending in
`jr $ra`; everything else aborts the whole fragment to the interpreter
(precision over recall).
- overlay_sljit.c: memory-backed GPRs, 32-bit ops (R3000A wraparound),
loads/stores via icall through the cpu read/write callbacks (same
MMIO/page-watch/dirty-tracking path as the interpreter). Opcodes:
SLL/SRL/SRA/SLLV/SRLV/SRAV, ADD(U)/SUB(U), AND/OR/XOR/NOR, SLT(U),
ADDI(U)/SLTI(U)/ANDI/ORI/XORI/LUI, LB/LH/LW/LBU/LHU/SB/SH/SW, SYNC.
- compile_fragment now returns CompiledFragment{fn,code_lo,code_len};
overlay_loader registers an sljit candidate (crc hashed from the live
bytes it JIT'd from, same live-byte validation as gcc candidates).
- Step 5 wiring is VALIDATION-GATED: JIT-on-miss fires only when
backend==sljit AND the same-state differential is armed (never in a
shadow run). Normal play stays byte-identical; live sljit execution
stays off until the differential gate passes.
- Debug: sljit_try <addr> probe; sljit_status reports shards_registered.
Verified: runtime/tests/sljit_emit_test.c (links overlay_sljit.c +
sljitLir.c only) JITs hand-built leaf functions and checks output —
26/26 pass incl. gpr0 invariant, sign/zero-ext, signed/unsigned compare,
and the decline cases. Full psx-runtime build clean.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
88 lines
4.3 KiB
C
88 lines
4.3 KiB
C
/* code_provider.h — the backend-agnostic code-production seam (SLJIT.md §3).
|
|
*
|
|
* One interface the overlay capture/dispatch spine talks to instead of calling
|
|
* a specific backend directly. The validated gcc spawn->DLL path becomes its
|
|
* first implementation; the in-process sljit JIT (SLJIT.md §7 step 4) becomes
|
|
* the second. Everything that makes overlays correct — content-keyed multi-
|
|
* candidate dispatch, per-call live-byte validation, the self-mod blacklist,
|
|
* the coverage manifest — is unchanged and backend-blind (SLJIT.md §2).
|
|
*
|
|
* Two production lifecycles, BOTH expressed here because the two backends model
|
|
* production differently and a provider implements whichever it supports:
|
|
*
|
|
* - BATCH / ASYNC (request / busy / poll_main): the gcc model. Kicked by the
|
|
* autocapture tick, spawns a compiler off-thread, applied later via a cache
|
|
* rescan on the emu thread. Seconds of latency; many fragments per run.
|
|
* - SYNC / ON-MISS (compile_fragment): the sljit model. JIT a single fragment
|
|
* in-process at a dispatch miss, sub-ms, return a native fn the caller
|
|
* registers immediately. (Wired into the dispatch path in SLJIT.md step 5;
|
|
* defined here so the abstraction is honest about both modes, not gcc-only.)
|
|
*
|
|
* A provider sets the hooks it supports and leaves the rest NULL; callers
|
|
* null-check before invoking. The gcc provider's batch hooks are thin pass-
|
|
* throughs to autocompile_* — behavior is byte-for-byte what it was before the
|
|
* abstraction (this is a pure refactor; selection defaults to gcc).
|
|
*/
|
|
#ifndef PSXRECOMP_CODE_PROVIDER_H
|
|
#define PSXRECOMP_CODE_PROVIDER_H
|
|
|
|
#include "cpu_state.h"
|
|
#include <stdint.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* Native shard ABI — identical to overlay_loader's OverlayFn / OverlaySljitFn. */
|
|
typedef void (*CodeProviderFn)(CPUState *);
|
|
|
|
/* Result of a synchronous on-miss compile. fn == NULL means the provider
|
|
* declined (caller runs the interpreter). On success [code_lo, code_lo+code_len)
|
|
* is the PHYS byte-range the fragment was compiled from — the caller registers a
|
|
* candidate over it for per-call live-byte validation (the backend-neutral
|
|
* equivalent of the gcc .ranges manifest). */
|
|
typedef struct {
|
|
CodeProviderFn fn; /* NULL = declined */
|
|
uint32_t code_lo; /* phys start of compiled code range */
|
|
uint32_t code_len; /* byte length of compiled code range */
|
|
} CompiledFragment;
|
|
|
|
typedef struct CodeProvider {
|
|
const char *name; /* "gcc" | "sljit" */
|
|
int (*available)(void); /* gcc: a compile cmd is configured;
|
|
sljit: always (no external toolchain) */
|
|
|
|
/* Batch/async production (autocapture-driven). request() returns 1 if a
|
|
* compile was started. busy() is 1 while one is in flight. poll_main() runs
|
|
* on the emu thread to apply a finished compile (cache rescan). Any may be
|
|
* NULL on a provider that does not do batch production. */
|
|
int (*request)(void);
|
|
int (*busy)(void);
|
|
void (*poll_main)(void);
|
|
|
|
/* Synchronous on-miss production of one fragment. Fills *out (out->fn NULL =
|
|
* declined → caller runs the interpreter, the always-safe precision-over-
|
|
* recall floor). gcc leaves this hook NULL (a compiler spawn is far too slow
|
|
* for the dispatch path); sljit JITs in-process. A NULL hook == always
|
|
* declines. `bytes`/`size`/`image_base_vram` describe the image to decode
|
|
* from (typically live RAM: bytes = RAM base, image_base_vram = 0). */
|
|
void (*compile_fragment)(uint32_t entry, const uint8_t *bytes, uint32_t size,
|
|
uint32_t image_base_vram, CompiledFragment *out);
|
|
} CodeProvider;
|
|
|
|
/* Resolve the active backend (overlay_backend_resolve) and cache the matching
|
|
* provider. cfg_backend = [runtime] overlay_backend ("auto"|"gcc"|"sljit", may
|
|
* be NULL/empty for auto); gcc_configured = autocompile_configured(). Call once
|
|
* at overlay-cache init, on the emu thread, before the run loop starts. */
|
|
void code_provider_init(const char *cfg_backend, int gcc_configured);
|
|
|
|
/* The active provider. Never NULL — defaults to the gcc provider before
|
|
* code_provider_init() runs, so any early caller is safe. */
|
|
const CodeProvider *code_provider_active(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* PSXRECOMP_CODE_PROVIDER_H */
|