mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-18 22:58:43 +02:00
* Add AddressTable<T> * Use AddressTable<T> for dispatch * Remove JumpTable & co. * Add fallback for out of range addresses * Add PPTC support * Add documentation to `AddressTable<T>` * Make AddressTable<T> configurable * Fix table walk * Fix IsMapped check * Remove CountTableCapacity * Add PPTC support for fast path * Rename IsMapped to IsValid * Remove stale comment * Change format of address in exception message * Add TranslatorStubs * Split DispatchStub Avoids recompilation of stubs during tests. * Add hint for 64bit or 32bit * Add documentation to `Symbol` * Add documentation to `TranslatorStubs` Make `TranslatorStubs` disposable as well. * Add documentation to `SymbolType` * Add `AddressTableEventSource` to monitor function table size Add an EventSource which measures the amount of unmanaged bytes allocated by AddressTable<T> instances. dotnet-counters monitor -n Ryujinx --counters ARMeilleure * Add `AllowLcqInFunctionTable` optimization toggle This is to reduce the impact this change has on the test duration. Before everytime a test was ran, the FunctionTable would be initialized and populated so that the newly compiled test would get registered to it. * Implement unmanaged dispatcher Uses the DispatchStub to dispatch into the next translation, which allows execution to stay in unmanaged for longer and skips a ConcurrentDictionary look up when the target translation has been registered to the FunctionTable. * Remove redundant null check * Tune levels of FunctionTable Uses 5 levels instead of 4 and change unit of AddressTableEventSource from KB to MB. * Use 64-bit function table Improves codegen for direct branches: mov qword [rax+0x408],0x10603560 - mov rcx,sub_10603560_OFFSET - mov ecx,[rcx] - mov ecx,ecx - mov rdx,JIT_CACHE_BASE - add rdx,rcx + mov rcx,sub_10603560 + mov rdx,[rcx] mov rcx,rax Improves codegen for dispatch stub: and rax,byte +0x1f - mov eax,[rcx+rax*4] - mov eax,eax - mov rcx,JIT_CACHE_BASE - lea rax,[rcx+rax] + mov rax,[rcx+rax*8] mov rcx,rbx * Remove `JitCacheSymbol` & `JitCache.Offset` * Turn `Translator.Translate` into an instance method We do not have to add more parameter to this method and related ones as new structures are added & needed for translation. * Add symbol only when PTC is enabled Address LDj3SNuD's feedback * Change `NativeContext.Running` to a 32-bit integer * Fix PageTable symbol for host mapped
198 lines
6.4 KiB
C#
198 lines
6.4 KiB
C#
using ARMeilleure.IntermediateRepresentation;
|
|
using ARMeilleure.Memory;
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace ARMeilleure.State
|
|
{
|
|
class NativeContext : IDisposable
|
|
{
|
|
private unsafe struct NativeCtxStorage
|
|
{
|
|
public fixed ulong X[RegisterConsts.IntRegsCount];
|
|
public fixed ulong V[RegisterConsts.VecRegsCount * 2];
|
|
public fixed uint Flags[RegisterConsts.FlagsCount];
|
|
public fixed uint FpFlags[RegisterConsts.FpFlagsCount];
|
|
public int Counter;
|
|
public ulong DispatchAddress;
|
|
public ulong ExclusiveAddress;
|
|
public ulong ExclusiveValueLow;
|
|
public ulong ExclusiveValueHigh;
|
|
public int Running;
|
|
}
|
|
|
|
private static NativeCtxStorage _dummyStorage = new NativeCtxStorage();
|
|
|
|
private readonly IJitMemoryBlock _block;
|
|
|
|
public IntPtr BasePtr => _block.Pointer;
|
|
|
|
public NativeContext(IJitMemoryAllocator allocator)
|
|
{
|
|
_block = allocator.Allocate((ulong)Unsafe.SizeOf<NativeCtxStorage>());
|
|
|
|
GetStorage().ExclusiveAddress = ulong.MaxValue;
|
|
}
|
|
|
|
public unsafe ulong GetX(int index)
|
|
{
|
|
if ((uint)index >= RegisterConsts.IntRegsCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(index));
|
|
}
|
|
|
|
return GetStorage().X[index];
|
|
}
|
|
|
|
public unsafe void SetX(int index, ulong value)
|
|
{
|
|
if ((uint)index >= RegisterConsts.IntRegsCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(index));
|
|
}
|
|
|
|
GetStorage().X[index] = value;
|
|
}
|
|
|
|
public unsafe V128 GetV(int index)
|
|
{
|
|
if ((uint)index >= RegisterConsts.VecRegsCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(index));
|
|
}
|
|
|
|
return new V128(GetStorage().V[index * 2 + 0], GetStorage().V[index * 2 + 1]);
|
|
}
|
|
|
|
public unsafe void SetV(int index, V128 value)
|
|
{
|
|
if ((uint)index >= RegisterConsts.VecRegsCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(index));
|
|
}
|
|
|
|
GetStorage().V[index * 2 + 0] = value.Extract<ulong>(0);
|
|
GetStorage().V[index * 2 + 1] = value.Extract<ulong>(1);
|
|
}
|
|
|
|
public unsafe bool GetPstateFlag(PState flag)
|
|
{
|
|
if ((uint)flag >= RegisterConsts.FlagsCount)
|
|
{
|
|
throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
|
|
}
|
|
|
|
return GetStorage().Flags[(int)flag] != 0;
|
|
}
|
|
|
|
public unsafe void SetPstateFlag(PState flag, bool value)
|
|
{
|
|
if ((uint)flag >= RegisterConsts.FlagsCount)
|
|
{
|
|
throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
|
|
}
|
|
|
|
GetStorage().Flags[(int)flag] = value ? 1u : 0u;
|
|
}
|
|
|
|
public unsafe bool GetFPStateFlag(FPState flag)
|
|
{
|
|
if ((uint)flag >= RegisterConsts.FpFlagsCount)
|
|
{
|
|
throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
|
|
}
|
|
|
|
return GetStorage().FpFlags[(int)flag] != 0;
|
|
}
|
|
|
|
public unsafe void SetFPStateFlag(FPState flag, bool value)
|
|
{
|
|
if ((uint)flag >= RegisterConsts.FpFlagsCount)
|
|
{
|
|
throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
|
|
}
|
|
|
|
GetStorage().FpFlags[(int)flag] = value ? 1u : 0u;
|
|
}
|
|
|
|
public int GetCounter() => GetStorage().Counter;
|
|
public void SetCounter(int value) => GetStorage().Counter = value;
|
|
|
|
public bool GetRunning() => GetStorage().Running != 0;
|
|
public void SetRunning(bool value) => GetStorage().Running = value ? 1 : 0;
|
|
|
|
public unsafe static int GetRegisterOffset(Register reg)
|
|
{
|
|
if (reg.Type == RegisterType.Integer)
|
|
{
|
|
if ((uint)reg.Index >= RegisterConsts.IntRegsCount)
|
|
{
|
|
throw new ArgumentException("Invalid register.");
|
|
}
|
|
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.X[reg.Index]);
|
|
}
|
|
else if (reg.Type == RegisterType.Vector)
|
|
{
|
|
if ((uint)reg.Index >= RegisterConsts.VecRegsCount)
|
|
{
|
|
throw new ArgumentException("Invalid register.");
|
|
}
|
|
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.V[reg.Index * 2]);
|
|
}
|
|
else if (reg.Type == RegisterType.Flag)
|
|
{
|
|
if ((uint)reg.Index >= RegisterConsts.FlagsCount)
|
|
{
|
|
throw new ArgumentException("Invalid register.");
|
|
}
|
|
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.Flags[reg.Index]);
|
|
}
|
|
else /* if (reg.Type == RegisterType.FpFlag) */
|
|
{
|
|
if ((uint)reg.Index >= RegisterConsts.FpFlagsCount)
|
|
{
|
|
throw new ArgumentException("Invalid register.");
|
|
}
|
|
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.FpFlags[reg.Index]);
|
|
}
|
|
}
|
|
|
|
public static int GetCounterOffset()
|
|
{
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.Counter);
|
|
}
|
|
|
|
public static int GetDispatchAddressOffset()
|
|
{
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.DispatchAddress);
|
|
}
|
|
|
|
public static int GetExclusiveAddressOffset()
|
|
{
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.ExclusiveAddress);
|
|
}
|
|
|
|
public static int GetExclusiveValueOffset()
|
|
{
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.ExclusiveValueLow);
|
|
}
|
|
|
|
public static int GetRunningOffset()
|
|
{
|
|
return StorageOffset(ref _dummyStorage, ref _dummyStorage.Running);
|
|
}
|
|
|
|
private static int StorageOffset<T>(ref NativeCtxStorage storage, ref T target)
|
|
{
|
|
return (int)Unsafe.ByteOffset(ref Unsafe.As<NativeCtxStorage, T>(ref storage), ref target);
|
|
}
|
|
|
|
private unsafe ref NativeCtxStorage GetStorage() => ref Unsafe.AsRef<NativeCtxStorage>((void*)_block.Pointer);
|
|
|
|
public void Dispose() => _block.Dispose();
|
|
}
|
|
} |