solvise/Ryujinx
1
1
Fork 0
forked from Mirror/Ryujinx
Code Pull requests Activity

Rework SVC handling (#883)

Browse source 
* Rework SVC handling

Prepare for 32 bits support.

* QueryMemory64 x1 is an output

* Pregenerate all SVC handler

Also clean up + 32 bits code path

* Address gdk's comments

* Simplify local setter loop

* Address jd's comments
This commit is contained in:
Thog 2020-01-13 03:04:28 +01:00 committed by jduncanator
parent 5facc0c07f
commit 892df335e6
8 changed files with 167 additions and 119 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
Ryujinx.HLE/HOS/Kernel/SupervisorCall/RAttribute.cs Normal file
View file

@ -0,0 +1,15 @@
using System;
namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
{
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
public class RAttribute : Attribute
{
public readonly int Index;
public RAttribute(int index)
{
Index = index;
}
}
}

6
Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcHandler.cs
View file

@ -20,15 +20,15 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
public void SvcCall(object sender, InstExceptionEventArgs e) public void SvcCall(object sender, InstExceptionEventArgs e)
{ {
Action<SvcHandler, ExecutionContext> svcFunc = SvcTable.GetSvcFunc(e.Id); ExecutionContext context = (ExecutionContext)sender;
Action<SvcHandler, ExecutionContext> svcFunc = context.IsAarch32 ? SvcTable.SvcTable32[e.Id] : SvcTable.SvcTable64[e.Id];
if (svcFunc == null) if (svcFunc == null)
{ {
throw new NotImplementedException($"SVC 0x{e.Id:X4} is not implemented."); throw new NotImplementedException($"SVC 0x{e.Id:X4} is not implemented.");
} }
ExecutionContext context = (ExecutionContext)sender;
svcFunc(this, context); svcFunc(this, context);
PostSvcHandler(); PostSvcHandler();

40
Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcIpc.cs
View file

@ -30,7 +30,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
} }
public KernelResult ConnectToNamedPort64(ulong namePtr, out int handle) public KernelResult ConnectToNamedPort64([R(1)] ulong namePtr, [R(1)] out int handle)
{ {
return ConnectToNamedPort(namePtr, out handle); return ConnectToNamedPort(namePtr, out handle);
} }
@ -81,12 +81,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult SendSyncRequest64(int handle) public KernelResult SendSyncRequest64([R(0)] int handle)
{ {
return SendSyncRequest((ulong)_system.Scheduler.GetCurrentThread().Context.Tpidr, 0x100, handle); return SendSyncRequest((ulong)_system.Scheduler.GetCurrentThread().Context.Tpidr, 0x100, handle);
} }
public KernelResult SendSyncRequestWithUserBuffer64(ulong messagePtr, ulong size, int handle) public KernelResult SendSyncRequestWithUserBuffer64([R(0)] ulong messagePtr, [R(1)] ulong size, [R(2)] int handle)
{ {
return SendSyncRequest(messagePtr, size, handle); return SendSyncRequest(messagePtr, size, handle);
} }
@ -168,10 +168,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
public KernelResult CreateSession64( public KernelResult CreateSession64(
bool isLight, [R(2)] bool isLight,
ulong namePtr, [R(3)] ulong namePtr,
out int serverSessionHandle, [R(1)] out int serverSessionHandle,
out int clientSessionHandle) [R(2)] out int clientSessionHandle)
{ {
return CreateSession(isLight, namePtr, out serverSessionHandle, out clientSessionHandle); return CreateSession(isLight, namePtr, out serverSessionHandle, out clientSessionHandle);
} }
@ -242,7 +242,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult AcceptSession64(int portHandle, out int sessionHandle) public KernelResult AcceptSession64([R(1)] int portHandle, [R(1)] out int sessionHandle)
{ {
return AcceptSession(portHandle, out sessionHandle); return AcceptSession(portHandle, out sessionHandle);
} }
@ -299,11 +299,11 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
public KernelResult ReplyAndReceive64( public KernelResult ReplyAndReceive64(
ulong handlesPtr, [R(1)] ulong handlesPtr,
int handlesCount, [R(2)] int handlesCount,
int replyTargetHandle, [R(3)] int replyTargetHandle,
long timeout, [R(4)] long timeout,
out int handleIndex) [R(1)] out int handleIndex)
{ {
handleIndex = 0; handleIndex = 0;
@ -385,11 +385,11 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
public KernelResult CreatePort64( public KernelResult CreatePort64(
int maxSessions, [R(2)] int maxSessions,
bool isLight, [R(3)] bool isLight,
ulong namePtr, [R(4)] ulong namePtr,
out int serverPortHandle, [R(1)] out int serverPortHandle,
out int clientPortHandle) [R(2)] out int clientPortHandle)
{ {
return CreatePort(maxSessions, isLight, namePtr, out serverPortHandle, out clientPortHandle); return CreatePort(maxSessions, isLight, namePtr, out serverPortHandle, out clientPortHandle);
} }
@ -429,7 +429,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult ManageNamedPort64(ulong namePtr, int maxSessions, out int handle) public KernelResult ManageNamedPort64([R(1)] ulong namePtr, [R(2)] int maxSessions, [R(1)] out int handle)
{ {
return ManageNamedPort(namePtr, maxSessions, out handle); return ManageNamedPort(namePtr, maxSessions, out handle);
} }
@ -474,7 +474,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult ConnectToPort64(int clientPortHandle, out int clientSessionHandle) public KernelResult ConnectToPort64([R(1)] int clientPortHandle, [R(1)] out int clientSessionHandle)
{ {
return ConnectToPort(clientPortHandle, out clientSessionHandle); return ConnectToPort(clientPortHandle, out clientSessionHandle);
} }

44
Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcMemory.cs
View file

@ -6,7 +6,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
{ {
partial class SvcHandler partial class SvcHandler
{ {
public KernelResult SetHeapSize64(ulong size, out ulong position) public KernelResult SetHeapSize64([R(1)] ulong size, [R(1)] out ulong position)
{ {
return SetHeapSize(size, out position); return SetHeapSize(size, out position);
} }
@ -24,10 +24,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
public KernelResult SetMemoryAttribute64( public KernelResult SetMemoryAttribute64(
ulong position, [R(0)] ulong position,
ulong size, [R(1)] ulong size,
MemoryAttribute attributeMask, [R(2)] MemoryAttribute attributeMask,
MemoryAttribute attributeValue) [R(3)] MemoryAttribute attributeValue)
{ {
return SetMemoryAttribute(position, size, attributeMask, attributeValue); return SetMemoryAttribute(position, size, attributeMask, attributeValue);
} }
@ -65,7 +65,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult MapMemory64(ulong dst, ulong src, ulong size) public KernelResult MapMemory64([R(0)] ulong dst, [R(1)] ulong src, [R(2)] ulong size)
{ {
return MapMemory(dst, src, size); return MapMemory(dst, src, size);
} }
@ -104,7 +104,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _process.MemoryManager.Map(dst, src, size); return _process.MemoryManager.Map(dst, src, size);
} }
public KernelResult UnmapMemory64(ulong dst, ulong src, ulong size) public KernelResult UnmapMemory64([R(0)] ulong dst, [R(1)] ulong src, [R(2)] ulong size)
{ {
return UnmapMemory(dst, src, size); return UnmapMemory(dst, src, size);
} }
@ -143,12 +143,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _process.MemoryManager.Unmap(dst, src, size); return _process.MemoryManager.Unmap(dst, src, size);
} }
public KernelResult QueryMemory64(ulong infoPtr, ulong x1, ulong position) public KernelResult QueryMemory64([R(0)] ulong infoPtr, [R(2)] ulong position, [R(1)] out ulong pageInfo)
{ {
return QueryMemory(infoPtr, position); return QueryMemory(infoPtr, position, out pageInfo);
} }
private KernelResult QueryMemory(ulong infoPtr, ulong position) private KernelResult QueryMemory(ulong infoPtr, ulong position, out ulong pageInfo)
{ {
KMemoryInfo blkInfo = _process.MemoryManager.QueryMemory(position); KMemoryInfo blkInfo = _process.MemoryManager.QueryMemory(position);
@ -161,10 +161,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
_process.CpuMemory.WriteInt32 ((long)infoPtr + 0x20, blkInfo.DeviceRefCount); _process.CpuMemory.WriteInt32 ((long)infoPtr + 0x20, blkInfo.DeviceRefCount);
_process.CpuMemory.WriteInt32 ((long)infoPtr + 0x24, 0); _process.CpuMemory.WriteInt32 ((long)infoPtr + 0x24, 0);
pageInfo = 0;
return KernelResult.Success; return KernelResult.Success;
} }
public KernelResult MapSharedMemory64(int handle, ulong address, ulong size, MemoryPermission permission) public KernelResult MapSharedMemory64([R(0)] int handle, [R(1)] ulong address, [R(2)] ulong size, [R(3)] MemoryPermission permission)
{ {
return MapSharedMemory(handle, address, size, permission); return MapSharedMemory(handle, address, size, permission);
} }
@ -215,7 +217,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
permission); permission);
} }
public KernelResult UnmapSharedMemory64(int handle, ulong address, ulong size) public KernelResult UnmapSharedMemory64([R(0)] int handle, [R(1)] ulong address, [R(2)] ulong size)
{ {
return UnmapSharedMemory(handle, address, size); return UnmapSharedMemory(handle, address, size);
} }
@ -261,10 +263,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
public KernelResult CreateTransferMemory64( public KernelResult CreateTransferMemory64(
ulong address, [R(1)] ulong address,
ulong size, [R(2)] ulong size,
MemoryPermission permission, [R(3)] MemoryPermission permission,
out int handle) [R(1)] out int handle)
{ {
return CreateTransferMemory(address, size, permission, out handle); return CreateTransferMemory(address, size, permission, out handle);
} }
@ -305,7 +307,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _process.HandleTable.GenerateHandle(transferMemory, out handle); return _process.HandleTable.GenerateHandle(transferMemory, out handle);
} }
public KernelResult MapPhysicalMemory64(ulong address, ulong size) public KernelResult MapPhysicalMemory64([R(0)] ulong address, [R(1)] ulong size)
{ {
return MapPhysicalMemory(address, size); return MapPhysicalMemory(address, size);
} }
@ -343,7 +345,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _process.MemoryManager.MapPhysicalMemory(address, size); return _process.MemoryManager.MapPhysicalMemory(address, size);
} }
public KernelResult UnmapPhysicalMemory64(ulong address, ulong size) public KernelResult UnmapPhysicalMemory64([R(0)] ulong address, [R(1)] ulong size)
{ {
return UnmapPhysicalMemory(address, size); return UnmapPhysicalMemory(address, size);
} }
@ -381,7 +383,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _process.MemoryManager.UnmapPhysicalMemory(address, size); return _process.MemoryManager.UnmapPhysicalMemory(address, size);
} }
public KernelResult MapProcessCodeMemory64(int handle, ulong dst, ulong src, ulong size) public KernelResult MapProcessCodeMemory64([R(0)] int handle, [R(1)] ulong dst, [R(2)] ulong src, [R(3)] ulong size)
{ {
return MapProcessCodeMemory(handle, dst, src, size); return MapProcessCodeMemory(handle, dst, src, size);
} }
@ -423,7 +425,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return targetProcess.MemoryManager.MapProcessCodeMemory(dst, src, size); return targetProcess.MemoryManager.MapProcessCodeMemory(dst, src, size);
} }
public KernelResult UnmapProcessCodeMemory64(int handle, ulong dst, ulong src, ulong size) public KernelResult UnmapProcessCodeMemory64([R(0)] int handle, [R(1)] ulong dst, [R(2)] ulong src, [R(3)] ulong size)
{ {
return UnmapProcessCodeMemory(handle, dst, src, size); return UnmapProcessCodeMemory(handle, dst, src, size);
} }
@ -465,7 +467,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return targetProcess.MemoryManager.UnmapProcessCodeMemory(dst, src, size); return targetProcess.MemoryManager.UnmapProcessCodeMemory(dst, src, size);
} }
public KernelResult SetProcessMemoryPermission64(int handle, ulong src, ulong size, MemoryPermission permission) public KernelResult SetProcessMemoryPermission64([R(0)] int handle, [R(1)] ulong src, [R(2)] ulong size, [R(3)] MemoryPermission permission)
{ {
return SetProcessMemoryPermission(handle, src, size, permission); return SetProcessMemoryPermission(handle, src, size, permission);
} }

24
Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcSystem.cs
View file

@ -17,7 +17,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
ExitProcess(); ExitProcess();
} }
public KernelResult TerminateProcess64(int handle) public KernelResult TerminateProcess64([R(0)] int handle)
{ {
return TerminateProcess(handle); return TerminateProcess(handle);
} }
@ -54,7 +54,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
_system.Scheduler.GetCurrentProcess().TerminateCurrentProcess(); _system.Scheduler.GetCurrentProcess().TerminateCurrentProcess();
} }
public KernelResult SignalEvent64(int handle) public KernelResult SignalEvent64([R(0)] int handle)
{ {
return SignalEvent(handle); return SignalEvent(handle);
} }
@ -79,7 +79,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult ClearEvent64(int handle) public KernelResult ClearEvent64([R(0)] int handle)
{ {
return ClearEvent(handle); return ClearEvent(handle);
} }
@ -104,7 +104,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult CloseHandle64(int handle) public KernelResult CloseHandle64([R(0)] int handle)
{ {
return CloseHandle(handle); return CloseHandle(handle);
} }
@ -134,7 +134,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return KernelResult.Success; return KernelResult.Success;
} }
public KernelResult ResetSignal64(int handle) public KernelResult ResetSignal64([R(0)] int handle)
{ {
return ResetSignal(handle); return ResetSignal(handle);
} }
@ -173,7 +173,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _system.Scheduler.GetCurrentThread().Context.CntpctEl0; return _system.Scheduler.GetCurrentThread().Context.CntpctEl0;
} }
public KernelResult GetProcessId64(int handle, out long pid) public KernelResult GetProcessId64([R(1)] int handle, [R(1)] out long pid)
{ {
return GetProcessId(handle, out pid); return GetProcessId(handle, out pid);
} }
@ -203,7 +203,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
: KernelResult.InvalidHandle; : KernelResult.InvalidHandle;
} }
public void Break64(ulong reason, ulong x1, ulong info) public void Break64([R(0)] ulong reason, [R(1)] ulong x1, [R(2)] ulong info)
{ {
Break(reason); Break(reason);
} }
@ -235,7 +235,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
} }
public void OutputDebugString64(ulong strPtr, ulong size) public void OutputDebugString64([R(0)] ulong strPtr, [R(1)] ulong size)
{ {
OutputDebugString(strPtr, size); OutputDebugString(strPtr, size);
} }
@ -247,7 +247,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
Logger.PrintWarning(LogClass.KernelSvc, str); Logger.PrintWarning(LogClass.KernelSvc, str);
} }
public KernelResult GetInfo64(uint id, int handle, long subId, out long value) public KernelResult GetInfo64([R(1)] uint id, [R(2)] int handle, [R(3)] long subId, [R(1)] out long value)
{ {
return GetInfo(id, handle, subId, out value); return GetInfo(id, handle, subId, out value);
} }
@ -478,7 +478,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return KernelResult.Success; return KernelResult.Success;
} }
public KernelResult CreateEvent64(out int wEventHandle, out int rEventHandle) public KernelResult CreateEvent64([R(1)] out int wEventHandle, [R(2)] out int rEventHandle)
{ {
return CreateEvent(out wEventHandle, out rEventHandle); return CreateEvent(out wEventHandle, out rEventHandle);
} }
@ -506,7 +506,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult GetProcessList64(ulong address, int maxCount, out int count) public KernelResult GetProcessList64([R(1)] ulong address, [R(2)] int maxCount, [R(1)] out int count)
{ {
return GetProcessList(address, maxCount, out count); return GetProcessList(address, maxCount, out count);
} }
@ -560,7 +560,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return KernelResult.Success; return KernelResult.Success;
} }
public KernelResult GetSystemInfo64(uint id, int handle, long subId, out long value) public KernelResult GetSystemInfo64([R(1)] uint id, [R(2)] int handle, [R(3)] long subId, [R(1)] out long value)
{ {
return GetSystemInfo(id, handle, subId, out value); return GetSystemInfo(id, handle, subId, out value);
} }

105
Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcTable.cs
View file

@ -3,6 +3,7 @@ using Ryujinx.Common.Logging;
using Ryujinx.HLE.HOS.Kernel.Common; using Ryujinx.HLE.HOS.Kernel.Common;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using System.Reflection; using System.Reflection;
using System.Reflection.Emit; using System.Reflection.Emit;
@ -10,15 +11,19 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
{ {
static class SvcTable static class SvcTable
{ {
private const int SvcFuncMaxArguments = 8; private const int SvcFuncMaxArguments64 = 8;
private const int SvcFuncMaxArguments32 = 4;
private const int SvcMax = 0x80;
private static Dictionary<int, string> _svcFuncs64; public static Action<SvcHandler, ExecutionContext>[] SvcTable32 { get; }
public static Action<SvcHandler, ExecutionContext>[] SvcTable64 { get; }
private static Action<SvcHandler, ExecutionContext>[] _svcTable64;
static SvcTable() static SvcTable()
{ {
_svcFuncs64 = new Dictionary<int, string> SvcTable32 = new Action<SvcHandler, ExecutionContext>[SvcMax];
SvcTable64 = new Action<SvcHandler, ExecutionContext>[SvcMax];
Dictionary<int, string> svcFuncs64 = new Dictionary<int, string>
{ {
{ 0x01, nameof(SvcHandler.SetHeapSize64) }, { 0x01, nameof(SvcHandler.SetHeapSize64) },
{ 0x03, nameof(SvcHandler.SetMemoryAttribute64) }, { 0x03, nameof(SvcHandler.SetMemoryAttribute64) },
@ -78,25 +83,23 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
{ 0x7B, nameof(SvcHandler.TerminateProcess64) } { 0x7B, nameof(SvcHandler.TerminateProcess64) }
}; };
_svcTable64 = new Action<SvcHandler, ExecutionContext>[0x80]; foreach (KeyValuePair<int, string> value in svcFuncs64)
}
public static Action<SvcHandler, ExecutionContext> GetSvcFunc(int svcId)
{ {
if (_svcTable64[svcId] != null) SvcTable64[value.Key] = GenerateMethod(value.Value, SvcFuncMaxArguments64);
}
Dictionary<int, string> svcFuncs32 = new Dictionary<int, string>
{ {
return _svcTable64[svcId]; // TODO
} };
if (_svcFuncs64.TryGetValue(svcId, out string svcName)) foreach (KeyValuePair<int, string> value in svcFuncs32)
{ {
return _svcTable64[svcId] = GenerateMethod(svcName); SvcTable32[value.Key] = GenerateMethod(value.Value, SvcFuncMaxArguments32);
}
} }
return null; private static Action<SvcHandler, ExecutionContext> GenerateMethod(string svcName, int registerCleanCount)
}
private static Action<SvcHandler, ExecutionContext> GenerateMethod(string svcName)
{ {
Type[] argTypes = new Type[] { typeof(SvcHandler), typeof(ExecutionContext) }; Type[] argTypes = new Type[] { typeof(SvcHandler), typeof(ExecutionContext) };
@ -106,11 +109,6 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
ParameterInfo[] methodArgs = methodInfo.GetParameters(); ParameterInfo[] methodArgs = methodInfo.GetParameters();
if (methodArgs.Length > SvcFuncMaxArguments)
{
throw new InvalidOperationException($"Method \"{svcName}\" has too many arguments, max is 8.");
}
ILGenerator generator = method.GetILGenerator(); ILGenerator generator = method.GetILGenerator();
void ConvertToArgType(Type sourceType) void ConvertToArgType(Type sourceType)
@ -152,6 +150,18 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
} }
RAttribute GetRegisterAttribute(ParameterInfo parameterInfo)
{
RAttribute argumentAttribute = (RAttribute)parameterInfo.GetCustomAttribute(typeof(RAttribute));
if (argumentAttribute == null)
{
throw new InvalidOperationException($"Method \"{svcName}\" is missing a {typeof(RAttribute).Name} attribute on parameter \"{parameterInfo.Name}\"");
}
return argumentAttribute;
}
// For functions returning output values, the first registers // For functions returning output values, the first registers
// are used to hold pointers where the value will be stored, // are used to hold pointers where the value will be stored,
// so they can't be used to pass argument and we must // so they can't be used to pass argument and we must
@ -179,15 +189,25 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
string argsFormat = svcName; string argsFormat = svcName;
for (int index = 0; index < inputArgsCount; index++) for (int index = 0; index < methodArgs.Length; index++)
{ {
Type argType = methodArgs[index].ParameterType;
// Ignore out argument for printing
if (argType.IsByRef)
{
continue;
}
RAttribute registerAttribute = GetRegisterAttribute(methodArgs[index]);
argsFormat += $" {methodArgs[index].Name}: 0x{{{index}:X8}},"; argsFormat += $" {methodArgs[index].Name}: 0x{{{index}:X8}},";
generator.Emit(OpCodes.Dup); generator.Emit(OpCodes.Dup);
generator.Emit(OpCodes.Ldc_I4, index); generator.Emit(OpCodes.Ldc_I4, index);
generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldc_I4, byRefArgsCount + index); generator.Emit(OpCodes.Ldc_I4, registerAttribute.Index);
MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.GetX)); MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.GetX));
@ -216,11 +236,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
// Call the SVC function handler. // Call the SVC function handler.
generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldarg_0);
List<LocalBuilder> locals = new List<LocalBuilder>(); List<(LocalBuilder, RAttribute)> locals = new List<(LocalBuilder, RAttribute)>();
for (int index = 0; index < methodArgs.Length; index++) for (int index = 0; index < methodArgs.Length; index++)
{ {
Type argType = methodArgs[index].ParameterType; Type argType = methodArgs[index].ParameterType;
RAttribute registerAttribute = GetRegisterAttribute(methodArgs[index]);
if (argType.IsByRef) if (argType.IsByRef)
{ {
@ -228,12 +249,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
LocalBuilder local = generator.DeclareLocal(argType); LocalBuilder local = generator.DeclareLocal(argType);
locals.Add(local); locals.Add((local, registerAttribute));
if (!methodArgs[index].IsOut) if (!methodArgs[index].IsOut)
{ {
generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldc_I4, index); generator.Emit(OpCodes.Ldc_I4, registerAttribute.Index);
MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.GetX)); MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.GetX));
@ -249,7 +270,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
else else
{ {
generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldc_I4, byRefArgsCount + index); generator.Emit(OpCodes.Ldc_I4, registerAttribute.Index);
MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.GetX)); MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.GetX));
@ -261,8 +282,6 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
generator.Emit(OpCodes.Call, methodInfo); generator.Emit(OpCodes.Call, methodInfo);
int outRegIndex = 0;
Type retType = methodInfo.ReturnType; Type retType = methodInfo.ReturnType;
// Print result code. // Print result code.
@ -275,6 +294,8 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
generator.Emit(OpCodes.Call, printResultMethod); generator.Emit(OpCodes.Call, printResultMethod);
} }
uint registerInUse = 0;
// Save return value into register X0 (when the method has a return value). // Save return value into register X0 (when the method has a return value).
if (retType != typeof(void)) if (retType != typeof(void))
{ {
@ -284,7 +305,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
generator.Emit(OpCodes.Stloc, tempLocal); generator.Emit(OpCodes.Stloc, tempLocal);
generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldc_I4, outRegIndex++); generator.Emit(OpCodes.Ldc_I4, 0);
generator.Emit(OpCodes.Ldloc, tempLocal); generator.Emit(OpCodes.Ldloc, tempLocal);
ConvertToFieldType(retType); ConvertToFieldType(retType);
@ -292,26 +313,36 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX)); MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX));
generator.Emit(OpCodes.Call, info); generator.Emit(OpCodes.Call, info);
registerInUse |= 1u << 0;
} }
for (int index = 0; index < locals.Count; index++) for (int index = 0; index < locals.Count; index++)
{ {
(LocalBuilder local, RAttribute attribute) = locals[index];
generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldc_I4, outRegIndex++); generator.Emit(OpCodes.Ldc_I4, attribute.Index);
generator.Emit(OpCodes.Ldloc, locals[index]); generator.Emit(OpCodes.Ldloc, local);
ConvertToFieldType(locals[index].LocalType); ConvertToFieldType(local.LocalType);
MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX)); MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX));
generator.Emit(OpCodes.Call, info); generator.Emit(OpCodes.Call, info);
registerInUse |= 1u << attribute.Index;
} }
// Zero out the remaining unused registers. // Zero out the remaining unused registers.
while (outRegIndex < SvcFuncMaxArguments) for (int i = 0; i < registerCleanCount; i++)
{ {
if ((registerInUse & (1u << i)) != 0)
{
continue;
}
generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldc_I4, outRegIndex++); generator.Emit(OpCodes.Ldc_I4, i);
generator.Emit(OpCodes.Ldc_I8, 0L); generator.Emit(OpCodes.Ldc_I8, 0L);
MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX)); MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX));

30
Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcThread.cs
View file

@ -9,12 +9,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
partial class SvcHandler partial class SvcHandler
{ {
public KernelResult CreateThread64( public KernelResult CreateThread64(
ulong entrypoint, [R(1)] ulong entrypoint,
ulong argsPtr, [R(2)] ulong argsPtr,
ulong stackTop, [R(3)] ulong stackTop,
int priority, [R(4)] int priority,
int cpuCore, [R(5)] int cpuCore,
out int handle) [R(1)] out int handle)
{ {
return CreateThread(entrypoint, argsPtr, stackTop, priority, cpuCore, out handle); return CreateThread(entrypoint, argsPtr, stackTop, priority, cpuCore, out handle);
} }
@ -78,7 +78,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult StartThread64(int handle) public KernelResult StartThread64([R(0)] int handle)
{ {
return StartThread(handle); return StartThread(handle);
} }
@ -122,7 +122,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
currentThread.Exit(); currentThread.Exit();
} }
public void SleepThread64(long timeout) public void SleepThread64([R(0)] long timeout)
{ {
SleepThread(timeout); SleepThread(timeout);
} }
@ -146,7 +146,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
} }
public KernelResult GetThreadPriority64(int handle, out int priority) public KernelResult GetThreadPriority64([R(1)] int handle, [R(1)] out int priority)
{ {
return GetThreadPriority(handle, out priority); return GetThreadPriority(handle, out priority);
} }
@ -169,7 +169,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
} }
public KernelResult SetThreadPriority64(int handle, int priority) public KernelResult SetThreadPriority64([R(0)] int handle, [R(1)] int priority)
{ {
return SetThreadPriority(handle, priority); return SetThreadPriority(handle, priority);
} }
@ -190,7 +190,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return KernelResult.Success; return KernelResult.Success;
} }
public KernelResult GetThreadCoreMask64(int handle, out int preferredCore, out long affinityMask) public KernelResult GetThreadCoreMask64([R(2)] int handle, [R(1)] out int preferredCore, [R(2)] out long affinityMask)
{ {
return GetThreadCoreMask(handle, out preferredCore, out affinityMask); return GetThreadCoreMask(handle, out preferredCore, out affinityMask);
} }
@ -215,7 +215,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
} }
public KernelResult SetThreadCoreMask64(int handle, int preferredCore, long affinityMask) public KernelResult SetThreadCoreMask64([R(0)] int handle, [R(1)] int preferredCore, [R(2)] long affinityMask)
{ {
return SetThreadCoreMask(handle, preferredCore, affinityMask); return SetThreadCoreMask(handle, preferredCore, affinityMask);
} }
@ -271,7 +271,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _system.Scheduler.GetCurrentThread().CurrentCore; return _system.Scheduler.GetCurrentThread().CurrentCore;
} }
public KernelResult GetThreadId64(int handle, out long threadUid) public KernelResult GetThreadId64([R(1)] int handle, [R(1)] out long threadUid)
{ {
return GetThreadId(handle, out threadUid); return GetThreadId(handle, out threadUid);
} }
@ -294,7 +294,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
} }
public KernelResult SetThreadActivity64(int handle, bool pause) public KernelResult SetThreadActivity64([R(0)] int handle, [R(1)] bool pause)
{ {
return SetThreadActivity(handle, pause); return SetThreadActivity(handle, pause);
} }
@ -321,7 +321,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return thread.SetActivity(pause); return thread.SetActivity(pause);
} }
public KernelResult GetThreadContext364(ulong address, int handle) public KernelResult GetThreadContext364([R(0)] ulong address, [R(1)] int handle)
{ {
return GetThreadContext3(address, handle); return GetThreadContext3(address, handle);
} }

22
Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcThreadSync.cs
View file

@ -7,7 +7,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
{ {
partial class SvcHandler partial class SvcHandler
{ {
public KernelResult WaitSynchronization64(ulong handlesPtr, int handlesCount, long timeout, out int handleIndex) public KernelResult WaitSynchronization64([R(1)] ulong handlesPtr, [R(2)] int handlesCount, [R(3)] long timeout, [R(1)] out int handleIndex)
{ {
return WaitSynchronization(handlesPtr, handlesCount, timeout, out handleIndex); return WaitSynchronization(handlesPtr, handlesCount, timeout, out handleIndex);
} }
@ -40,7 +40,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return _system.Synchronization.WaitFor(syncObjs.ToArray(), timeout, out handleIndex); return _system.Synchronization.WaitFor(syncObjs.ToArray(), timeout, out handleIndex);
} }
public KernelResult CancelSynchronization64(int handle) public KernelResult CancelSynchronization64([R(0)] int handle)
{ {
return CancelSynchronization(handle); return CancelSynchronization(handle);
} }
@ -59,7 +59,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return KernelResult.Success; return KernelResult.Success;
} }
public KernelResult ArbitrateLock64(int ownerHandle, ulong mutexAddress, int requesterHandle) public KernelResult ArbitrateLock64([R(0)] int ownerHandle, [R(1)] ulong mutexAddress, [R(2)] int requesterHandle)
{ {
return ArbitrateLock(ownerHandle, mutexAddress, requesterHandle); return ArbitrateLock(ownerHandle, mutexAddress, requesterHandle);
} }
@ -81,7 +81,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return currentProcess.AddressArbiter.ArbitrateLock(ownerHandle, mutexAddress, requesterHandle); return currentProcess.AddressArbiter.ArbitrateLock(ownerHandle, mutexAddress, requesterHandle);
} }
public KernelResult ArbitrateUnlock64(ulong mutexAddress) public KernelResult ArbitrateUnlock64([R(0)] ulong mutexAddress)
{ {
return ArbitrateUnlock(mutexAddress); return ArbitrateUnlock(mutexAddress);
} }
@ -104,10 +104,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
} }
public KernelResult WaitProcessWideKeyAtomic64( public KernelResult WaitProcessWideKeyAtomic64(
ulong mutexAddress, [R(0)] ulong mutexAddress,
ulong condVarAddress, [R(1)] ulong condVarAddress,
int handle, [R(2)] int handle,
long timeout) [R(3)] long timeout)
{ {
return WaitProcessWideKeyAtomic(mutexAddress, condVarAddress, handle, timeout); return WaitProcessWideKeyAtomic(mutexAddress, condVarAddress, handle, timeout);
} }
@ -137,7 +137,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
timeout); timeout);
} }
public KernelResult SignalProcessWideKey64(ulong address, int count) public KernelResult SignalProcessWideKey64([R(0)] ulong address, [R(1)] int count)
{ {
return SignalProcessWideKey(address, count); return SignalProcessWideKey(address, count);
} }
@ -151,7 +151,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return KernelResult.Success; return KernelResult.Success;
} }
public KernelResult WaitForAddress64(ulong address, ArbitrationType type, int value, long timeout) public KernelResult WaitForAddress64([R(0)] ulong address, [R(1)] ArbitrationType type, [R(2)] int value, [R(3)] long timeout)
{ {
return WaitForAddress(address, type, value, timeout); return WaitForAddress(address, type, value, timeout);
} }
@ -194,7 +194,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
return result; return result;
} }
public KernelResult SignalToAddress64(ulong address, SignalType type, int value, int count) public KernelResult SignalToAddress64([R(0)] ulong address, [R(1)] SignalType type, [R(2)] int value, [R(3)] int count)
{ {
return SignalToAddress(address, type, value, count); return SignalToAddress(address, type, value, count);
} }