Commit Graph
3083 Commits
Author SHA1 Message Date
Frajo Haider fd9c970621 JitArm64/Jit64: Extend the fast lookup mmap-ed segment further to avoid needing to check the msr bits.
And in order to avoid a double dereference in the dispatcher, directly store
the normalEntry in the map.

The index to the block map becomes ((((DR<<1) | IR) << 30) | (address >> 2)).
This has been chosen since the msr bits change less often than the address,
thus we keep nearby entries together.

Also do not call the C dispatcher in case the assembly dispatcher didn't
find a block, since it wouldn't find a block either due to the 1:1 mapping,
except when falling back to the non shm segment lookup table.
2023-09-15 19:46:15 +03:00
Admiral H. Curtiss d16bedd5c4 Merge pull request #12178 from JosJuice/jit-gp-pc
Jit: Use correct address when checking fifoWriteAddresses
2023-09-10 15:58:23 +02:00
Admiral H. Curtiss 92d67df4e9 Merge pull request #12138 from JosJuice/jit-gp-check-discard
Jit: Don't discard before gather pipe interrupt check
2023-09-10 15:10:37 +02:00
JosJuice 34b0a6ea90 Jit: Check for discarded registers when flushing
This adds a check for the bug addressed by the previous commit.
2023-09-10 12:54:52 +02:00
JosJuice 5902b5b113 PPCAnalyst: Don't discard before gather pipe interrupt check
This bug has been lurking in the code ever since I added the discard
functionality. It doesn't seem to be triggered all that often,
and on top of that the emitted code only runs conditionally, so I'm not
sure if people have been affected by this bug in practice or not.
2023-09-10 12:54:52 +02:00
JosJuice f7f4da2be8 Jit: Use correct address when checking fifoWriteAddresses
We need to check for the address of the *previous* instruction, because
checking fifoWriteAddresses happens not at the end of the instruction
that triggered it but at the start of the next instruction.
2023-09-10 12:54:18 +02:00
Admiral H. Curtiss 1a0f0e7e96 Merge pull request #12081 from JosJuice/jitarm64-debug-exit-pc
JitArm64: Store PC on debug exit
2023-09-10 02:10:29 +02:00
Admiral H. Curtiss cf2a1f29b7 Core/JitCache: Don't try to allocate the fast block map on 32-bit builds. 2023-09-07 14:48:57 +02:00
JMC47 bd57d17dee Merge pull request #12079 from JosJuice/blr-no-fastmem
Jit: Allow BLR optimization without fastmem
2023-09-02 12:45:39 -04:00
Admiral H. Curtiss f1c1c6ded6 JitCache: Fix potentially dangling pointer to fast block map.
Whenever JitBaseBlockCache::Clear() got called, it threw away the memory mapping for the fast block map and created a new one. This new mapping typically got mapped at the same address at the old one, but this is not guaranteed. The pointer to the mapping gets embedded in the generated dispatcher code in Jit64AsmRoutineManager::Generate(), which is only called once on game boot, so if the new mapping ended up at a different address than the old one, the pointer in the ASM pointed at garbage, leading to a crash.

This fixes the issue by guaranteeing that the new mapping is mapped at the same address.
2023-09-02 04:03:22 +02:00
JosJuice 4131dffae9 Jit: Allow BLR optimization without fastmem
While both fastmem and the BLR optimization depend on fault handling,
the BLR optimization doesn't depend on fastmem, and there are cases
where you might want the BLR optimization but not fastmem. For me
personally, it's useful when I try to use a debugger on Android and have
to disable fastmem so I don't get SIGSEGVs all the time, but it would be
especially useful for iOS users.
2023-08-29 22:55:29 +02:00
JosJuice af2c32635a Jit: Add more error checking to ProtectStack 2023-08-29 22:46:50 +02:00
JMC47 1b2d0c0507 Merge pull request #10575 from JosJuice/jitbase-auto-clear
Jit: Automatically clear cache when JIT settings are updated
2023-08-29 15:56:25 -04:00
Frajo Haider 7daa19f40d JitArm64: Avoid loading compilerPC multiple times if it's already in a register. 2023-08-26 18:14:07 +03:00
JosJuice 85281e76ee Jit: Remove unnecessary member variables 2023-08-26 17:05:04 +02:00
JosJuice 28e8117b90 Jit: Automatically clear cache when JIT settings are updated
This fixes a problem where changing the JIT debug settings on
Android while a game was running wouldn't cause the changed settings
to apply to code blocks that already had been compiled.
2023-08-26 17:04:56 +02:00
JosJuice cd31da97d6 Merge pull request #11191 from JosJuice/jitarm64-no-checked-entry
JitArm64: Never check downcount on block entry
2023-08-26 17:00:08 +02:00
Admiral H. Curtiss 2502e412b3 Merge pull request #12117 from JosJuice/config-callback-cpu
Don't call RunAsCPUThread in config callbacks
2023-08-26 16:34:46 +02:00
Dentomologist 58ab94c30c GCC: Suppress PPCSTATE_OFF invalid-offsetof warnings
Modify PPCSTATE_OFF and PPCSTATE_OFF_ARRAY macros when using GCC to
avoid useless log spam. Specifically, use a consteval lambda with gcc
_Pragma statements to disable the -Winvalid-offsetof warning inside the
macros.

Each successful build (and many failing ones) on the Android buildbot
generates almost 300 cases of -Winvalid-offsetof, resulting in thousands
of lines of log spam per build. In addition to bloating the log filesize
these spurious warnings make it harder to find actual warnings.

These warnings are generated by calls to the macros PPCSTATE_OFF and
PPCSTATE_OFF_ARRAY, which in turn are used by many other macros used by
the JIT. The ultimate cause is that offsetof is only conditionally
supported on non-standard-layout types, which includes the PowerPCState
struct.

To address potential questions of whether there's a better way to handle
this:

The obvious solution would be to modify PowerPCState so that it does
have a standard layout. This is unfortunately impractical.

To have a standard layout a type can only contain other types with
standard layouts. None of the stl containers are guaranteed to have
standard layouts, and PowerPCState contains a std::tuple and std::array.
PowerPCState also contains a PowerPC::Cache and InstructionCache which
themselves contain std:arrays and std::vectors.

Furthermore InstructionCache derives from Cache, and a derived class can
only have standard layout if at most one class in its hierarchy has a
non-static data member, but both classes have such members. Making
InstructionCache have a standard layout would require duplicating all
the functionality of Cache so it no longer derived from it, as well as
replacing the stl containers. This might require having a raw pointer to
said containers, with the manual memory management that implies.

All of that would be much more disruptive than would be justified to get
rid of some warnings (however annoying they might be). This is
compounded by the fact that PowerPCState hasn't had a standard layout
for a long time, if ever, and if the PPCSTATE_OFF macros weren't working
reliably it would have become obvious a long time ago.

As to why I picked the lambda solution over other potential changes:

- Keeping the define as-is and wrapping some gcc #pragmas around it
  doesn't work because the pragmas don't get included when the define is
  substituted to the call site.

- Keeping the define as a non-lambda expression and using inline
  _Pragma() statements would ideally be better and works fine for msvc,
  but fails for GCC with "'#pragma' is not allowed here".

- Turning off -Winvalid-offsetof globally for gcc would work, but there
  might be other contexts where offsetof is problematic and GCC seems to
  be the only compiler warning about it.
2023-08-21 14:01:11 -07:00
Admiral H. Curtiss f19651e49b Merge pull request #11025 from AdmiralCurtiss/hle-printf
HLE_OS: Manually handle printfs from emulated software to prevent emulated software from crashing Dolphin with an invalid printf formatting string.
2023-08-20 01:31:49 +02:00
Admiral H. Curtiss d36f0fff4c Jit64: Actually update membase register after GlobalAdvance(). 2023-08-19 17:00:01 +02:00
JosJuice ed7894924c Merge pull request #12048 from krnlyng/someothertest
Jit: Load the memory register only when the msr bits have changed and do not use jumps to load it.
2023-08-19 09:49:29 +02:00
Admiral H. Curtiss ecf5870a91 Merge pull request #12115 from AdmiralCurtiss/advanced-config
DolphinQt/AdvancedPane: UI improvements.
2023-08-18 00:16:59 +02:00
JosJuice 7197e3abd0 Use structs for config callback IDs
This way you can't mix up regular config callback IDs and CPU thread
config callback IDs. (It would be rather bad if you did!)
2023-08-17 19:19:26 +02:00
JosJuice 71ce8bb6f0 Don't call RunAsCPUThread in config callbacks
In theory, our config system supports calling Set from any thread. But
because we have config callbacks that call RunAsCPUThread, it's a lot
more restricted in practice. Calling Set from any thread other than the
host thread or the CPU thread is formally thread unsafe, and calling Set
on the host thread while the CPU thread is showing a panic alert causes
a deadlock. This is especially a problem because 04072f0 made the
"Ignore for this session" button in panic alerts call Set.

Because so many of our config callbacks want their code to run on the
CPU thread, I thought it would make sense to have a centralized way to
move execution to the CPU thread for config callbacks. To solve the
deadlock problem, this new way is non-blocking. This means that threads
other than the CPU thread might continue executing before the CPU thread
is informed of the new config, but I don't think there's any problem
with that.

Intends to fix https://bugs.dolphin-emu.org/issues/13108.
2023-08-17 19:19:25 +02:00
Admiral H. Curtiss a34f221782 Core/PowerPC: Return AvailableCPUCores() as a std::span. 2023-08-16 19:25:03 +02:00
MikeIsAStar 0bb5c88a22 Retrieve page table information from the data cache
Thanks to @mkwcat for identifying the problematic code.
2023-08-15 12:44:55 -04:00
JosJuice d50494b88d Merge pull request #12060 from Sintendo/arm64-bool-logimm
JitArm64: Use LogicalImm in boolX
2023-08-13 18:51:05 +02:00
JosJuice 1ebec40e4d JitArm64: Prefer MOVI with 64-bit elements for zeroing
The Cortex-X2 and Cortex-X3 (and possibly others) recognize MOVI with
64-bit elements as a zeroing idiom, but not MOVI with other sizes.
2023-08-06 12:11:37 +02:00
JosJuice 262a3be08a JitArm64: Store PC on debug exit
Should fix https://bugs.dolphin-emu.org/issues/13178.

Jit64 doesn't need to do this because it stores PC directly into
ppcState instead of first storing it in a register.
2023-07-31 16:50:49 +02:00
JosJuice d2c5d79614 JitArm64: Use farcode in WriteLinkBlock
Now block link nearcode is back to a length of three instructions.

Unfortunately, the code I'm adding to Jit.cpp ends up being a bit messy
because we need to handle the case of already being in farcode...
2023-07-30 15:00:07 +02:00
JosJuice 1813f0fdb5 Jit: Remove checkedEntry
It's now always identical to normalEntry.
2023-07-30 14:28:02 +02:00
JosJuice f78ba9ac55 JitArm64: Never check downcount on block entry
Jumping between linked blocks currently works as follows: First, at the
end of the first block, we check if the downcount is greater than zero.
If it is, we jump to the `normalEntry` of the block. So far so good. But
if the downcount wasn't greater than zero, we jump to the `checkedEntry`
of the block, which checks the downcount *again* and then jumps to
`do_timing` if it's less than zero (which seems like an off by one error
- Jit64 doesn't do anything like this). This second check is rather
redundant. Let's jump to `do_timing` where we previously jumped to
`checkedEntry`.

Jit64 doesn't check the downcount on block entry. See 5236dc3.
2023-07-30 14:20:44 +02:00
Admiral H. Curtiss 7f29f0398c MMU: Add a HostGetU16String() function for wide strings used by emulated software. 2023-07-29 15:11:00 +02:00
Franz-Josef Haider 8bfcd2deb7 JitArm64/Jit64: Load the memory register without jumps and only when necessary. 2023-07-28 14:24:53 +03:00
Bram Speeckaert a486168448 JitArm64: Use LogicalImm in boolX
ARM64 has a special logical immediate encoding scheme, that can be used
with AND, ORR, and EOR. By taking advantage of this, we no longer need
to materialize the immediate value in a register, saving instructions
and/or reducing register pressure.

- orx

Before:
mov    w23, #0x1
orr    w23, w25, w23

After:
orr    w23, w25, #0x1

- andx

Before:
mov    w26, #-0x80000000
and    w27, w27, w26
sxtw   x24, w27

After:
and    w27, w27, #0x80000000
sxtw   x26, w27

- eqvx

Before:
mov    w23, #0x4
eon    w26, w23, w22

After:
eor    w26, w22, #0xfffffffb

- xorx

Before:
mov    w23, #0x1e
eor    w23, w27, w23

After:
eor    w23, w27, #0x1e

- norx

Before:
mov    w25, #-0x2001
orr    w23, w23, w25
mvn    w23, w23

After:
orr    w23, w23, #0xffffdfff
mvn    w23, w23
2023-07-23 18:40:53 +02:00
mitaclaw 70b3db93e0 Announce RSCRATCH clobbering in Jit64 when profiling is enabled 2023-07-19 14:15:42 -07:00
Admiral H. Curtiss ed4403537f Merge pull request #11916 from JosJuice/ppcanalyst-reorder-loop
PPCAnalyst: Reduce number of iterations in ReorderInstructionsCore
2023-07-01 01:06:53 +02:00
Admiral H. Curtiss b71304230c Jit64: Fix trampolines after #11834. 2023-06-18 01:31:44 +02:00
get 07ad75f34f EnumUtils: Add Common::ToUnderlying
Mirrors the C++23 <utility> function, std::to_underlying
2023-06-17 07:15:33 -05:00
Admiral H. Curtiss 089d433996 Merge pull request #11956 from JosJuice/jitarm64-12-bit-asm
JitArm64: Micro-optimizations in fres routine
2023-06-17 04:00:22 +02:00
Admiral H. Curtiss f5eea4a957 Merge pull request #11834 from Dentomologist/xemitter_use_pseudonamed_parameter_force5bytes
XEmitter: Add enum class Force5Bytes
2023-06-16 15:46:36 +02:00
JosJuice 9c13436e2b JitArm64: Improve instruction scheduling in fres routine
We want to have a low number of instructions between the LDP and the
MADD so that the MADD can start immediately after the LDP finishes
even if we're on a lower-end in-order CPU.
2023-06-15 22:02:39 +02:00
JMC47 f0f8225ff8 Merge pull request #11424 from Pokechu22/jit-imm-loadstore-update
Jit64: Attempt to fix updating stores with an immediate value
2023-06-15 11:32:30 -04:00
JosJuice 5b5124d9ff JitArm64: Use immediates more in fres routine
Not sure why I didn't do this to begin with. Maybe I was under the
impression that the most significant bit of a 12-bit immediate was a
sign bit.
2023-06-14 23:27:58 +02:00
Lioncash 708c986693 PPCCache: Remove redundant reinterpret_casts
The pointer is being passed to functions that take arguments as void*,
so we don't need to cast here.
2023-06-13 08:25:26 -04:00
Dentomologist 4c2759f541 XEmitter: Add enum class Jump
Replace the bool parameter force5bytes in J, JMP, and J_CC with an enum
class Jump::Short/Near. Many callers set that parameter to the literal
'true', which was unclear if you didn't already know what it did.
2023-06-12 13:04:18 -07:00
Lioncash 41df38cb7c Common: Move DebugInterface.h into Core
The base DebugInterface now depends on the Core's CPUThreadGuard, and
utilities in Common shouldn't be depending on Core facilities. So, we
can move this into the core library instead.
2023-06-12 10:35:31 -04:00
JosJuice 061ec365a8 PPCAnalyst: Reduce number of iterations in ReorderInstructionsCore
We can utilize the fact that if swapping two instructions causes another
swap to become possible, that swap involves one of the two instructions
we just swapped. There's need to search for new swap opportunities as
far back as the beginning of the block; we can just go one step back.
2023-06-09 19:45:51 +02:00
Lioncash 09271f365a PowerPC/ConditionRegister: Mark PPCToInternal() as constexpr
This allows the compiler to eliminate a static constructor that
initializes the table, and instead precompute all of the data ahead of
time.

e.g. We get something like so on GCC without constexpr:

_GLOBAL__sub_I_PowerPC::ConditionRegister::s_crTable:
        movdqa  xmm0, XMMWORD PTR .LC0[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip], xmm0
        movdqa  xmm0, XMMWORD PTR .LC1[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip+16], xmm0
        movdqa  xmm0, XMMWORD PTR .LC2[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip+32], xmm0
        movdqa  xmm0, XMMWORD PTR .LC3[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip+48], xmm0
        movdqa  xmm0, XMMWORD PTR .LC4[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip+64], xmm0
        movdqa  xmm0, XMMWORD PTR .LC5[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip+80], xmm0
        movdqa  xmm0, XMMWORD PTR .LC6[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip+96], xmm0
        movdqa  xmm0, XMMWORD PTR .LC7[rip]
        movaps  XMMWORD PTR PowerPC::ConditionRegister::s_crTable[rip+112], xmm0
        ret
PowerPC::ConditionRegister::s_crTable:
        .zero   128
.LC0:
        .quad   -9223372032559808511
        .quad   -8646911280256385023
.LC1:
        .quad   -9223372032559808512
        .quad   -8646911280256385024
.LC2:
        .quad   4294967297
        .quad   576460756598390785
.LC3:
        .quad   4294967296
        .quad   576460756598390784
.LC4:
        .quad   -4611686014132420607
        .quad   -4035225261828997119
.LC5:
        .quad   -4611686014132420608
        .quad   -4035225261828997120
.LC6:
        .quad   4611686022722355201
        .quad   5188146775025778689
.LC7:
        .quad   4611686022722355200
        .quad   5188146775025778688

and with constexpr, this all get collapsed into:

PowerPC::ConditionRegister::s_crTable:
        .quad   -9223372032559808511
        .quad   -8646911280256385023
        .quad   -9223372032559808512
        .quad   -8646911280256385024
        .quad   4294967297
        .quad   576460756598390785
        .quad   4294967296
        .quad   576460756598390784
        .quad   -4611686014132420607
        .quad   -4035225261828997119
        .quad   -4611686014132420608
        .quad   -4035225261828997120
        .quad   4611686022722355201
        .quad   5188146775025778689
        .quad   4611686022722355200
        .quad   5188146775025778688

completely eliminating the static constructor. MSVC also exhibits this,
whereas clang is a little better and does this anyway, even without
constexpr.
2023-06-08 14:33:13 -04:00