Rework SVC handling (#883)

* 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

Ryujinx.HLE/HOS/Kernel/SupervisorCall/RAttribute.cs

@@ -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;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcHandler.cs

@@ -20,15 +20,15 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 
         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)
             {
                 throw new NotImplementedException($"SVC 0x{e.Id:X4} is not implemented.");
             }
 
-            ExecutionContext context = (ExecutionContext)sender;
-
             svcFunc(this, context);
 
             PostSvcHandler();

Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcIpc.cs

@@ -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);
         }
@@ -81,12 +81,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return result;
         }
 
-        public KernelResult SendSyncRequest64(int handle)
+        public KernelResult SendSyncRequest64([R(0)] int 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);
         }
@@ -168,10 +168,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
         }
 
         public KernelResult CreateSession64(
-            bool    isLight,
-            ulong   namePtr,
-            out int serverSessionHandle,
-            out int clientSessionHandle)
+            [R(2)] bool    isLight,
+            [R(3)] ulong   namePtr,
+            [R(1)] out int serverSessionHandle,
+            [R(2)] out int clientSessionHandle)
         {
             return CreateSession(isLight, namePtr, out serverSessionHandle, out clientSessionHandle);
         }
@@ -242,7 +242,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -299,11 +299,11 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
         }
 
         public KernelResult ReplyAndReceive64(
-            ulong   handlesPtr,
-            int     handlesCount,
-            int     replyTargetHandle,
-            long    timeout,
-            out int handleIndex)
+            [R(1)] ulong   handlesPtr,
+            [R(2)] int     handlesCount,
+            [R(3)] int     replyTargetHandle,
+            [R(4)] long    timeout,
+            [R(1)] out int handleIndex)
         {
             handleIndex = 0;
 
@@ -385,11 +385,11 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
         }
 
         public KernelResult CreatePort64(
-            int     maxSessions,
-            bool    isLight,
-            ulong   namePtr,
-            out int serverPortHandle,
-            out int clientPortHandle)
+            [R(2)] int     maxSessions,
+            [R(3)] bool    isLight,
+            [R(4)] ulong   namePtr,
+            [R(1)] out int serverPortHandle,
+            [R(2)] out int clientPortHandle)
         {
             return CreatePort(maxSessions, isLight, namePtr, out serverPortHandle, out clientPortHandle);
         }
@@ -429,7 +429,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -474,7 +474,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }

Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcMemory.cs

@@ -6,7 +6,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 {
     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);
         }
@@ -24,10 +24,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
         }
 
         public KernelResult SetMemoryAttribute64(
-            ulong           position,
-            ulong           size,
-            MemoryAttribute attributeMask,
-            MemoryAttribute attributeValue)
+            [R(0)] ulong           position,
+            [R(1)] ulong           size,
+            [R(2)] MemoryAttribute attributeMask,
+            [R(3)] MemoryAttribute attributeValue)
         {
             return SetMemoryAttribute(position, size, attributeMask, attributeValue);
         }
@@ -65,7 +65,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -104,7 +104,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -143,12 +143,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
 
@@ -161,10 +161,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             _process.CpuMemory.WriteInt32 ((long)infoPtr + 0x20, blkInfo.DeviceRefCount);
             _process.CpuMemory.WriteInt32 ((long)infoPtr + 0x24, 0);
 
+            pageInfo = 0;
+
             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);
         }
@@ -215,7 +217,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
                 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);
         }
@@ -261,10 +263,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
         }
 
         public KernelResult CreateTransferMemory64(
-            ulong            address,
-            ulong            size,
-            MemoryPermission permission,
-            out int          handle)
+            [R(1)] ulong            address,
+            [R(2)] ulong            size,
+            [R(3)] MemoryPermission permission,
+            [R(1)] out int          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);
         }
 
-        public KernelResult MapPhysicalMemory64(ulong address, ulong size)
+        public KernelResult MapPhysicalMemory64([R(0)] ulong address, [R(1)] ulong size)
         {
             return MapPhysicalMemory(address, size);
         }
@@ -343,7 +345,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -381,7 +383,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -423,7 +425,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -465,7 +467,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }

Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcSystem.cs

@@ -17,7 +17,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             ExitProcess();
         }
 
-        public KernelResult TerminateProcess64(int handle)
+        public KernelResult TerminateProcess64([R(0)] int handle)
         {
             return TerminateProcess(handle);
         }
@@ -54,7 +54,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             _system.Scheduler.GetCurrentProcess().TerminateCurrentProcess();
         }
 
-        public KernelResult SignalEvent64(int handle)
+        public KernelResult SignalEvent64([R(0)] int handle)
         {
             return SignalEvent(handle);
         }
@@ -79,7 +79,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return result;
         }
 
-        public KernelResult ClearEvent64(int handle)
+        public KernelResult ClearEvent64([R(0)] int handle)
         {
             return ClearEvent(handle);
         }
@@ -104,7 +104,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return result;
         }
 
-        public KernelResult CloseHandle64(int handle)
+        public KernelResult CloseHandle64([R(0)] int handle)
         {
             return CloseHandle(handle);
         }
@@ -134,7 +134,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return KernelResult.Success;
         }
 
-        public KernelResult ResetSignal64(int handle)
+        public KernelResult ResetSignal64([R(0)] int handle)
         {
             return ResetSignal(handle);
         }
@@ -173,7 +173,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -203,7 +203,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
                 : 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);
         }
@@ -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);
         }
@@ -247,7 +247,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -478,7 +478,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -506,7 +506,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -560,7 +560,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }

Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcTable.cs

@@ -3,6 +3,7 @@ using Ryujinx.Common.Logging;
 using Ryujinx.HLE.HOS.Kernel.Common;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
 
@@ -10,15 +11,19 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 {
     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;
-
-        private static Action<SvcHandler, ExecutionContext>[] _svcTable64;
+        public static Action<SvcHandler, ExecutionContext>[] SvcTable32 { get; }
+        public static Action<SvcHandler, ExecutionContext>[] SvcTable64 { get; }
 
         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)                   },
                 { 0x03, nameof(SvcHandler.SetMemoryAttribute64)            },
@@ -78,25 +83,23 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
                 { 0x7B, nameof(SvcHandler.TerminateProcess64)              }
             };
 
-            _svcTable64 = new Action<SvcHandler, ExecutionContext>[0x80];
-        }
-
-        public static Action<SvcHandler, ExecutionContext> GetSvcFunc(int svcId)
-        {
-            if (_svcTable64[svcId] != null)
+            foreach (KeyValuePair<int, string> value in svcFuncs64)
             {
-                return _svcTable64[svcId];
+                SvcTable64[value.Key] = GenerateMethod(value.Value, SvcFuncMaxArguments64);
             }
 
-            if (_svcFuncs64.TryGetValue(svcId, out string svcName))
+            Dictionary<int, string> svcFuncs32 = new Dictionary<int, string>
             {
-                return _svcTable64[svcId] = GenerateMethod(svcName);
-            }
+                // TODO
+            };
 
-            return null;
+            foreach (KeyValuePair<int, string> value in svcFuncs32)
+            {
+                SvcTable32[value.Key] = GenerateMethod(value.Value, SvcFuncMaxArguments32);
+            }
         }
 
-        private static Action<SvcHandler, ExecutionContext> GenerateMethod(string svcName)
+        private static Action<SvcHandler, ExecutionContext> GenerateMethod(string svcName, int registerCleanCount)
         {
             Type[] argTypes = new Type[] { typeof(SvcHandler), typeof(ExecutionContext) };
 
@@ -106,11 +109,6 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 
             ParameterInfo[] methodArgs = methodInfo.GetParameters();
 
-            if (methodArgs.Length > SvcFuncMaxArguments)
-            {
-                throw new InvalidOperationException($"Method \"{svcName}\" has too many arguments, max is 8.");
-            }
-
             ILGenerator generator = method.GetILGenerator();
 
             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
             // are used to hold pointers where the value will be stored,
             // 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;
 
-                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}},";
 
                     generator.Emit(OpCodes.Dup);
                     generator.Emit(OpCodes.Ldc_I4, index);
 
                     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));
 
@@ -200,7 +220,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 
                 argsFormat = argsFormat.Substring(0, argsFormat.Length - 1);
 
-                generator.Emit(OpCodes.Ldstr, argsFormat);
+               generator.Emit(OpCodes.Ldstr, argsFormat);
             }
             else
             {
@@ -216,11 +236,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             // Call the SVC function handler.
             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++)
             {
                 Type argType = methodArgs[index].ParameterType;
+                RAttribute registerAttribute = GetRegisterAttribute(methodArgs[index]);
 
                 if (argType.IsByRef)
                 {
@@ -228,12 +249,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 
                     LocalBuilder local = generator.DeclareLocal(argType);
 
-                    locals.Add(local);
+                    locals.Add((local, registerAttribute));
 
                     if (!methodArgs[index].IsOut)
                     {
                         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));
 
@@ -249,7 +270,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
                 else
                 {
                     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));
 
@@ -261,8 +282,6 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 
             generator.Emit(OpCodes.Call, methodInfo);
 
-            int outRegIndex = 0;
-
             Type retType = methodInfo.ReturnType;
 
             // Print result code.
@@ -275,6 +294,8 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
                 generator.Emit(OpCodes.Call, printResultMethod);
             }
 
+            uint registerInUse = 0;
+
             // Save return value into register X0 (when the method has a return value).
             if (retType != typeof(void))
             {
@@ -284,7 +305,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 
                 generator.Emit(OpCodes.Stloc, tempLocal);
                 generator.Emit(OpCodes.Ldarg_1);
-                generator.Emit(OpCodes.Ldc_I4, outRegIndex++);
+                generator.Emit(OpCodes.Ldc_I4, 0);
                 generator.Emit(OpCodes.Ldloc, tempLocal);
 
                 ConvertToFieldType(retType);
@@ -292,26 +313,36 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
                 MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX));
 
                 generator.Emit(OpCodes.Call, info);
+
+                registerInUse |= 1u << 0;
             }
 
             for (int index = 0; index < locals.Count; index++)
             {
+                (LocalBuilder local, RAttribute attribute) = locals[index];
                 generator.Emit(OpCodes.Ldarg_1);
-                generator.Emit(OpCodes.Ldc_I4, outRegIndex++);
-                generator.Emit(OpCodes.Ldloc, locals[index]);
+                generator.Emit(OpCodes.Ldc_I4, attribute.Index);
+                generator.Emit(OpCodes.Ldloc, local);
 
-                ConvertToFieldType(locals[index].LocalType);
+                ConvertToFieldType(local.LocalType);
 
                 MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX));
 
                 generator.Emit(OpCodes.Call, info);
+
+                registerInUse |= 1u << attribute.Index;
             }
 
             // 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.Ldc_I4, outRegIndex++);
+                generator.Emit(OpCodes.Ldc_I4, i);
                 generator.Emit(OpCodes.Ldc_I8, 0L);
 
                 MethodInfo info = typeof(ExecutionContext).GetMethod(nameof(ExecutionContext.SetX));

Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcThread.cs

@@ -9,12 +9,12 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
     partial class SvcHandler
     {
         public KernelResult CreateThread64(
-            ulong   entrypoint,
-            ulong   argsPtr,
-            ulong   stackTop,
-            int     priority,
-            int     cpuCore,
-            out int handle)
+            [R(1)] ulong   entrypoint,
+            [R(2)] ulong   argsPtr,
+            [R(3)] ulong   stackTop,
+            [R(4)] int     priority,
+            [R(5)] int     cpuCore,
+            [R(1)] out int handle)
         {
             return CreateThread(entrypoint, argsPtr, stackTop, priority, cpuCore, out handle);
         }
@@ -78,7 +78,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return result;
         }
 
-        public KernelResult StartThread64(int handle)
+        public KernelResult StartThread64([R(0)] int handle)
         {
             return StartThread(handle);
         }
@@ -122,7 +122,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             currentThread.Exit();
         }
 
-        public void SleepThread64(long timeout)
+        public void SleepThread64([R(0)] long 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);
         }
@@ -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);
         }
@@ -190,7 +190,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -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);
         }
@@ -271,7 +271,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -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);
         }
@@ -321,7 +321,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }

Ryujinx.HLE/HOS/Kernel/SupervisorCall/SvcThreadSync.cs

@@ -7,7 +7,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 {
     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);
         }
@@ -40,7 +40,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return _system.Synchronization.WaitFor(syncObjs.ToArray(), timeout, out handleIndex);
         }
 
-        public KernelResult CancelSynchronization64(int handle)
+        public KernelResult CancelSynchronization64([R(0)] int handle)
         {
             return CancelSynchronization(handle);
         }
@@ -59,7 +59,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -81,7 +81,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return currentProcess.AddressArbiter.ArbitrateLock(ownerHandle, mutexAddress, requesterHandle);
         }
 
-        public KernelResult ArbitrateUnlock64(ulong mutexAddress)
+        public KernelResult ArbitrateUnlock64([R(0)] ulong mutexAddress)
         {
             return ArbitrateUnlock(mutexAddress);
         }
@@ -104,10 +104,10 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
         }
 
         public KernelResult WaitProcessWideKeyAtomic64(
-            ulong mutexAddress,
-            ulong condVarAddress,
-            int   handle,
-            long  timeout)
+            [R(0)] ulong mutexAddress,
+            [R(1)] ulong condVarAddress,
+            [R(2)] int   handle,
+            [R(3)] long  timeout)
         {
             return WaitProcessWideKeyAtomic(mutexAddress, condVarAddress, handle, timeout);
         }
@@ -137,7 +137,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
                 timeout);
         }
 
-        public KernelResult SignalProcessWideKey64(ulong address, int count)
+        public KernelResult SignalProcessWideKey64([R(0)] ulong address, [R(1)] int count)
         {
             return SignalProcessWideKey(address, count);
         }
@@ -151,7 +151,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }
@@ -194,7 +194,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             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);
         }