mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-19 23:28:42 +02:00
* Refactor CPU interface * Use IExecutionContext interface on SVC handler, change how CPU interrupts invokes the handlers * Make CpuEngine take a ITickSource rather than returning one The previous implementation had the scenario where the CPU engine had to implement the tick source in mind, like for example, when we have a hypervisor and the game can read CNTPCT on the host directly. However given that we need to do conversion due to different frequencies anyway, it's not worth it. It's better to just let the user pass the tick source and redirect any reads to CNTPCT to the user tick source * XML docs for the public interfaces * PPTC invalidation due to NativeInterface function name changes * Fix build of the CPU tests * PR feedback
223 lines
7.1 KiB
C#
223 lines
7.1 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 ulong GetPc()
|
|
{
|
|
// TODO: More precise tracking of PC value.
|
|
return GetStorage().DispatchAddress;
|
|
}
|
|
|
|
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 uint GetPstate()
|
|
{
|
|
uint value = 0;
|
|
for (int flag = 0; flag < RegisterConsts.FlagsCount; flag++)
|
|
{
|
|
value |= GetStorage().Flags[flag] != 0 ? 1u << flag : 0u;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
public unsafe void SetPstate(uint value)
|
|
{
|
|
for (int flag = 0; flag < RegisterConsts.FlagsCount; flag++)
|
|
{
|
|
uint bit = 1u << flag;
|
|
GetStorage().Flags[flag] = (value & bit) == bit ? 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();
|
|
}
|
|
} |