Emulator

Unless this is needed for some specific game or homebrew, I'm reluctant to implement runtime checking of this, since it would affect performance. Your patch is doing compile-time checking, which is rather inaccurate.

Compile-time checking is fine if a JIT block is only used if the value of HID2.PSE matches the one it was compiled with, right? I think something like that is already done with address translation. It's probably not worth the overhead though.

I think the cached interpreter would also be affected as it re-uses the JIT infrastructure, just with a list of function pointers. The pure interpreter does check if paired single instructions are valid (in Interpreter::SingleStepInner).

Compile-time checking is fine if a JIT block is only used if the value of HID2.PSE matches the one it was compiled with, right?

Yes, but we currently don't have any mechanism for ensuring that, unlike for address translation. Adding such a mechanism wouldn't be impossible, but it would require doubling the size of the fast lookup table. (Or quadrupling, if we want to track HID2.PSE and HID2.LSQE separately.)

The instruction cache is supposed to be invalidated after touching "any of the enable bits [in HID2]" (ppc_750cl.pdf page 66), and as far as I can tell JIT output is discarded on icache invalidation, so JIT compile-time checking may be accurate enough here?

Rairii wrote in #note-4:

The instruction cache is supposed to be invalidated by code after touching "any of the enable bits [in HID2]" (ppc_750cl.pdf page 66), and as far as I can tell JIT output is discarded on icache invalidation, so JIT compile-time checking may be accurate enough here?

(Sorry for the double post, I thought the quote button was an edit comment button. Not used to this bug tracker.)

Maybe it would be good enough then. Do you have an example of any software that needs this behavior, homebrew included? I feel it's hard to reason about what's accurate enough without having something to test.

JosJuice wrote in #note-7:

Maybe it would be good enough then. Do you have an example of any software that needs this behavior, homebrew included? I feel it's hard to reason about what's accurate enough without having something to test.

I'm working on porting Windows NT 4 to the Wii.

All non-bytewise reads/writes are patched to an invalid instruction, to be emulated inside the program exception handler.

I use paired singles instructions for this purpose (as the Dolphin interpreter implemented the correct behaviour here, and I'm using Dolphin for debugging as I don't have an NDEV or similar).

The behaviour works on real hardware as expected, as does the Dolphin interpreter; and with a patch applied to implement the correct behaviour the JIT does too.

Okay, then this kind of implementation sounds reasonable.

Personally I don't have time to work on this right now, but I would probably be interested in doing it at some later point, unless you want to implement it yourself before then.