Remove MultiRange Min/MaxAddress and rename GetSlice to Slice (#4566)

* Delete MinAddress and MaxAddress from MultiRange

* Rename MultiRange.GetSlice to MultiRange.Slice

.github/workflows/flatpak.yml

@@ -0,0 +1,171 @@
+name: Flatpak release job
+
+on:
+  workflow_call:
+    inputs:
+      ryujinx_version:
+        required: true
+        type: string
+
+
+concurrency: flatpak-release
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    env:
+      NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
+      GIT_COMMITTER_NAME: "RyujinxBot"
+      GIT_COMMITTER_EMAIL: "61127645+RyujinxBot@users.noreply.github.com"
+      RYUJINX_PROJECT_FILE: "Ryujinx/Ryujinx.csproj"
+      NUGET_SOURCES_DESTDIR: "nuget-sources"
+      RYUJINX_VERSION: "${{ inputs.ryujinx_version }}"
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          path: Ryujinx
+
+      - uses: actions/setup-dotnet@v3
+        with:
+          global-json-file: Ryujinx/global.json
+
+      - name: Get version info
+        id: version_info
+        working-directory: Ryujinx
+        run: |
+          echo "git_hash=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+
+      - uses: actions/checkout@v3
+        with:
+          repository: flathub/org.ryujinx.Ryujinx
+          token: ${{ secrets.RYUJINX_BOT_PAT }}
+          submodules: recursive
+          path: flathub
+
+      - name: Install dependencies
+        run: python -m pip install PyYAML lxml
+
+      - name: Restore Nuget packages
+        run: dotnet restore Ryujinx/${{ env.RYUJINX_PROJECT_FILE }}
+
+      - name: Generate nuget_sources.json
+        shell: python
+        run: |
+          from pathlib import Path
+          import base64
+          import binascii
+          import json
+          import os
+
+          sources = []
+
+          for path in Path(os.environ['NUGET_PACKAGES']).glob('**/*.nupkg.sha512'):
+            name = path.parent.parent.name
+            version = path.parent.name
+            filename = '{}.{}.nupkg'.format(name, version)
+            url = 'https://api.nuget.org/v3-flatcontainer/{}/{}/{}'.format(name, version, filename)
+
+            with path.open() as fp:
+                sha512 = binascii.hexlify(base64.b64decode(fp.read())).decode('ascii')
+
+            sources.append({
+                'type': 'file',
+                'url': url,
+                'sha512': sha512,
+                'dest': os.environ['NUGET_SOURCES_DESTDIR'],
+                'dest-filename': filename,
+            })
+
+          with open('flathub/nuget_sources.json', 'w') as fp:
+            json.dump(sources, fp, indent=4)
+
+      - name: Update flatpak metadata
+        id: metadata
+        env:
+          RYUJINX_GIT_HASH: ${{ steps.version_info.outputs.git_hash }}
+        shell: python
+        run: |
+          import hashlib
+          import hmac
+          import json
+          import os
+          import yaml
+          from datetime import datetime
+          from lxml import etree
+          
+          
+          # Ensure we don't destroy multiline strings
+          def str_presenter(dumper, data):
+            if len(data.splitlines()) > 1:
+              return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
+            return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+            
+            
+          yaml.representer.SafeRepresenter.add_representer(str, str_presenter)
+  
+          yaml_file = "flathub/org.ryujinx.Ryujinx.yml"
+          xml_file = "flathub/org.ryujinx.Ryujinx.appdata.xml"
+
+          with open(yaml_file, "r") as f:
+            data = yaml.safe_load(f)
+
+          for source in data["modules"][0]["sources"]:
+            if type(source) is str:
+              continue
+            if (
+              source["type"] == "git"
+              and source["url"] == "https://github.com/Ryujinx/Ryujinx.git"
+            ):
+              source["commit"] = os.environ['RYUJINX_GIT_HASH']
+
+          is_same_version = data["modules"][0]["build-options"]["env"]["RYUJINX_VERSION"] == os.environ['RYUJINX_VERSION']
+
+          with open(os.environ['GITHUB_OUTPUT'], "a") as gh_out:
+            if is_same_version:
+              gh_out.write(f"commit_message=Retry update to {os.environ['RYUJINX_VERSION']}")
+            else:
+              gh_out.write(f"commit_message=Update to {os.environ['RYUJINX_VERSION']}")
+
+          if not is_same_version:
+            data["modules"][0]["build-options"]["env"]["RYUJINX_VERSION"] = os.environ['RYUJINX_VERSION']
+
+            with open(yaml_file, "w") as f:
+                yaml.safe_dump(data, f, sort_keys=False)
+
+            parser = etree.XMLParser(remove_blank_text=True)
+            tree = etree.parse(xml_file, parser)
+
+            root = tree.getroot()
+
+            releases = root.find("releases")
+
+            element = etree.Element("release")
+            element.set("version", os.environ['RYUJINX_VERSION'])
+            element.set("date", datetime.now().date().isoformat())
+            releases.insert(0, element)
+
+            # Ensure 4 spaces
+            etree.indent(root, space="    ")
+
+            with open(xml_file, "wb") as f:
+              f.write(
+                etree.tostring(
+                  tree,
+                  pretty_print=True,
+                  encoding="UTF-8",
+                  doctype='<?xml version="1.0" encoding="UTF-8"?>',
+                )
+              )
+
+      - name: Push flatpak update
+        working-directory: flathub
+        env:
+          COMMIT_MESSAGE: ${{ steps.metadata.outputs.commit_message }}
+        run: |
+          git config user.name "${{ env.GIT_COMMITTER_NAME }}"
+          git config user.email "${{ env.GIT_COMMITTER_EMAIL }}"
+          git add .
+          git commit -m "$COMMIT_MESSAGE"
+          git push origin master

.github/workflows/release.yml

@@ -13,23 +13,22 @@ on:
 
 concurrency: release
 
+env:
+  POWERSHELL_TELEMETRY_OPTOUT: 1
+  DOTNET_CLI_TELEMETRY_OPTOUT: 1
+  RYUJINX_BASE_VERSION: "1.1"
+  RYUJINX_TARGET_RELEASE_CHANNEL_NAME: "master"
+  RYUJINX_TARGET_RELEASE_CHANNEL_OWNER: "Ryujinx"
+  RYUJINX_TARGET_RELEASE_CHANNEL_REPO: "release-channel-master"
+
 jobs:
   release:
     runs-on: windows-latest
-
-    env:
-      POWERSHELL_TELEMETRY_OPTOUT: 1
-      DOTNET_CLI_TELEMETRY_OPTOUT: 1
-      RYUJINX_BASE_VERSION: "1.1"
-      RYUJINX_TARGET_RELEASE_CHANNEL_NAME: "master"
-      RYUJINX_TARGET_RELEASE_CHANNEL_OWNER: "Ryujinx"
-      RYUJINX_TARGET_RELEASE_CHANNEL_REPO: "release-channel-master"
-
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 7.0.x
+          global-json-file: global.json
       - name: Get version info
         id: version_info
         run: |
@@ -112,3 +111,10 @@ jobs:
           owner: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}
           repo: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}
           token: ${{ secrets.RELEASE_TOKEN }}
+
+  flatpak_release:
+    uses: ./.github/workflows/flatpak.yml
+    needs: release
+    with:
+      ryujinx_version: "1.1.${{ github.run_number }}"
+    secrets: inherit

ARMeilleure/CodeGen/Arm64/CodeGenContext.cs

@@ -1,6 +1,7 @@
 using ARMeilleure.CodeGen.Linking;
 using ARMeilleure.CodeGen.RegisterAllocators;
 using ARMeilleure.IntermediateRepresentation;
+using Ryujinx.Common.Memory;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -59,7 +60,7 @@ namespace ARMeilleure.CodeGen.Arm64
 
         public CodeGenContext(AllocationResult allocResult, int maxCallArgs, int blocksCount, bool relocatable)
         {
-            _stream = new MemoryStream();
+            _stream = MemoryStreamManager.Shared.GetStream();
 
             AllocResult = allocResult;
 
@@ -265,7 +266,7 @@ namespace ARMeilleure.CodeGen.Arm64
             }
             else
             {
-                relocInfo = new RelocInfo(new RelocEntry[0]);
+                relocInfo = new RelocInfo(Array.Empty<RelocEntry>());
             }
 
             return (code, relocInfo);

ARMeilleure/CodeGen/Arm64/PreAllocator.cs

@@ -9,7 +9,7 @@ using static ARMeilleure.IntermediateRepresentation.Operation.Factory;
 
 namespace ARMeilleure.CodeGen.Arm64
 {
-    class PreAllocator
+    static class PreAllocator
     {
         private class ConstantDict
         {
@@ -54,8 +54,8 @@ namespace ARMeilleure.CodeGen.Arm64
                         continue;
                     }
 
-                    HandleConstantRegCopy(constants, block.Operations, node);
-                    HandleDestructiveRegCopy(block.Operations, node);
+                    InsertConstantRegCopies(constants, block.Operations, node);
+                    InsertDestructiveRegCopies(block.Operations, node);
 
                     switch (node.Instruction)
                     {
@@ -78,28 +78,28 @@ namespace ARMeilleure.CodeGen.Arm64
 
                             // Copy values to registers expected by the function
                             // being called, as mandated by the ABI.
-                            HandleCall(constants, block.Operations, node);
+                            InsertCallCopies(constants, block.Operations, node);
                             break;
                         case Instruction.CompareAndSwap:
                         case Instruction.CompareAndSwap16:
                         case Instruction.CompareAndSwap8:
-                            nextNode = HandleCompareAndSwap(block.Operations, node);
+                            nextNode = GenerateCompareAndSwap(block.Operations, node);
                             break;
                         case Instruction.LoadArgument:
-                            nextNode = HandleLoadArgument(cctx, ref buffer, block.Operations, preservedArgs, node);
+                            nextNode = InsertLoadArgumentCopy(cctx, ref buffer, block.Operations, preservedArgs, node);
                             break;
                         case Instruction.Return:
-                            HandleReturn(block.Operations, node);
+                            InsertReturnCopy(block.Operations, node);
                             break;
                         case Instruction.Tailcall:
-                            HandleTailcall(constants, block.Operations, stackAlloc, node, node);
+                            InsertTailcallCopies(constants, block.Operations, stackAlloc, node, node);
                             break;
                     }
                 }
             }
         }
 
-        private static void HandleConstantRegCopy(ConstantDict constants, IntrusiveList<Operation> nodes, Operation node)
+        private static void InsertConstantRegCopies(ConstantDict constants, IntrusiveList<Operation> nodes, Operation node)
         {
             if (node.SourcesCount == 0 || IsIntrinsicWithConst(node))
             {
@@ -211,7 +211,7 @@ namespace ARMeilleure.CodeGen.Arm64
             }
         }
 
-        private static void HandleDestructiveRegCopy(IntrusiveList<Operation> nodes, Operation node)
+        private static void InsertDestructiveRegCopies(IntrusiveList<Operation> nodes, Operation node)
         {
             if (node.Destination == default || node.SourcesCount == 0)
             {
@@ -259,7 +259,7 @@ namespace ARMeilleure.CodeGen.Arm64
             }
         }
 
-        private static void HandleCall(ConstantDict constants, IntrusiveList<Operation> nodes, Operation node)
+        private static void InsertCallCopies(ConstantDict constants, IntrusiveList<Operation> nodes, Operation node)
         {
             Operation operation = node;
 
@@ -319,7 +319,7 @@ namespace ARMeilleure.CodeGen.Arm64
 
                     Operation copyOp = Operation(Instruction.Copy, argReg, source);
 
-                    HandleConstantRegCopy(constants, nodes, nodes.AddBefore(node, copyOp));
+                    InsertConstantRegCopies(constants, nodes, nodes.AddBefore(node, copyOp));
 
                     sources.Add(argReg);
                 }
@@ -329,7 +329,7 @@ namespace ARMeilleure.CodeGen.Arm64
 
                     Operation spillOp = Operation(Instruction.SpillArg, default, offset, source);
 
-                    HandleConstantRegCopy(constants, nodes, nodes.AddBefore(node, spillOp));
+                    InsertConstantRegCopies(constants, nodes, nodes.AddBefore(node, spillOp));
 
                     stackOffset += source.Type.GetSizeInBytes();
                 }
@@ -364,7 +364,7 @@ namespace ARMeilleure.CodeGen.Arm64
             operation.SetSources(sources.ToArray());
         }
 
-        private static void HandleTailcall(
+        private static void InsertTailcallCopies(
             ConstantDict constants,
             IntrusiveList<Operation> nodes,
             StackAllocator stackAlloc,
@@ -420,7 +420,7 @@ namespace ARMeilleure.CodeGen.Arm64
 
                     Operation copyOp = Operation(Instruction.Copy, argReg, source);
 
-                    HandleConstantRegCopy(constants, nodes, nodes.AddBefore(node, copyOp));
+                    InsertConstantRegCopies(constants, nodes, nodes.AddBefore(node, copyOp));
 
                     sources.Add(argReg);
                 }
@@ -444,7 +444,7 @@ namespace ARMeilleure.CodeGen.Arm64
             operation.SetSources(sources.ToArray());
         }
 
-        private static Operation HandleCompareAndSwap(IntrusiveList<Operation> nodes, Operation node)
+        private static Operation GenerateCompareAndSwap(IntrusiveList<Operation> nodes, Operation node)
         {
             Operand expected = node.GetSource(1);
 
@@ -508,7 +508,7 @@ namespace ARMeilleure.CodeGen.Arm64
             return node.ListNext;
         }
 
-        private static void HandleReturn(IntrusiveList<Operation> nodes, Operation node)
+        private static void InsertReturnCopy(IntrusiveList<Operation> nodes, Operation node)
         {
             if (node.SourcesCount == 0)
             {
@@ -537,7 +537,7 @@ namespace ARMeilleure.CodeGen.Arm64
             }
         }
 
-        private static Operation HandleLoadArgument(
+        private static Operation InsertLoadArgumentCopy(
             CompilerContext cctx,
             ref Span<Operation> buffer,
             IntrusiveList<Operation> nodes,
@@ -629,7 +629,7 @@ namespace ARMeilleure.CodeGen.Arm64
                 if (dest.AssignmentsCount == 1)
                 {
                     // Let's propagate the argument if we can to avoid copies.
-                    Propagate(ref buffer, dest, preservedArgs[index]);
+                    PreAllocatorCommon.Propagate(ref buffer, dest, preservedArgs[index]);
                     nextNode = node.ListNext;
                 }
                 else
@@ -648,54 +648,6 @@ namespace ARMeilleure.CodeGen.Arm64
             }
         }
 
-        private static void Propagate(ref Span<Operation> buffer, Operand dest, Operand value)
-        {
-            ReadOnlySpan<Operation> uses = dest.GetUses(ref buffer);
-
-            foreach (Operation use in uses)
-            {
-                for (int srcIndex = 0; srcIndex < use.SourcesCount; srcIndex++)
-                {
-                    Operand useSrc = use.GetSource(srcIndex);
-
-                    if (useSrc == dest)
-                    {
-                        use.SetSource(srcIndex, value);
-                    }
-                    else if (useSrc.Kind == OperandKind.Memory)
-                    {
-                        MemoryOperand memoryOp = useSrc.GetMemory();
-
-                        Operand baseAddr = memoryOp.BaseAddress;
-                        Operand index = memoryOp.Index;
-                        bool changed = false;
-
-                        if (baseAddr == dest)
-                        {
-                            baseAddr = value;
-                            changed = true;
-                        }
-
-                        if (index == dest)
-                        {
-                            index = value;
-                            changed = true;
-                        }
-
-                        if (changed)
-                        {
-                            use.SetSource(srcIndex, MemoryOp(
-                                useSrc.Type,
-                                baseAddr,
-                                index,
-                                memoryOp.Scale,
-                                memoryOp.Displacement));
-                        }
-                    }
-                }
-            }
-        }
-
         private static Operand AddFloatConstantCopy(
             ConstantDict constants,
             IntrusiveList<Operation> nodes,

ARMeilleure/CodeGen/PreAllocatorCommon.cs

@@ -0,0 +1,57 @@
+using ARMeilleure.IntermediateRepresentation;
+using System;
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+
+namespace ARMeilleure.CodeGen
+{
+    static class PreAllocatorCommon
+    {
+        public static void Propagate(ref Span<Operation> buffer, Operand dest, Operand value)
+        {
+            ReadOnlySpan<Operation> uses = dest.GetUses(ref buffer);
+
+            foreach (Operation use in uses)
+            {
+                for (int srcIndex = 0; srcIndex < use.SourcesCount; srcIndex++)
+                {
+                    Operand useSrc = use.GetSource(srcIndex);
+
+                    if (useSrc == dest)
+                    {
+                        use.SetSource(srcIndex, value);
+                    }
+                    else if (useSrc.Kind == OperandKind.Memory)
+                    {
+                        MemoryOperand memoryOp = useSrc.GetMemory();
+
+                        Operand baseAddr = memoryOp.BaseAddress;
+                        Operand index = memoryOp.Index;
+                        bool changed = false;
+
+                        if (baseAddr == dest)
+                        {
+                            baseAddr = value;
+                            changed = true;
+                        }
+
+                        if (index == dest)
+                        {
+                            index = value;
+                            changed = true;
+                        }
+
+                        if (changed)
+                        {
+                            use.SetSource(srcIndex, MemoryOp(
+                                useSrc.Type,
+                                baseAddr,
+                                index,
+                                memoryOp.Scale,
+                                memoryOp.Displacement));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

ARMeilleure/CodeGen/RegisterAllocators/LinearScanAllocator.cs

@@ -433,16 +433,11 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
 
         private static int GetHighestValueIndex(Span<int> span)
         {
-            int highest = span[0];
-
-            if (highest == int.MaxValue)
-            {
-                return 0;
-            }
+            int highest = int.MinValue;
 
             int selected = 0;
 
-            for (int index = 1; index < span.Length; index++)
+            for (int index = 0; index < span.Length; index++)
             {
                 int current = span[index];
 

ARMeilleure/CodeGen/X86/Assembler.cs

@@ -1,5 +1,6 @@
 using ARMeilleure.CodeGen.Linking;
 using ARMeilleure.IntermediateRepresentation;
+using Ryujinx.Common.Memory;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -1285,7 +1286,7 @@ namespace ARMeilleure.CodeGen.X86
             // Write the code, ignoring the dummy bytes after jumps, into a new stream.
             _stream.Seek(0, SeekOrigin.Begin);
 
-            using var codeStream = new MemoryStream();
+            using var codeStream = MemoryStreamManager.Shared.GetStream();
             var assembler = new Assembler(codeStream, HasRelocs);
 
             bool hasRelocs = HasRelocs;

ARMeilleure/CodeGen/X86/CodeGenContext.cs

@@ -1,5 +1,6 @@
 using ARMeilleure.CodeGen.RegisterAllocators;
 using ARMeilleure.IntermediateRepresentation;
+using Ryujinx.Common.Memory;
 using System.IO;
 using System.Numerics;
 
@@ -22,7 +23,7 @@ namespace ARMeilleure.CodeGen.X86
 
         public CodeGenContext(AllocationResult allocResult, int maxCallArgs, int blocksCount, bool relocatable)
         {
-            _stream = new MemoryStream();
+            _stream = MemoryStreamManager.Shared.GetStream();
             _blockLabels = new Operand[blocksCount];
 
             AllocResult = allocResult;

ARMeilleure/CodeGen/X86/PreAllocator.cs

@@ -2,19 +2,20 @@ using ARMeilleure.CodeGen.RegisterAllocators;
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.Translation;
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
 using static ARMeilleure.IntermediateRepresentation.Operation.Factory;
 
 namespace ARMeilleure.CodeGen.X86
 {
-    static class PreAllocator
+    class PreAllocator
     {
         public static void RunPass(CompilerContext cctx, StackAllocator stackAlloc, out int maxCallArgs)
         {
             maxCallArgs = -1;
 
+            Span<Operation> buffer = default;
+
             CallConvName callConv = CallingConvention.GetCurrentCallConv();
 
             Operand[] preservedArgs = new Operand[CallingConvention.GetArgumentsOnRegsCount()];
@@ -32,9 +33,9 @@ namespace ARMeilleure.CodeGen.X86
                         continue;
                     }
 
-                    HandleConstantRegCopy(block.Operations, node);
-                    HandleDestructiveRegCopy(block.Operations, node);
-                    HandleConstrainedRegCopy(block.Operations, node);
+                    InsertConstantRegCopies(block.Operations, node);
+                    InsertDestructiveRegCopies(block.Operations, node);
+                    InsertConstrainedRegCopies(block.Operations, node);
 
                     switch (node.Instruction)
                     {
@@ -59,62 +60,62 @@ namespace ARMeilleure.CodeGen.X86
                             // being called, as mandated by the ABI.
                             if (callConv == CallConvName.Windows)
                             {
-                                HandleCallWindowsAbi(block.Operations, stackAlloc, node);
+                                PreAllocatorWindows.InsertCallCopies(block.Operations, stackAlloc, node);
                             }
                             else /* if (callConv == CallConvName.SystemV) */
                             {
-                                HandleCallSystemVAbi(block.Operations, node);
+                                PreAllocatorSystemV.InsertCallCopies(block.Operations, node);
                             }
                             break;
 
                         case Instruction.ConvertToFPUI:
-                            HandleConvertToFPUI(block.Operations, node);
+                            GenerateConvertToFPUI(block.Operations, node);
                             break;
 
                         case Instruction.LoadArgument:
                             if (callConv == CallConvName.Windows)
                             {
-                                nextNode = HandleLoadArgumentWindowsAbi(cctx, block.Operations, preservedArgs, node);
+                                nextNode = PreAllocatorWindows.InsertLoadArgumentCopy(cctx, ref buffer, block.Operations, preservedArgs, node);
                             }
                             else /* if (callConv == CallConvName.SystemV) */
                             {
-                                nextNode = HandleLoadArgumentSystemVAbi(cctx, block.Operations, preservedArgs, node);
+                                nextNode = PreAllocatorSystemV.InsertLoadArgumentCopy(cctx, ref buffer, block.Operations, preservedArgs, node);
                             }
                             break;
 
                         case Instruction.Negate:
                             if (!node.GetSource(0).Type.IsInteger())
                             {
-                                HandleNegate(block.Operations, node);
+                                GenerateNegate(block.Operations, node);
                             }
                             break;
 
                         case Instruction.Return:
                             if (callConv == CallConvName.Windows)
                             {
-                                HandleReturnWindowsAbi(cctx, block.Operations, preservedArgs, node);
+                                PreAllocatorWindows.InsertReturnCopy(cctx, block.Operations, preservedArgs, node);
                             }
                             else /* if (callConv == CallConvName.SystemV) */
                             {
-                                HandleReturnSystemVAbi(block.Operations, node);
+                                PreAllocatorSystemV.InsertReturnCopy(block.Operations, node);
                             }
                             break;
 
                         case Instruction.Tailcall:
                             if (callConv == CallConvName.Windows)
                             {
-                                HandleTailcallWindowsAbi(block.Operations, stackAlloc, node);
+                                PreAllocatorWindows.InsertTailcallCopies(block.Operations, stackAlloc, node);
                             }
                             else
                             {
-                                HandleTailcallSystemVAbi(block.Operations, stackAlloc, node);
+                                PreAllocatorSystemV.InsertTailcallCopies(block.Operations, stackAlloc, node);
                             }
                             break;
 
                         case Instruction.VectorInsert8:
                             if (!HardwareCapabilities.SupportsSse41)
                             {
-                                HandleVectorInsert8(block.Operations, node);
+                                GenerateVectorInsert8(block.Operations, node);
                             }
                             break;
 
@@ -131,7 +132,7 @@ namespace ARMeilleure.CodeGen.X86
             }
         }
 
-        private static void HandleConstantRegCopy(IntrusiveList<Operation> nodes, Operation node)
+        protected static void InsertConstantRegCopies(IntrusiveList<Operation> nodes, Operation node)
         {
             if (node.SourcesCount == 0 || IsXmmIntrinsic(node))
             {
@@ -212,7 +213,7 @@ namespace ARMeilleure.CodeGen.X86
             }
         }
 
-        private static void HandleConstrainedRegCopy(IntrusiveList<Operation> nodes, Operation node)
+        protected static void InsertConstrainedRegCopies(IntrusiveList<Operation> nodes, Operation node)
         {
             Operand dest = node.Destination;
 
@@ -369,7 +370,7 @@ namespace ARMeilleure.CodeGen.X86
             }
         }
 
-        private static void HandleDestructiveRegCopy(IntrusiveList<Operation> nodes, Operation node)
+        protected static void InsertDestructiveRegCopies(IntrusiveList<Operation> nodes, Operation node)
         {
             if (node.Destination == default || node.SourcesCount == 0)
             {
@@ -447,7 +448,7 @@ namespace ARMeilleure.CodeGen.X86
             }
         }
 
-        private static void HandleConvertToFPUI(IntrusiveList<Operation> nodes, Operation node)
+        private static void GenerateConvertToFPUI(IntrusiveList<Operation> nodes, Operation node)
         {
             // Unsigned integer to FP conversions are not supported on X86.
             // We need to turn them into signed integer to FP conversions, and
@@ -501,7 +502,7 @@ namespace ARMeilleure.CodeGen.X86
             Delete(nodes, currentNode);
         }
 
-        private static void HandleNegate(IntrusiveList<Operation> nodes, Operation node)
+        private static void GenerateNegate(IntrusiveList<Operation> nodes, Operation node)
         {
             // There's no SSE FP negate instruction, so we need to transform that into
             // a XOR of the value to be negated with a mask with the highest bit set.
@@ -534,7 +535,7 @@ namespace ARMeilleure.CodeGen.X86
             Delete(nodes, currentNode);
         }
 
-        private static void HandleVectorInsert8(IntrusiveList<Operation> nodes, Operation node)
+        private static void GenerateVectorInsert8(IntrusiveList<Operation> nodes, Operation node)
         {
             // Handle vector insertion, when SSE 4.1 is not supported.
             Operand dest = node.Destination;
@@ -579,620 +580,7 @@ namespace ARMeilleure.CodeGen.X86
             Delete(nodes, currentNode);
         }
 
-        private static void HandleCallWindowsAbi(IntrusiveList<Operation> nodes, StackAllocator stackAlloc, Operation node)
-        {
-            Operand dest = node.Destination;
-
-            // Handle struct arguments.
-            int retArgs = 0;
-            int stackAllocOffset = 0;
-
-            int AllocateOnStack(int size)
-            {
-                // We assume that the stack allocator is initially empty (TotalSize = 0).
-                // Taking that into account, we can reuse the space allocated for other
-                // calls by keeping track of our own allocated size (stackAllocOffset).
-                // If the space allocated is not big enough, then we just expand it.
-                int offset = stackAllocOffset;
-
-                if (stackAllocOffset + size > stackAlloc.TotalSize)
-                {
-                    stackAlloc.Allocate((stackAllocOffset + size) - stackAlloc.TotalSize);
-                }
-
-                stackAllocOffset += size;
-
-                return offset;
-            }
-
-            Operand arg0Reg = default;
-
-            if (dest != default && dest.Type == OperandType.V128)
-            {
-                int stackOffset = AllocateOnStack(dest.Type.GetSizeInBytes());
-
-                arg0Reg = Gpr(CallingConvention.GetIntArgumentRegister(0), OperandType.I64);
-
-                Operation allocOp = Operation(Instruction.StackAlloc, arg0Reg, Const(stackOffset));
-
-                nodes.AddBefore(node, allocOp);
-
-                retArgs = 1;
-            }
-
-            int argsCount = node.SourcesCount - 1;
-            int maxArgs = CallingConvention.GetArgumentsOnRegsCount() - retArgs;
-
-            if (argsCount > maxArgs)
-            {
-                argsCount = maxArgs;
-            }
-
-            Operand[] sources = new Operand[1 + retArgs + argsCount];
-
-            sources[0] = node.GetSource(0);
-
-            if (arg0Reg != default)
-            {
-                sources[1] = arg0Reg;
-            }
-
-            for (int index = 1; index < node.SourcesCount; index++)
-            {
-                Operand source = node.GetSource(index);
-
-                if (source.Type == OperandType.V128)
-                {
-                    Operand stackAddr = Local(OperandType.I64);
-
-                    int stackOffset = AllocateOnStack(source.Type.GetSizeInBytes());
-
-                    nodes.AddBefore(node, Operation(Instruction.StackAlloc, stackAddr, Const(stackOffset)));
-
-                    Operation storeOp = Operation(Instruction.Store, default, stackAddr, source);
-
-                    HandleConstantRegCopy(nodes, nodes.AddBefore(node, storeOp));
-
-                    node.SetSource(index, stackAddr);
-                }
-            }
-
-            // Handle arguments passed on registers.
-            for (int index = 0; index < argsCount; index++)
-            {
-                Operand source = node.GetSource(index + 1);
-                Operand argReg;
-
-                int argIndex = index + retArgs;
-
-                if (source.Type.IsInteger())
-                {
-                    argReg = Gpr(CallingConvention.GetIntArgumentRegister(argIndex), source.Type);
-                }
-                else
-                {
-                    argReg = Xmm(CallingConvention.GetVecArgumentRegister(argIndex), source.Type);
-                }
-
-                Operation copyOp = Operation(Instruction.Copy, argReg, source);
-
-                HandleConstantRegCopy(nodes, nodes.AddBefore(node, copyOp));
-
-                sources[1 + retArgs + index] = argReg;
-            }
-
-            // The remaining arguments (those that are not passed on registers)
-            // should be passed on the stack, we write them to the stack with "SpillArg".
-            for (int index = argsCount; index < node.SourcesCount - 1; index++)
-            {
-                Operand source = node.GetSource(index + 1);
-                Operand offset = Const((index + retArgs) * 8);
-
-                Operation spillOp = Operation(Instruction.SpillArg, default, offset, source);
-
-                HandleConstantRegCopy(nodes, nodes.AddBefore(node, spillOp));
-            }
-
-            if (dest != default)
-            {
-                if (dest.Type == OperandType.V128)
-                {
-                    Operand retValueAddr = Local(OperandType.I64);
-
-                    nodes.AddBefore(node, Operation(Instruction.Copy, retValueAddr, arg0Reg));
-
-                    Operation loadOp = Operation(Instruction.Load, dest, retValueAddr);
-
-                    nodes.AddAfter(node, loadOp);
-
-                    node.Destination = default;
-                }
-                else
-                {
-                    Operand retReg = dest.Type.IsInteger()
-                        ? Gpr(CallingConvention.GetIntReturnRegister(), dest.Type)
-                        : Xmm(CallingConvention.GetVecReturnRegister(), dest.Type);
-
-                    Operation copyOp = Operation(Instruction.Copy, dest, retReg);
-
-                    nodes.AddAfter(node, copyOp);
-
-                    node.Destination = retReg;
-                }
-            }
-
-            node.SetSources(sources);
-        }
-
-        private static void HandleCallSystemVAbi(IntrusiveList<Operation> nodes, Operation node)
-        {
-            Operand dest = node.Destination;
-
-            List<Operand> sources = new List<Operand>
-            {
-                node.GetSource(0)
-            };
-
-            int argsCount = node.SourcesCount - 1;
-
-            int intMax = CallingConvention.GetIntArgumentsOnRegsCount();
-            int vecMax = CallingConvention.GetVecArgumentsOnRegsCount();
-
-            int intCount = 0;
-            int vecCount = 0;
-
-            int stackOffset = 0;
-
-            for (int index = 0; index < argsCount; index++)
-            {
-                Operand source = node.GetSource(index + 1);
-
-                bool passOnReg;
-
-                if (source.Type.IsInteger())
-                {
-                    passOnReg = intCount < intMax;
-                }
-                else if (source.Type == OperandType.V128)
-                {
-                    passOnReg = intCount + 1 < intMax;
-                }
-                else
-                {
-                    passOnReg = vecCount < vecMax;
-                }
-
-                if (source.Type == OperandType.V128 && passOnReg)
-                {
-                    // V128 is a struct, we pass each half on a GPR if possible.
-                    Operand argReg  = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-                    Operand argReg2 = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg,  source, Const(0)));
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg2, source, Const(1)));
-
-                    continue;
-                }
-
-                if (passOnReg)
-                {
-                    Operand argReg = source.Type.IsInteger()
-                        ? Gpr(CallingConvention.GetIntArgumentRegister(intCount++), source.Type)
-                        : Xmm(CallingConvention.GetVecArgumentRegister(vecCount++), source.Type);
-
-                    Operation copyOp = Operation(Instruction.Copy, argReg, source);
-
-                    HandleConstantRegCopy(nodes, nodes.AddBefore(node, copyOp));
-
-                    sources.Add(argReg);
-                }
-                else
-                {
-                    Operand offset = Const(stackOffset);
-
-                    Operation spillOp = Operation(Instruction.SpillArg, default, offset, source);
-
-                    HandleConstantRegCopy(nodes, nodes.AddBefore(node, spillOp));
-
-                    stackOffset += source.Type.GetSizeInBytes();
-                }
-            }
-
-            node.SetSources(sources.ToArray());
-
-            if (dest != default)
-            {
-                if (dest.Type == OperandType.V128)
-                {
-                    Operand retLReg = Gpr(CallingConvention.GetIntReturnRegister(),     OperandType.I64);
-                    Operand retHReg = Gpr(CallingConvention.GetIntReturnRegisterHigh(), OperandType.I64);
-
-                    Operation operation = node;
-
-                    node = nodes.AddAfter(node, Operation(Instruction.VectorCreateScalar, dest, retLReg));
-                    nodes.AddAfter(node, Operation(Instruction.VectorInsert, dest, dest, retHReg, Const(1)));
-
-                    operation.Destination = default;
-                }
-                else
-                {
-                    Operand retReg = dest.Type.IsInteger()
-                        ? Gpr(CallingConvention.GetIntReturnRegister(), dest.Type)
-                        : Xmm(CallingConvention.GetVecReturnRegister(), dest.Type);
-
-                    Operation copyOp = Operation(Instruction.Copy, dest, retReg);
-
-                    nodes.AddAfter(node, copyOp);
-
-                    node.Destination = retReg;
-                }
-            }
-        }
-
-        private static void HandleTailcallSystemVAbi(IntrusiveList<Operation> nodes, StackAllocator stackAlloc, Operation node)
-        {
-            List<Operand> sources = new List<Operand>
-            {
-                node.GetSource(0)
-            };
-
-            int argsCount = node.SourcesCount - 1;
-
-            int intMax = CallingConvention.GetIntArgumentsOnRegsCount();
-            int vecMax = CallingConvention.GetVecArgumentsOnRegsCount();
-
-            int intCount = 0;
-            int vecCount = 0;
-
-            // Handle arguments passed on registers.
-            for (int index = 0; index < argsCount; index++)
-            {
-                Operand source = node.GetSource(1 + index);
-
-                bool passOnReg;
-
-                if (source.Type.IsInteger())
-                {
-                    passOnReg = intCount + 1 < intMax;
-                }
-                else
-                {
-                    passOnReg = vecCount < vecMax;
-                }
-
-                if (source.Type == OperandType.V128 && passOnReg)
-                {
-                    // V128 is a struct, we pass each half on a GPR if possible.
-                    Operand argReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-                    Operand argReg2 = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg, source, Const(0)));
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg2, source, Const(1)));
-
-                    continue;
-                }
-
-                if (passOnReg)
-                {
-                    Operand argReg = source.Type.IsInteger()
-                        ? Gpr(CallingConvention.GetIntArgumentRegister(intCount++), source.Type)
-                        : Xmm(CallingConvention.GetVecArgumentRegister(vecCount++), source.Type);
-
-                    Operation copyOp = Operation(Instruction.Copy, argReg, source);
-
-                    HandleConstantRegCopy(nodes, nodes.AddBefore(node, copyOp));
-
-                    sources.Add(argReg);
-                }
-                else
-                {
-                    throw new NotImplementedException("Spilling is not currently supported for tail calls. (too many arguments)");
-                }
-            }
-
-            // The target address must be on the return registers, since we
-            // don't return anything and it is guaranteed to not be a
-            // callee saved register (which would be trashed on the epilogue).
-            Operand retReg = Gpr(CallingConvention.GetIntReturnRegister(), OperandType.I64);
-
-            Operation addrCopyOp = Operation(Instruction.Copy, retReg, node.GetSource(0));
-
-            nodes.AddBefore(node, addrCopyOp);
-
-            sources[0] = retReg;
-
-            node.SetSources(sources.ToArray());
-        }
-
-        private static void HandleTailcallWindowsAbi(IntrusiveList<Operation> nodes, StackAllocator stackAlloc, Operation node)
-        {
-            int argsCount = node.SourcesCount - 1;
-            int maxArgs = CallingConvention.GetArgumentsOnRegsCount();
-
-            if (argsCount > maxArgs)
-            {
-                throw new NotImplementedException("Spilling is not currently supported for tail calls. (too many arguments)");
-            }
-
-            Operand[] sources = new Operand[1 + argsCount];
-
-            // Handle arguments passed on registers.
-            for (int index = 0; index < argsCount; index++)
-            {
-                Operand source = node.GetSource(1 + index);
-                Operand argReg = source.Type.IsInteger()
-                    ? Gpr(CallingConvention.GetIntArgumentRegister(index), source.Type)
-                    : Xmm(CallingConvention.GetVecArgumentRegister(index), source.Type);
-
-                Operation copyOp = Operation(Instruction.Copy, argReg, source);
-
-                HandleConstantRegCopy(nodes, nodes.AddBefore(node, copyOp));
-
-                sources[1 + index] = argReg;
-            }
-
-            // The target address must be on the return registers, since we
-            // don't return anything and it is guaranteed to not be a
-            // callee saved register (which would be trashed on the epilogue).
-            Operand retReg = Gpr(CallingConvention.GetIntReturnRegister(), OperandType.I64);
-
-            Operation addrCopyOp = Operation(Instruction.Copy, retReg, node.GetSource(0));
-
-            nodes.AddBefore(node, addrCopyOp);
-
-            sources[0] = retReg;
-
-            node.SetSources(sources);
-        }
-
-        private static Operation HandleLoadArgumentWindowsAbi(
-            CompilerContext cctx,
-            IntrusiveList<Operation> nodes,
-            Operand[] preservedArgs,
-            Operation node)
-        {
-            Operand source = node.GetSource(0);
-
-            Debug.Assert(source.Kind == OperandKind.Constant, "Non-constant LoadArgument source kind.");
-
-            int retArgs = cctx.FuncReturnType == OperandType.V128 ? 1 : 0;
-
-            int index = source.AsInt32() + retArgs;
-
-            if (index < CallingConvention.GetArgumentsOnRegsCount())
-            {
-                Operand dest = node.Destination;
-
-                if (preservedArgs[index] == default)
-                {
-                    Operand argReg, pArg;
-
-                    if (dest.Type.IsInteger())
-                    {
-                        argReg = Gpr(CallingConvention.GetIntArgumentRegister(index), dest.Type);
-                        pArg = Local(dest.Type);
-                    }
-                    else if (dest.Type == OperandType.V128)
-                    {
-                        argReg = Gpr(CallingConvention.GetIntArgumentRegister(index), OperandType.I64);
-                        pArg = Local(OperandType.I64);
-                    }
-                    else
-                    {
-                        argReg = Xmm(CallingConvention.GetVecArgumentRegister(index), dest.Type);
-                        pArg = Local(dest.Type);
-                    }
-
-                    Operation copyOp = Operation(Instruction.Copy, pArg, argReg);
-
-                    cctx.Cfg.Entry.Operations.AddFirst(copyOp);
-
-                    preservedArgs[index] = pArg;
-                }
-
-                Operation argCopyOp = Operation(dest.Type == OperandType.V128
-                    ? Instruction.Load
-                    : Instruction.Copy, dest, preservedArgs[index]);
-
-                Operation newNode = nodes.AddBefore(node, argCopyOp);
-
-                Delete(nodes, node);
-
-                return newNode;
-            }
-            else
-            {
-                // TODO: Pass on stack.
-                return node;
-            }
-        }
-
-        private static Operation HandleLoadArgumentSystemVAbi(
-            CompilerContext cctx,
-            IntrusiveList<Operation> nodes,
-            Operand[] preservedArgs,
-            Operation node)
-        {
-            Operand source = node.GetSource(0);
-
-            Debug.Assert(source.Kind == OperandKind.Constant, "Non-constant LoadArgument source kind.");
-
-            int index = source.AsInt32();
-
-            int intCount = 0;
-            int vecCount = 0;
-
-            for (int cIndex = 0; cIndex < index; cIndex++)
-            {
-                OperandType argType = cctx.FuncArgTypes[cIndex];
-
-                if (argType.IsInteger())
-                {
-                    intCount++;
-                }
-                else if (argType == OperandType.V128)
-                {
-                    intCount += 2;
-                }
-                else
-                {
-                    vecCount++;
-                }
-            }
-
-            bool passOnReg;
-
-            if (source.Type.IsInteger())
-            {
-                passOnReg = intCount < CallingConvention.GetIntArgumentsOnRegsCount();
-            }
-            else if (source.Type == OperandType.V128)
-            {
-                passOnReg = intCount + 1 < CallingConvention.GetIntArgumentsOnRegsCount();
-            }
-            else
-            {
-                passOnReg = vecCount < CallingConvention.GetVecArgumentsOnRegsCount();
-            }
-
-            if (passOnReg)
-            {
-                Operand dest = node.Destination;
-
-                if (preservedArgs[index] == default)
-                {
-                    if (dest.Type == OperandType.V128)
-                    {
-                        // V128 is a struct, we pass each half on a GPR if possible.
-                        Operand pArg = Local(OperandType.V128);
-
-                        Operand argLReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount),     OperandType.I64);
-                        Operand argHReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount + 1), OperandType.I64);
-
-                        Operation copyL = Operation(Instruction.VectorCreateScalar, pArg, argLReg);
-                        Operation copyH = Operation(Instruction.VectorInsert,       pArg, pArg, argHReg, Const(1));
-
-                        cctx.Cfg.Entry.Operations.AddFirst(copyH);
-                        cctx.Cfg.Entry.Operations.AddFirst(copyL);
-
-                        preservedArgs[index] = pArg;
-                    }
-                    else
-                    {
-                        Operand pArg = Local(dest.Type);
-
-                        Operand argReg = dest.Type.IsInteger()
-                            ? Gpr(CallingConvention.GetIntArgumentRegister(intCount), dest.Type)
-                            : Xmm(CallingConvention.GetVecArgumentRegister(vecCount), dest.Type);
-
-                        Operation copyOp = Operation(Instruction.Copy, pArg, argReg);
-
-                        cctx.Cfg.Entry.Operations.AddFirst(copyOp);
-
-                        preservedArgs[index] = pArg;
-                    }
-                }
-
-                Operation argCopyOp = Operation(Instruction.Copy, dest, preservedArgs[index]);
-
-                Operation newNode = nodes.AddBefore(node, argCopyOp);
-
-                Delete(nodes, node);
-
-                return newNode;
-            }
-            else
-            {
-                // TODO: Pass on stack.
-                return node;
-            }
-        }
-
-        private static void HandleReturnWindowsAbi(
-            CompilerContext cctx,
-            IntrusiveList<Operation> nodes,
-            Operand[] preservedArgs,
-            Operation node)
-        {
-            if (node.SourcesCount == 0)
-            {
-                return;
-            }
-
-            Operand source = node.GetSource(0);
-            Operand retReg;
-
-            if (source.Type.IsInteger())
-            {
-                retReg = Gpr(CallingConvention.GetIntReturnRegister(), source.Type);
-            }
-            else if (source.Type == OperandType.V128)
-            {
-                if (preservedArgs[0] == default)
-                {
-                    Operand preservedArg = Local(OperandType.I64);
-                    Operand arg0 = Gpr(CallingConvention.GetIntArgumentRegister(0), OperandType.I64);
-
-                    Operation copyOp = Operation(Instruction.Copy, preservedArg, arg0);
-
-                    cctx.Cfg.Entry.Operations.AddFirst(copyOp);
-
-                    preservedArgs[0] = preservedArg;
-                }
-
-                retReg = preservedArgs[0];
-            }
-            else
-            {
-                retReg = Xmm(CallingConvention.GetVecReturnRegister(), source.Type);
-            }
-
-            if (source.Type == OperandType.V128)
-            {
-                Operation retStoreOp = Operation(Instruction.Store, default, retReg, source);
-
-                nodes.AddBefore(node, retStoreOp);
-            }
-            else
-            {
-                Operation retCopyOp = Operation(Instruction.Copy, retReg, source);
-
-                nodes.AddBefore(node, retCopyOp);
-            }
-
-            node.SetSources(Array.Empty<Operand>());
-        }
-
-        private static void HandleReturnSystemVAbi(IntrusiveList<Operation> nodes, Operation node)
-        {
-            if (node.SourcesCount == 0)
-            {
-                return;
-            }
-
-            Operand source = node.GetSource(0);
-
-            if (source.Type == OperandType.V128)
-            {
-                Operand retLReg = Gpr(CallingConvention.GetIntReturnRegister(),     OperandType.I64);
-                Operand retHReg = Gpr(CallingConvention.GetIntReturnRegisterHigh(), OperandType.I64);
-
-                nodes.AddBefore(node, Operation(Instruction.VectorExtract, retLReg, source, Const(0)));
-                nodes.AddBefore(node, Operation(Instruction.VectorExtract, retHReg, source, Const(1)));
-            }
-            else
-            {
-                Operand retReg = source.Type.IsInteger()
-                    ? Gpr(CallingConvention.GetIntReturnRegister(), source.Type)
-                    : Xmm(CallingConvention.GetVecReturnRegister(), source.Type);
-
-                Operation retCopyOp = Operation(Instruction.Copy, retReg, source);
-
-                nodes.AddBefore(node, retCopyOp);
-            }
-        }
-
-        private static Operand AddXmmCopy(IntrusiveList<Operation> nodes, Operation node, Operand source)
+        protected static Operand AddXmmCopy(IntrusiveList<Operation> nodes, Operation node, Operand source)
         {
             Operand temp = Local(source.Type);
             Operand intConst = AddCopy(nodes, node, GetIntConst(source));
@@ -1204,7 +592,7 @@ namespace ARMeilleure.CodeGen.X86
             return temp;
         }
 
-        private static Operand AddCopy(IntrusiveList<Operation> nodes, Operation node, Operand source)
+        protected static Operand AddCopy(IntrusiveList<Operation> nodes, Operation node, Operand source)
         {
             Operand temp = Local(source.Type);
 
@@ -1229,7 +617,7 @@ namespace ARMeilleure.CodeGen.X86
             return value;
         }
 
-        private static void Delete(IntrusiveList<Operation> nodes, Operation node)
+        protected static void Delete(IntrusiveList<Operation> nodes, Operation node)
         {
             node.Destination = default;
 
@@ -1241,12 +629,12 @@ namespace ARMeilleure.CodeGen.X86
             nodes.Remove(node);
         }
 
-        private static Operand Gpr(X86Register register, OperandType type)
+        protected static Operand Gpr(X86Register register, OperandType type)
         {
             return Register((int)register, RegisterType.Integer, type);
         }
 
-        private static Operand Xmm(X86Register register, OperandType type)
+        protected static Operand Xmm(X86Register register, OperandType type)
         {
             return Register((int)register, RegisterType.Vector, type);
         }

ARMeilleure/CodeGen/X86/PreAllocatorSystemV.cs

@@ -0,0 +1,334 @@
+using ARMeilleure.CodeGen.RegisterAllocators;
+using ARMeilleure.IntermediateRepresentation;
+using ARMeilleure.Translation;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+using static ARMeilleure.IntermediateRepresentation.Operation.Factory;
+
+namespace ARMeilleure.CodeGen.X86
+{
+    class PreAllocatorSystemV : PreAllocator
+    {
+        public static void InsertCallCopies(IntrusiveList<Operation> nodes, Operation node)
+        {
+            Operand dest = node.Destination;
+
+            List<Operand> sources = new List<Operand>
+            {
+                node.GetSource(0)
+            };
+
+            int argsCount = node.SourcesCount - 1;
+
+            int intMax = CallingConvention.GetIntArgumentsOnRegsCount();
+            int vecMax = CallingConvention.GetVecArgumentsOnRegsCount();
+
+            int intCount = 0;
+            int vecCount = 0;
+
+            int stackOffset = 0;
+
+            for (int index = 0; index < argsCount; index++)
+            {
+                Operand source = node.GetSource(index + 1);
+
+                bool passOnReg;
+
+                if (source.Type.IsInteger())
+                {
+                    passOnReg = intCount < intMax;
+                }
+                else if (source.Type == OperandType.V128)
+                {
+                    passOnReg = intCount + 1 < intMax;
+                }
+                else
+                {
+                    passOnReg = vecCount < vecMax;
+                }
+
+                if (source.Type == OperandType.V128 && passOnReg)
+                {
+                    // V128 is a struct, we pass each half on a GPR if possible.
+                    Operand argReg  = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
+                    Operand argReg2 = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
+
+                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg,  source, Const(0)));
+                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg2, source, Const(1)));
+
+                    continue;
+                }
+
+                if (passOnReg)
+                {
+                    Operand argReg = source.Type.IsInteger()
+                        ? Gpr(CallingConvention.GetIntArgumentRegister(intCount++), source.Type)
+                        : Xmm(CallingConvention.GetVecArgumentRegister(vecCount++), source.Type);
+
+                    Operation copyOp = Operation(Instruction.Copy, argReg, source);
+
+                    InsertConstantRegCopies(nodes, nodes.AddBefore(node, copyOp));
+
+                    sources.Add(argReg);
+                }
+                else
+                {
+                    Operand offset = Const(stackOffset);
+
+                    Operation spillOp = Operation(Instruction.SpillArg, default, offset, source);
+
+                    InsertConstantRegCopies(nodes, nodes.AddBefore(node, spillOp));
+
+                    stackOffset += source.Type.GetSizeInBytes();
+                }
+            }
+
+            node.SetSources(sources.ToArray());
+
+            if (dest != default)
+            {
+                if (dest.Type == OperandType.V128)
+                {
+                    Operand retLReg = Gpr(CallingConvention.GetIntReturnRegister(),     OperandType.I64);
+                    Operand retHReg = Gpr(CallingConvention.GetIntReturnRegisterHigh(), OperandType.I64);
+
+                    Operation operation = node;
+
+                    node = nodes.AddAfter(node, Operation(Instruction.VectorCreateScalar, dest, retLReg));
+                    nodes.AddAfter(node, Operation(Instruction.VectorInsert, dest, dest, retHReg, Const(1)));
+
+                    operation.Destination = default;
+                }
+                else
+                {
+                    Operand retReg = dest.Type.IsInteger()
+                        ? Gpr(CallingConvention.GetIntReturnRegister(), dest.Type)
+                        : Xmm(CallingConvention.GetVecReturnRegister(), dest.Type);
+
+                    Operation copyOp = Operation(Instruction.Copy, dest, retReg);
+
+                    nodes.AddAfter(node, copyOp);
+
+                    node.Destination = retReg;
+                }
+            }
+        }
+
+        public static void InsertTailcallCopies(IntrusiveList<Operation> nodes, StackAllocator stackAlloc, Operation node)
+        {
+            List<Operand> sources = new List<Operand>
+            {
+                node.GetSource(0)
+            };
+
+            int argsCount = node.SourcesCount - 1;
+
+            int intMax = CallingConvention.GetIntArgumentsOnRegsCount();
+            int vecMax = CallingConvention.GetVecArgumentsOnRegsCount();
+
+            int intCount = 0;
+            int vecCount = 0;
+
+            // Handle arguments passed on registers.
+            for (int index = 0; index < argsCount; index++)
+            {
+                Operand source = node.GetSource(1 + index);
+
+                bool passOnReg;
+
+                if (source.Type.IsInteger())
+                {
+                    passOnReg = intCount + 1 < intMax;
+                }
+                else
+                {
+                    passOnReg = vecCount < vecMax;
+                }
+
+                if (source.Type == OperandType.V128 && passOnReg)
+                {
+                    // V128 is a struct, we pass each half on a GPR if possible.
+                    Operand argReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
+                    Operand argReg2 = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
+
+                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg, source, Const(0)));
+                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg2, source, Const(1)));
+
+                    continue;
+                }
+
+                if (passOnReg)
+                {
+                    Operand argReg = source.Type.IsInteger()
+                        ? Gpr(CallingConvention.GetIntArgumentRegister(intCount++), source.Type)
+                        : Xmm(CallingConvention.GetVecArgumentRegister(vecCount++), source.Type);
+
+                    Operation copyOp = Operation(Instruction.Copy, argReg, source);
+
+                    InsertConstantRegCopies(nodes, nodes.AddBefore(node, copyOp));
+
+                    sources.Add(argReg);
+                }
+                else
+                {
+                    throw new NotImplementedException("Spilling is not currently supported for tail calls. (too many arguments)");
+                }
+            }
+
+            // The target address must be on the return registers, since we
+            // don't return anything and it is guaranteed to not be a
+            // callee saved register (which would be trashed on the epilogue).
+            Operand retReg = Gpr(CallingConvention.GetIntReturnRegister(), OperandType.I64);
+
+            Operation addrCopyOp = Operation(Instruction.Copy, retReg, node.GetSource(0));
+
+            nodes.AddBefore(node, addrCopyOp);
+
+            sources[0] = retReg;
+
+            node.SetSources(sources.ToArray());
+        }
+
+        public static Operation InsertLoadArgumentCopy(
+            CompilerContext cctx,
+            ref Span<Operation> buffer,
+            IntrusiveList<Operation> nodes,
+            Operand[] preservedArgs,
+            Operation node)
+        {
+            Operand source = node.GetSource(0);
+
+            Debug.Assert(source.Kind == OperandKind.Constant, "Non-constant LoadArgument source kind.");
+
+            int index = source.AsInt32();
+
+            int intCount = 0;
+            int vecCount = 0;
+
+            for (int cIndex = 0; cIndex < index; cIndex++)
+            {
+                OperandType argType = cctx.FuncArgTypes[cIndex];
+
+                if (argType.IsInteger())
+                {
+                    intCount++;
+                }
+                else if (argType == OperandType.V128)
+                {
+                    intCount += 2;
+                }
+                else
+                {
+                    vecCount++;
+                }
+            }
+
+            bool passOnReg;
+
+            if (source.Type.IsInteger())
+            {
+                passOnReg = intCount < CallingConvention.GetIntArgumentsOnRegsCount();
+            }
+            else if (source.Type == OperandType.V128)
+            {
+                passOnReg = intCount + 1 < CallingConvention.GetIntArgumentsOnRegsCount();
+            }
+            else
+            {
+                passOnReg = vecCount < CallingConvention.GetVecArgumentsOnRegsCount();
+            }
+
+            if (passOnReg)
+            {
+                Operand dest = node.Destination;
+
+                if (preservedArgs[index] == default)
+                {
+                    if (dest.Type == OperandType.V128)
+                    {
+                        // V128 is a struct, we pass each half on a GPR if possible.
+                        Operand pArg = Local(OperandType.V128);
+
+                        Operand argLReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount),     OperandType.I64);
+                        Operand argHReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount + 1), OperandType.I64);
+
+                        Operation copyL = Operation(Instruction.VectorCreateScalar, pArg, argLReg);
+                        Operation copyH = Operation(Instruction.VectorInsert,       pArg, pArg, argHReg, Const(1));
+
+                        cctx.Cfg.Entry.Operations.AddFirst(copyH);
+                        cctx.Cfg.Entry.Operations.AddFirst(copyL);
+
+                        preservedArgs[index] = pArg;
+                    }
+                    else
+                    {
+                        Operand pArg = Local(dest.Type);
+
+                        Operand argReg = dest.Type.IsInteger()
+                            ? Gpr(CallingConvention.GetIntArgumentRegister(intCount), dest.Type)
+                            : Xmm(CallingConvention.GetVecArgumentRegister(vecCount), dest.Type);
+
+                        Operation copyOp = Operation(Instruction.Copy, pArg, argReg);
+
+                        cctx.Cfg.Entry.Operations.AddFirst(copyOp);
+
+                        preservedArgs[index] = pArg;
+                    }
+                }
+
+                Operation nextNode;
+
+                if (dest.AssignmentsCount == 1)
+                {
+                    // Let's propagate the argument if we can to avoid copies.
+                    PreAllocatorCommon.Propagate(ref buffer, dest, preservedArgs[index]);
+                    nextNode = node.ListNext;
+                }
+                else
+                {
+                    Operation argCopyOp = Operation(Instruction.Copy, dest, preservedArgs[index]);
+                    nextNode = nodes.AddBefore(node, argCopyOp);
+                }
+
+                Delete(nodes, node);
+                return nextNode;
+            }
+            else
+            {
+                // TODO: Pass on stack.
+                return node;
+            }
+        }
+
+        public static void InsertReturnCopy(IntrusiveList<Operation> nodes, Operation node)
+        {
+            if (node.SourcesCount == 0)
+            {
+                return;
+            }
+
+            Operand source = node.GetSource(0);
+
+            if (source.Type == OperandType.V128)
+            {
+                Operand retLReg = Gpr(CallingConvention.GetIntReturnRegister(),     OperandType.I64);
+                Operand retHReg = Gpr(CallingConvention.GetIntReturnRegisterHigh(), OperandType.I64);
+
+                nodes.AddBefore(node, Operation(Instruction.VectorExtract, retLReg, source, Const(0)));
+                nodes.AddBefore(node, Operation(Instruction.VectorExtract, retHReg, source, Const(1)));
+            }
+            else
+            {
+                Operand retReg = source.Type.IsInteger()
+                    ? Gpr(CallingConvention.GetIntReturnRegister(), source.Type)
+                    : Xmm(CallingConvention.GetVecReturnRegister(), source.Type);
+
+                Operation retCopyOp = Operation(Instruction.Copy, retReg, source);
+
+                nodes.AddBefore(node, retCopyOp);
+            }
+        }
+    }
+}

ARMeilleure/CodeGen/X86/PreAllocatorWindows.cs

@@ -0,0 +1,327 @@
+using ARMeilleure.CodeGen.RegisterAllocators;
+using ARMeilleure.IntermediateRepresentation;
+using ARMeilleure.Translation;
+using System;
+using System.Diagnostics;
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+using static ARMeilleure.IntermediateRepresentation.Operation.Factory;
+
+namespace ARMeilleure.CodeGen.X86
+{
+    class PreAllocatorWindows : PreAllocator
+    {
+        public static void InsertCallCopies(IntrusiveList<Operation> nodes, StackAllocator stackAlloc, Operation node)
+        {
+            Operand dest = node.Destination;
+
+            // Handle struct arguments.
+            int retArgs = 0;
+            int stackAllocOffset = 0;
+
+            int AllocateOnStack(int size)
+            {
+                // We assume that the stack allocator is initially empty (TotalSize = 0).
+                // Taking that into account, we can reuse the space allocated for other
+                // calls by keeping track of our own allocated size (stackAllocOffset).
+                // If the space allocated is not big enough, then we just expand it.
+                int offset = stackAllocOffset;
+
+                if (stackAllocOffset + size > stackAlloc.TotalSize)
+                {
+                    stackAlloc.Allocate((stackAllocOffset + size) - stackAlloc.TotalSize);
+                }
+
+                stackAllocOffset += size;
+
+                return offset;
+            }
+
+            Operand arg0Reg = default;
+
+            if (dest != default && dest.Type == OperandType.V128)
+            {
+                int stackOffset = AllocateOnStack(dest.Type.GetSizeInBytes());
+
+                arg0Reg = Gpr(CallingConvention.GetIntArgumentRegister(0), OperandType.I64);
+
+                Operation allocOp = Operation(Instruction.StackAlloc, arg0Reg, Const(stackOffset));
+
+                nodes.AddBefore(node, allocOp);
+
+                retArgs = 1;
+            }
+
+            int argsCount = node.SourcesCount - 1;
+            int maxArgs = CallingConvention.GetArgumentsOnRegsCount() - retArgs;
+
+            if (argsCount > maxArgs)
+            {
+                argsCount = maxArgs;
+            }
+
+            Operand[] sources = new Operand[1 + retArgs + argsCount];
+
+            sources[0] = node.GetSource(0);
+
+            if (arg0Reg != default)
+            {
+                sources[1] = arg0Reg;
+            }
+
+            for (int index = 1; index < node.SourcesCount; index++)
+            {
+                Operand source = node.GetSource(index);
+
+                if (source.Type == OperandType.V128)
+                {
+                    Operand stackAddr = Local(OperandType.I64);
+
+                    int stackOffset = AllocateOnStack(source.Type.GetSizeInBytes());
+
+                    nodes.AddBefore(node, Operation(Instruction.StackAlloc, stackAddr, Const(stackOffset)));
+
+                    Operation storeOp = Operation(Instruction.Store, default, stackAddr, source);
+
+                    InsertConstantRegCopies(nodes, nodes.AddBefore(node, storeOp));
+
+                    node.SetSource(index, stackAddr);
+                }
+            }
+
+            // Handle arguments passed on registers.
+            for (int index = 0; index < argsCount; index++)
+            {
+                Operand source = node.GetSource(index + 1);
+                Operand argReg;
+
+                int argIndex = index + retArgs;
+
+                if (source.Type.IsInteger())
+                {
+                    argReg = Gpr(CallingConvention.GetIntArgumentRegister(argIndex), source.Type);
+                }
+                else
+                {
+                    argReg = Xmm(CallingConvention.GetVecArgumentRegister(argIndex), source.Type);
+                }
+
+                Operation copyOp = Operation(Instruction.Copy, argReg, source);
+
+                InsertConstantRegCopies(nodes, nodes.AddBefore(node, copyOp));
+
+                sources[1 + retArgs + index] = argReg;
+            }
+
+            // The remaining arguments (those that are not passed on registers)
+            // should be passed on the stack, we write them to the stack with "SpillArg".
+            for (int index = argsCount; index < node.SourcesCount - 1; index++)
+            {
+                Operand source = node.GetSource(index + 1);
+                Operand offset = Const((index + retArgs) * 8);
+
+                Operation spillOp = Operation(Instruction.SpillArg, default, offset, source);
+
+                InsertConstantRegCopies(nodes, nodes.AddBefore(node, spillOp));
+            }
+
+            if (dest != default)
+            {
+                if (dest.Type == OperandType.V128)
+                {
+                    Operand retValueAddr = Local(OperandType.I64);
+
+                    nodes.AddBefore(node, Operation(Instruction.Copy, retValueAddr, arg0Reg));
+
+                    Operation loadOp = Operation(Instruction.Load, dest, retValueAddr);
+
+                    nodes.AddAfter(node, loadOp);
+
+                    node.Destination = default;
+                }
+                else
+                {
+                    Operand retReg = dest.Type.IsInteger()
+                        ? Gpr(CallingConvention.GetIntReturnRegister(), dest.Type)
+                        : Xmm(CallingConvention.GetVecReturnRegister(), dest.Type);
+
+                    Operation copyOp = Operation(Instruction.Copy, dest, retReg);
+
+                    nodes.AddAfter(node, copyOp);
+
+                    node.Destination = retReg;
+                }
+            }
+
+            node.SetSources(sources);
+        }
+
+        public static void InsertTailcallCopies(IntrusiveList<Operation> nodes, StackAllocator stackAlloc, Operation node)
+        {
+            int argsCount = node.SourcesCount - 1;
+            int maxArgs = CallingConvention.GetArgumentsOnRegsCount();
+
+            if (argsCount > maxArgs)
+            {
+                throw new NotImplementedException("Spilling is not currently supported for tail calls. (too many arguments)");
+            }
+
+            Operand[] sources = new Operand[1 + argsCount];
+
+            // Handle arguments passed on registers.
+            for (int index = 0; index < argsCount; index++)
+            {
+                Operand source = node.GetSource(1 + index);
+                Operand argReg = source.Type.IsInteger()
+                    ? Gpr(CallingConvention.GetIntArgumentRegister(index), source.Type)
+                    : Xmm(CallingConvention.GetVecArgumentRegister(index), source.Type);
+
+                Operation copyOp = Operation(Instruction.Copy, argReg, source);
+
+                InsertConstantRegCopies(nodes, nodes.AddBefore(node, copyOp));
+
+                sources[1 + index] = argReg;
+            }
+
+            // The target address must be on the return registers, since we
+            // don't return anything and it is guaranteed to not be a
+            // callee saved register (which would be trashed on the epilogue).
+            Operand retReg = Gpr(CallingConvention.GetIntReturnRegister(), OperandType.I64);
+
+            Operation addrCopyOp = Operation(Instruction.Copy, retReg, node.GetSource(0));
+
+            nodes.AddBefore(node, addrCopyOp);
+
+            sources[0] = retReg;
+
+            node.SetSources(sources);
+        }
+
+        public static Operation InsertLoadArgumentCopy(
+            CompilerContext cctx,
+            ref Span<Operation> buffer,
+            IntrusiveList<Operation> nodes,
+            Operand[] preservedArgs,
+            Operation node)
+        {
+            Operand source = node.GetSource(0);
+
+            Debug.Assert(source.Kind == OperandKind.Constant, "Non-constant LoadArgument source kind.");
+
+            int retArgs = cctx.FuncReturnType == OperandType.V128 ? 1 : 0;
+
+            int index = source.AsInt32() + retArgs;
+
+            if (index < CallingConvention.GetArgumentsOnRegsCount())
+            {
+                Operand dest = node.Destination;
+
+                if (preservedArgs[index] == default)
+                {
+                    Operand argReg, pArg;
+
+                    if (dest.Type.IsInteger())
+                    {
+                        argReg = Gpr(CallingConvention.GetIntArgumentRegister(index), dest.Type);
+                        pArg = Local(dest.Type);
+                    }
+                    else if (dest.Type == OperandType.V128)
+                    {
+                        argReg = Gpr(CallingConvention.GetIntArgumentRegister(index), OperandType.I64);
+                        pArg = Local(OperandType.I64);
+                    }
+                    else
+                    {
+                        argReg = Xmm(CallingConvention.GetVecArgumentRegister(index), dest.Type);
+                        pArg = Local(dest.Type);
+                    }
+
+                    Operation copyOp = Operation(Instruction.Copy, pArg, argReg);
+
+                    cctx.Cfg.Entry.Operations.AddFirst(copyOp);
+
+                    preservedArgs[index] = pArg;
+                }
+
+                Operation nextNode;
+
+                if (dest.Type != OperandType.V128 && dest.AssignmentsCount == 1)
+                {
+                    // Let's propagate the argument if we can to avoid copies.
+                    PreAllocatorCommon.Propagate(ref buffer, dest, preservedArgs[index]);
+                    nextNode = node.ListNext;
+                }
+                else
+                {
+                    Operation argCopyOp = Operation(dest.Type == OperandType.V128
+                        ? Instruction.Load
+                        : Instruction.Copy, dest, preservedArgs[index]);
+
+                    nextNode = nodes.AddBefore(node, argCopyOp);
+                }
+
+                Delete(nodes, node);
+                return nextNode;
+            }
+            else
+            {
+                // TODO: Pass on stack.
+                return node;
+            }
+        }
+
+        public static void InsertReturnCopy(
+            CompilerContext cctx,
+            IntrusiveList<Operation> nodes,
+            Operand[] preservedArgs,
+            Operation node)
+        {
+            if (node.SourcesCount == 0)
+            {
+                return;
+            }
+
+            Operand source = node.GetSource(0);
+            Operand retReg;
+
+            if (source.Type.IsInteger())
+            {
+                retReg = Gpr(CallingConvention.GetIntReturnRegister(), source.Type);
+            }
+            else if (source.Type == OperandType.V128)
+            {
+                if (preservedArgs[0] == default)
+                {
+                    Operand preservedArg = Local(OperandType.I64);
+                    Operand arg0 = Gpr(CallingConvention.GetIntArgumentRegister(0), OperandType.I64);
+
+                    Operation copyOp = Operation(Instruction.Copy, preservedArg, arg0);
+
+                    cctx.Cfg.Entry.Operations.AddFirst(copyOp);
+
+                    preservedArgs[0] = preservedArg;
+                }
+
+                retReg = preservedArgs[0];
+            }
+            else
+            {
+                retReg = Xmm(CallingConvention.GetVecReturnRegister(), source.Type);
+            }
+
+            if (source.Type == OperandType.V128)
+            {
+                Operation retStoreOp = Operation(Instruction.Store, default, retReg, source);
+
+                nodes.AddBefore(node, retStoreOp);
+            }
+            else
+            {
+                Operation retCopyOp = Operation(Instruction.Copy, retReg, source);
+
+                nodes.AddBefore(node, retCopyOp);
+            }
+
+            node.SetSources(Array.Empty<Operand>());
+        }
+    }
+}

ARMeilleure/Decoders/DecoderHelper.cs

@@ -17,7 +17,7 @@ namespace ARMeilleure.Decoders
         {
             uint[] tbl = new uint[256];
 
-            for (int idx = 0; idx < 256; idx++)
+            for (int idx = 0; idx < tbl.Length; idx++)
             {
                 tbl[idx] = ExpandImm8ToFP32((uint)idx);
             }
@@ -29,7 +29,7 @@ namespace ARMeilleure.Decoders
         {
             ulong[] tbl = new ulong[256];
 
-            for (int idx = 0; idx < 256; idx++)
+            for (int idx = 0; idx < tbl.Length; idx++)
             {
                 tbl[idx] = ExpandImm8ToFP64((ulong)idx);
             }

ARMeilleure/Decoders/OpCodeTable.cs

@@ -1301,7 +1301,7 @@ namespace ARMeilleure.Decoders
         {
             List<InstInfo>[] temp = new List<InstInfo>[FastLookupSize];
 
-            for (int index = 0; index < FastLookupSize; index++)
+            for (int index = 0; index < temp.Length; index++)
             {
                 temp[index] = new List<InstInfo>();
             }
@@ -1311,7 +1311,7 @@ namespace ARMeilleure.Decoders
                 int mask  = ToFastLookupIndex(inst.Mask);
                 int value = ToFastLookupIndex(inst.Value);
 
-                for (int index = 0; index < FastLookupSize; index++)
+                for (int index = 0; index < temp.Length; index++)
                 {
                     if ((index & mask) == value)
                     {
@@ -1320,7 +1320,7 @@ namespace ARMeilleure.Decoders
                 }
             }
 
-            for (int index = 0; index < FastLookupSize; index++)
+            for (int index = 0; index < temp.Length; index++)
             {
                 table[index] = temp[index].ToArray();
             }

ARMeilleure/Translation/PTC/Ptc.cs

@@ -6,6 +6,7 @@ using ARMeilleure.Memory;
 using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
@@ -29,7 +30,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 4328; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 4484; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";
@@ -150,10 +151,10 @@ namespace ARMeilleure.Translation.PTC
 
         private void InitializeCarriers()
         {
-            _infosStream = new MemoryStream();
+            _infosStream = MemoryStreamManager.Shared.GetStream();
             _codesList = new List<byte[]>();
-            _relocsStream = new MemoryStream();
-            _unwindInfosStream = new MemoryStream();
+            _relocsStream = MemoryStreamManager.Shared.GetStream();
+            _unwindInfosStream = MemoryStreamManager.Shared.GetStream();
         }
 
         private void DisposeCarriers()

ARMeilleure/Translation/PTC/PtcProfiler.cs

@@ -1,6 +1,7 @@
 using ARMeilleure.State;
 using Ryujinx.Common;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using System;
 using System.Buffers.Binary;
 using System.Collections.Concurrent;
@@ -182,7 +183,7 @@ namespace ARMeilleure.Translation.PTC
                     return false;
                 }
 
-                using (MemoryStream stream = new MemoryStream())
+                using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
                 {
                     Debug.Assert(stream.Seek(0L, SeekOrigin.Begin) == 0L && stream.Length == 0L);
 
@@ -274,7 +275,7 @@ namespace ARMeilleure.Translation.PTC
 
             outerHeader.SetHeaderHash();
 
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             {
                 Debug.Assert(stream.Seek(0L, SeekOrigin.Begin) == 0L && stream.Length == 0L);
 

Directory.Packages.props

@@ -12,7 +12,6 @@
     <PackageVersion Include="Avalonia.Svg.Skia" Version="0.10.18" />
     <PackageVersion Include="CommandLineParser" Version="2.9.1" />
     <PackageVersion Include="Concentus" Version="1.1.7" />
-    <PackageVersion Include="Crc32.NET" Version="1.2.0" />
     <PackageVersion Include="DiscordRichPresence" Version="1.1.3.18" />
     <PackageVersion Include="DynamicData" Version="7.12.11" />
     <PackageVersion Include="FluentAvaloniaUI" Version="1.4.5" />
@@ -23,6 +22,7 @@
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="2.3.2" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
     <PackageVersion Include="NUnit" Version="3.13.3" />
     <PackageVersion Include="NUnit3TestAdapter" Version="4.1.0" />
@@ -45,11 +45,9 @@
     <PackageVersion Include="SPB" Version="0.0.4-build28" />
     <PackageVersion Include="System.Drawing.Common" Version="7.0.0" />
     <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="6.27.0" />
-    <PackageVersion Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
+    <PackageVersion Include="System.IO.Hashing" Version="7.0.0" />
     <PackageVersion Include="System.Management" Version="7.0.0" />
-    <PackageVersion Include="System.Net.NameResolution" Version="4.3.0" />
-    <PackageVersion Include="System.Threading.ThreadPool" Version="4.3.0" />
-    <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-f7c841d" />
+    <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-fb78016" />
     <PackageVersion Include="XamlNameReferenceGenerator" Version="1.5.1" />
   </ItemGroup>
 </Project>

Ryujinx.Audio/Common/AudioDeviceSession.cs

@@ -400,7 +400,9 @@ namespace Ryujinx.Audio.Common
         {
             uint bufferIndex = (_releasedBufferIndex - _bufferReleasedCount) % Constants.AudioDeviceBufferCountMax;
 
-            for (int i = 0; i < GetTotalBufferCount(); i++)
+            uint totalBufferCount = GetTotalBufferCount();
+
+            for (int i = 0; i < totalBufferCount; i++)
             {
                 if (_buffers[bufferIndex].BufferTag == bufferTag)
                 {

Ryujinx.Ava/Assets/Locales/en_US.json

@@ -583,10 +583,10 @@
   "SelectUpdateDialogTitle": "Select update files",
   "UserProfileWindowTitle": "User Profiles Manager",
   "CheatWindowTitle": "Cheats Manager",
-  "DlcWindowTitle": "Downloadable Content Manager",
+  "DlcWindowTitle": "Manage Downloadable Content for {0} ({1})",
   "UpdateWindowTitle": "Title Update Manager",
   "CheatWindowHeading": "Cheats Available for {0} [{1}]",
-  "DlcWindowHeading": "{0} Downloadable Content(s) available for {1} ({2})",
+  "DlcWindowHeading": "{0} Downloadable Content(s)",
   "UserProfilesEditProfile": "Edit Selected",
   "Cancel": "Cancel",
   "Save": "Save",

Ryujinx.Ava/Ryujinx.Ava.csproj

@@ -13,7 +13,7 @@
   </PropertyGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="$([MSBuild]::IsOSPlatform('OSX'))">
-    <Exec Command="codesign --entitlements $(ProjectDir)..\distribution\macos\entitlements.xml -f --deep -s $(SigningCertificate) $(TargetDir)$(TargetName)" />
+    <Exec Command="codesign --entitlements '$(ProjectDir)..\distribution\macos\entitlements.xml' -f --deep -s $(SigningCertificate) '$(TargetDir)$(TargetName)'" />
   </Target>
 
   <PropertyGroup Condition="'$(RuntimeIdentifier)' != ''">

Ryujinx.Ava/UI/Models/DownloadableContentModel.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Ava.UI.ViewModels;
+using System.IO;
 
 namespace Ryujinx.Ava.UI.Models
 {
@@ -21,6 +22,8 @@ namespace Ryujinx.Ava.UI.Models
         public string ContainerPath { get; }
         public string FullPath      { get; }
 
+        public string FileName => Path.GetFileName(ContainerPath);
+
         public DownloadableContentModel(string titleId, string containerPath, string fullPath, bool enabled)
         {
             TitleId       = titleId;

Ryujinx.Ava/UI/ViewModels/DownloadableContentManagerViewModel.cs

@@ -0,0 +1,340 @@
+using Avalonia.Collections;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Threading;
+using DynamicData;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.FsSystem;
+using LibHac.Tools.Fs;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.UI.Helpers;
+using Ryujinx.Ava.UI.Models;
+using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.FileSystem;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Path = System.IO.Path;
+
+namespace Ryujinx.Ava.UI.ViewModels
+{
+    public class DownloadableContentManagerViewModel : BaseModel
+    {
+        private readonly List<DownloadableContentContainer> _downloadableContentContainerList;
+        private readonly string                             _downloadableContentJsonPath;
+
+        private VirtualFileSystem                      _virtualFileSystem;
+        private AvaloniaList<DownloadableContentModel> _downloadableContents = new();
+        private AvaloniaList<DownloadableContentModel> _views = new();
+        private AvaloniaList<DownloadableContentModel> _selectedDownloadableContents = new();
+
+        private string _search;
+        private ulong _titleId;
+        private string _titleName;
+
+        public AvaloniaList<DownloadableContentModel> DownloadableContents
+        {
+            get => _downloadableContents;
+            set
+            {
+                _downloadableContents = value;
+                OnPropertyChanged();
+                OnPropertyChanged(nameof(UpdateCount));
+                Sort();
+            }
+        }
+
+        public AvaloniaList<DownloadableContentModel> Views
+        {
+            get => _views;
+            set
+            {
+                _views = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public AvaloniaList<DownloadableContentModel> SelectedDownloadableContents
+        {
+            get => _selectedDownloadableContents;
+            set
+            {
+                _selectedDownloadableContents = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public string Search
+        {
+            get => _search;
+            set
+            {
+                _search = value;
+                OnPropertyChanged();
+                Sort();
+            }
+        }
+
+        public string UpdateCount
+        {
+            get => string.Format(LocaleManager.Instance[LocaleKeys.DlcWindowHeading], DownloadableContents.Count);
+        }
+
+        public DownloadableContentManagerViewModel(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName)
+        {
+            _virtualFileSystem = virtualFileSystem;
+
+            _titleId   = titleId;
+            _titleName = titleName;
+
+            _downloadableContentJsonPath = Path.Combine(AppDataManager.GamesDirPath, titleId.ToString("x16"), "dlc.json");
+
+            try
+            {
+                _downloadableContentContainerList = JsonHelper.DeserializeFromFile<List<DownloadableContentContainer>>(_downloadableContentJsonPath);
+            }
+            catch
+            {
+                Logger.Error?.Print(LogClass.Configuration, "Downloadable Content JSON failed to deserialize.");
+                _downloadableContentContainerList = new List<DownloadableContentContainer>();
+            }
+
+            LoadDownloadableContents();
+        }
+
+        private void LoadDownloadableContents()
+        {
+            foreach (DownloadableContentContainer downloadableContentContainer in _downloadableContentContainerList)
+            {
+                if (File.Exists(downloadableContentContainer.ContainerPath))
+                {
+                    using FileStream containerFile = File.OpenRead(downloadableContentContainer.ContainerPath);
+
+                    PartitionFileSystem partitionFileSystem = new(containerFile.AsStorage());
+
+                    _virtualFileSystem.ImportTickets(partitionFileSystem);
+
+                    foreach (DownloadableContentNca downloadableContentNca in downloadableContentContainer.DownloadableContentNcaList)
+                    {
+                        using UniqueRef<IFile> ncaFile = new();
+
+                        partitionFileSystem.OpenFile(ref ncaFile.Ref, downloadableContentNca.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
+
+                        Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), downloadableContentContainer.ContainerPath);
+                        if (nca != null)
+                        {   
+                            var content = new DownloadableContentModel(nca.Header.TitleId.ToString("X16"),
+                                downloadableContentContainer.ContainerPath,
+                                downloadableContentNca.FullPath,
+                                downloadableContentNca.Enabled);
+
+                            DownloadableContents.Add(content);
+
+                            if (content.Enabled)
+                            {
+                                SelectedDownloadableContents.Add(content);
+                            }
+
+                            OnPropertyChanged(nameof(UpdateCount));
+                        }
+                    }
+                }
+            }
+
+            // NOTE: Save the list again to remove leftovers.
+            Save();
+            Sort();
+        }
+
+        public void Sort()
+        {
+            DownloadableContents.AsObservableChangeSet()
+                .Filter(Filter)
+                .Bind(out var view).AsObservableList();
+
+            _views.Clear();
+            _views.AddRange(view);
+            OnPropertyChanged(nameof(Views));
+        }
+
+        private bool Filter(object arg)
+        {
+            if (arg is DownloadableContentModel content)
+            {
+                return string.IsNullOrWhiteSpace(_search) || content.FileName.ToLower().Contains(_search.ToLower()) || content.TitleId.ToLower().Contains(_search.ToLower());
+            }
+
+            return false;
+        }
+
+        private Nca TryOpenNca(IStorage ncaStorage, string containerPath)
+        {
+            try
+            {
+                return new Nca(_virtualFileSystem.KeySet, ncaStorage);
+            }
+            catch (Exception ex)
+            {
+                Dispatcher.UIThread.InvokeAsync(async () =>
+                {
+                    await ContentDialogHelper.CreateErrorDialog(string.Format(LocaleManager.Instance[LocaleKeys.DialogLoadNcaErrorMessage], ex.Message, containerPath));
+                });
+            }
+
+            return null;
+        }
+
+        public async void Add()
+        {
+            OpenFileDialog dialog = new OpenFileDialog()
+            {
+                Title         = LocaleManager.Instance[LocaleKeys.SelectDlcDialogTitle],
+                AllowMultiple = true
+            };
+
+            dialog.Filters.Add(new FileDialogFilter
+            {
+                Name       = "NSP",
+                Extensions = { "nsp" }
+            });
+
+            if (Avalonia.Application.Current.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+            {
+                string[] files = await dialog.ShowAsync(desktop.MainWindow);
+
+                if (files != null)
+                {
+                    foreach (string file in files)
+                    {
+                        await AddDownloadableContent(file);
+                    }
+                }
+            }
+        }
+
+        private async Task AddDownloadableContent(string path)
+        {
+            if (!File.Exists(path) || DownloadableContents.FirstOrDefault(x => x.ContainerPath == path) != null)
+            {
+                return;
+            }
+
+            using FileStream containerFile = File.OpenRead(path);
+
+            PartitionFileSystem partitionFileSystem         = new(containerFile.AsStorage());
+            bool                containsDownloadableContent = false;
+
+            _virtualFileSystem.ImportTickets(partitionFileSystem);
+
+            foreach (DirectoryEntryEx fileEntry in partitionFileSystem.EnumerateEntries("/", "*.nca"))
+            {
+                using var ncaFile = new UniqueRef<IFile>();
+
+                partitionFileSystem.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
+
+                Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), path);
+                if (nca == null)
+                {
+                    continue;
+                }
+
+                if (nca.Header.ContentType == NcaContentType.PublicData)
+                {
+                    if ((nca.Header.TitleId & 0xFFFFFFFFFFFFE000) != _titleId)
+                    {
+                        break;
+                    }
+
+                    var content = new DownloadableContentModel(nca.Header.TitleId.ToString("X16"), path, fileEntry.FullPath, true);
+                    DownloadableContents.Add(content);
+                    SelectedDownloadableContents.Add(content);
+
+                    OnPropertyChanged(nameof(UpdateCount));
+                    Sort();
+
+                    containsDownloadableContent = true;
+                }
+            }
+
+            if (!containsDownloadableContent)
+            {
+                await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogDlcNoDlcErrorMessage]);
+            }
+        }
+
+        public void Remove(DownloadableContentModel model)
+        {
+            DownloadableContents.Remove(model);
+            OnPropertyChanged(nameof(UpdateCount));
+            Sort();
+        }
+
+        public void RemoveAll()
+        {
+            DownloadableContents.Clear();
+            OnPropertyChanged(nameof(UpdateCount));
+            Sort();
+        }
+
+        public void EnableAll()
+        {
+            SelectedDownloadableContents = new(DownloadableContents);
+        }
+
+        public void DisableAll()
+        {
+            SelectedDownloadableContents.Clear();
+        }
+
+        public void Save()
+        {
+            _downloadableContentContainerList.Clear();
+
+            DownloadableContentContainer container = default;
+
+            foreach (DownloadableContentModel downloadableContent in DownloadableContents)
+            {
+                if (container.ContainerPath != downloadableContent.ContainerPath)
+                {
+                    if (!string.IsNullOrWhiteSpace(container.ContainerPath))
+                    {
+                        _downloadableContentContainerList.Add(container);
+                    }
+
+                    container = new DownloadableContentContainer
+                    {
+                        ContainerPath              = downloadableContent.ContainerPath,
+                        DownloadableContentNcaList = new List<DownloadableContentNca>()
+                    };
+                }
+
+                container.DownloadableContentNcaList.Add(new DownloadableContentNca
+                {
+                    Enabled  = downloadableContent.Enabled,
+                    TitleId  = Convert.ToUInt64(downloadableContent.TitleId, 16),
+                    FullPath = downloadableContent.FullPath
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(container.ContainerPath))
+            {
+                _downloadableContentContainerList.Add(container);
+            }
+
+            using (FileStream downloadableContentJsonStream = File.Create(_downloadableContentJsonPath, 4096, FileOptions.WriteThrough))
+            {
+                downloadableContentJsonStream.Write(Encoding.UTF8.GetBytes(JsonHelper.Serialize(_downloadableContentContainerList, true)));
+            }
+        }
+
+    }
+}

Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs

@@ -1564,7 +1564,7 @@ namespace Ryujinx.Ava.UI.ViewModels
         {
             if (SelectedApplication != null)
             {
-                await new DownloadableContentManagerWindow(VirtualFileSystem, ulong.Parse(SelectedApplication.TitleId, NumberStyles.HexNumber), SelectedApplication.TitleName).ShowDialog(TopLevel as Window);
+                await DownloadableContentManagerWindow.Show(VirtualFileSystem, ulong.Parse(SelectedApplication.TitleId, NumberStyles.HexNumber), SelectedApplication.TitleName);
             }
         }
 

Ryujinx.Ava/UI/ViewModels/SettingsViewModel.cs

@@ -236,7 +236,7 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         public DateTimeOffset DateOffset { get; set; }
         public TimeSpan TimeOffset { get; set; }
-        private AvaloniaList<TimeZone> TimeZones { get; set; }
+        internal AvaloniaList<TimeZone> TimeZones { get; set; }
         public AvaloniaList<string> GameDirectories { get; set; }
         public ObservableCollection<ComboBoxItem> AvailableGpus { get; set; }
 

Ryujinx.Ava/UI/Windows/DownloadableContentManagerWindow.axaml

@@ -1,172 +1,194 @@
-<window:StyleableWindow
+<UserControl
     x:Class="Ryujinx.Ava.UI.Windows.DownloadableContentManagerWindow"
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:locale="clr-namespace:Ryujinx.Ava.Common.Locale"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    xmlns:window="clr-namespace:Ryujinx.Ava.UI.Windows"
-    Width="800"
-    Height="500"
-    MinWidth="800"
-    MinHeight="500"
-    MaxWidth="800"
-    MaxHeight="500"
-    SizeToContent="Height"
-    WindowStartupLocation="CenterOwner"
+    xmlns:viewModels="clr-namespace:Ryujinx.Ava.UI.ViewModels"
+    xmlns:models="clr-namespace:Ryujinx.Ava.UI.Models"
+    xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
+    Width="500"
+    Height="380"
     mc:Ignorable="d"
+    x:CompileBindings="True"
+    x:DataType="viewModels:DownloadableContentManagerViewModel"
     Focusable="True">
-    <Grid Name="DownloadableContentGrid" Margin="15">
+    <Grid>
         <Grid.RowDefinitions>
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
             <RowDefinition Height="Auto" />
             <RowDefinition Height="*" />
             <RowDefinition Height="Auto" />
         </Grid.RowDefinitions>
-        <TextBlock
-            Name="Heading"
-            Grid.Row="1"
-            MaxWidth="500"
-            Margin="20,15,20,20"
-            HorizontalAlignment="Center"
-            VerticalAlignment="Center"
-            LineHeight="18"
-            TextAlignment="Center"
-            TextWrapping="Wrap" />
-        <DockPanel
-            Grid.Row="2"
-            Margin="0"
-            HorizontalAlignment="Left">
-            <Button
-                Name="EnableAllButton"
-                MinWidth="90"
-                Margin="5"
-                Command="{Binding EnableAll}">
-                <TextBlock Text="{locale:Locale DlcManagerEnableAllButton}" />
-            </Button>
-            <Button
-                Name="DisableAllButton"
-                MinWidth="90"
-                Margin="5"
-                Command="{Binding DisableAll}">
-                <TextBlock Text="{locale:Locale DlcManagerDisableAllButton}" />
-            </Button>
-        </DockPanel>
+        <Panel
+            Margin="0 0 0 10"
+            Grid.Row="0">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="*" />
+                </Grid.ColumnDefinitions>
+                <TextBlock
+                    Grid.Column="0"
+                    Text="{Binding UpdateCount}" />
+                <StackPanel
+                    Margin="10 0"
+                    Grid.Column="1"
+                    Orientation="Horizontal">
+                    <Button
+                        Name="EnableAllButton"
+                        MinWidth="90"
+                        Margin="5"
+                        Command="{ReflectionBinding EnableAll}">
+                        <TextBlock Text="{locale:Locale DlcManagerEnableAllButton}" />
+                    </Button>
+                    <Button
+                        Name="DisableAllButton"
+                        MinWidth="90"
+                        Margin="5"
+                        Command="{ReflectionBinding DisableAll}">
+                        <TextBlock Text="{locale:Locale DlcManagerDisableAllButton}" />
+                    </Button>
+                </StackPanel>
+                <TextBox
+                    Grid.Column="2"
+                    MinHeight="27"
+                    MaxHeight="27"
+                    HorizontalAlignment="Stretch"
+                    Watermark="{locale:Locale Search}"
+                    Text="{Binding Search}" />
+            </Grid>
+        </Panel>
         <Border
-            Grid.Row="3"
-            Margin="5"
+            Grid.Row="1"
+            Margin="0 0 0 24"
             HorizontalAlignment="Stretch"
             VerticalAlignment="Stretch"
-            BorderBrush="Gray"
-            BorderThickness="1">
-            <ScrollViewer
-                VerticalAlignment="Stretch"
-                HorizontalScrollBarVisibility="Auto"
-                VerticalScrollBarVisibility="Auto">
-                <DataGrid
-                    Name="DlcDataGrid"
-                    MinHeight="200"
-                    HorizontalAlignment="Stretch"
-                    VerticalAlignment="Stretch"
-                    CanUserReorderColumns="False"
-                    CanUserResizeColumns="True"
-                    CanUserSortColumns="True"
-                    HorizontalScrollBarVisibility="Auto"
-                    Items="{Binding _downloadableContents}"
-                    SelectionMode="Extended"
-                    VerticalScrollBarVisibility="Auto">
-                    <DataGrid.Styles>
-                        <Styles>
-                            <Style Selector="DataGridCell:nth-child(3), DataGridCell:nth-child(4)">
-                                <Setter Property="HorizontalAlignment" Value="Left" />
-                                <Setter Property="HorizontalContentAlignment" Value="Left" />
-                            </Style>
-                        </Styles>
-                        <Styles>
-                            <Style Selector="DataGridCell:nth-child(1)">
-                                <Setter Property="HorizontalAlignment" Value="Right" />
-                                <Setter Property="HorizontalContentAlignment" Value="Right" />
-                            </Style>
-                        </Styles>
-                    </DataGrid.Styles>
-                    <DataGrid.Columns>
-                        <DataGridTemplateColumn Width="90">
-                            <DataGridTemplateColumn.CellTemplate>
-                                <DataTemplate>
-                                    <CheckBox
-                                        Width="50"
-                                        MinWidth="40"
-                                        HorizontalAlignment="Center"
-                                        IsChecked="{Binding Enabled}" />
-                                </DataTemplate>
-                            </DataGridTemplateColumn.CellTemplate>
-                            <DataGridTemplateColumn.Header>
-                                <TextBlock Text="{locale:Locale DlcManagerTableHeadingEnabledLabel}" />
-                            </DataGridTemplateColumn.Header>
-                        </DataGridTemplateColumn>
-                        <DataGridTextColumn Width="140" Binding="{Binding TitleId}">
-                            <DataGridTextColumn.Header>
-                                <TextBlock Text="{locale:Locale DlcManagerTableHeadingTitleIdLabel}" />
-                            </DataGridTextColumn.Header>
-                        </DataGridTextColumn>
-                        <DataGridTextColumn Width="280" Binding="{Binding FullPath}">
-                            <DataGridTextColumn.Header>
-                                <TextBlock Text="{locale:Locale DlcManagerTableHeadingFullPathLabel}" />
-                            </DataGridTextColumn.Header>
-                        </DataGridTextColumn>
-                        <DataGridTextColumn Binding="{Binding ContainerPath}">
-                            <DataGridTextColumn.Header>
-                                <TextBlock Text="{locale:Locale DlcManagerTableHeadingContainerPathLabel}" />
-                            </DataGridTextColumn.Header>
-                        </DataGridTextColumn>
-                    </DataGrid.Columns>
-                </DataGrid>
-            </ScrollViewer>
+            BorderBrush="{DynamicResource AppListHoverBackgroundColor}"
+            BorderThickness="1"
+            CornerRadius="5"
+            Padding="2.5">
+            <ListBox
+                AutoScrollToSelectedItem="False"
+                VirtualizationMode="None"
+                SelectionMode="Multiple, Toggle"
+                Background="Transparent"
+                SelectionChanged="OnSelectionChanged"
+                SelectedItems="{Binding SelectedDownloadableContents, Mode=TwoWay}"
+                Items="{Binding Views}">
+                <ListBox.DataTemplates>
+                    <DataTemplate
+                        DataType="models:DownloadableContentModel">
+                        <Panel Margin="10">
+                            <Grid>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="*" />
+                                    <ColumnDefinition Width="Auto" />
+                                </Grid.ColumnDefinitions>
+                                <Grid
+                                    Grid.Column="0">
+                                    <Grid.ColumnDefinitions>
+                                        <ColumnDefinition Width="*"></ColumnDefinition>
+                                        <ColumnDefinition Width="Auto"></ColumnDefinition>
+                                    </Grid.ColumnDefinitions>
+                                    <TextBlock
+                                        Grid.Column="0"
+                                        HorizontalAlignment="Left"
+                                        VerticalAlignment="Center"
+                                        MaxLines="2"
+                                        TextWrapping="Wrap"
+                                        TextTrimming="CharacterEllipsis"
+                                        Text="{Binding FileName}" />
+                                    <TextBlock
+                                        Grid.Column="1"
+                                        Margin="10 0"
+                                        HorizontalAlignment="Left"
+                                        VerticalAlignment="Center"
+                                        Text="{Binding TitleId}" />
+                                </Grid>
+                                <StackPanel
+                                    Grid.Column="1"
+                                    Spacing="10"
+                                    Orientation="Horizontal"
+                                    HorizontalAlignment="Right">
+                                    <Button
+                                        VerticalAlignment="Center"
+                                        HorizontalAlignment="Right"
+                                        Padding="10"
+                                        MinWidth="0"
+                                        MinHeight="0"
+                                        Click="OpenLocation">
+                                        <ui:SymbolIcon
+                                            Symbol="OpenFolder"
+                                            HorizontalAlignment="Center"
+                                            VerticalAlignment="Center" />
+                                    </Button>
+                                    <Button
+                                        VerticalAlignment="Center"
+                                        HorizontalAlignment="Right"
+                                        Padding="10"
+                                        MinWidth="0"
+                                        MinHeight="0"
+                                        Click="RemoveDLC">
+                                        <ui:SymbolIcon
+                                            Symbol="Cancel"
+                                            HorizontalAlignment="Center"
+                                            VerticalAlignment="Center" />
+                                    </Button>
+                                </StackPanel>
+                            </Grid>
+                        </Panel>
+                    </DataTemplate>
+                </ListBox.DataTemplates>
+                <ListBox.Styles>
+                    <Style Selector="ListBoxItem">
+                        <Setter Property="Background" Value="Transparent" />
+                    </Style>
+                </ListBox.Styles>
+            </ListBox>
         </Border>
-        <DockPanel
-            Grid.Row="4"
-            Margin="0"
+        <Panel
+            Grid.Row="2"
             HorizontalAlignment="Stretch">
-            <DockPanel Margin="0" HorizontalAlignment="Left">
+            <StackPanel
+                Orientation="Horizontal"
+                Spacing="10"
+                HorizontalAlignment="Left">
                 <Button
                     Name="AddButton"
                     MinWidth="90"
                     Margin="5"
-                    Command="{Binding Add}">
+                    Command="{ReflectionBinding Add}">
                     <TextBlock Text="{locale:Locale SettingsTabGeneralAdd}" />
                 </Button>
-                <Button
-                    Name="RemoveButton"
-                    MinWidth="90"
-                    Margin="5"
-                    Command="{Binding RemoveSelected}">
-                    <TextBlock Text="{locale:Locale SettingsTabGeneralRemove}" />
-                </Button>
                 <Button
                     Name="RemoveAllButton"
                     MinWidth="90"
                     Margin="5"
-                    Command="{Binding RemoveAll}">
+                    Command="{ReflectionBinding RemoveAll}">
                     <TextBlock Text="{locale:Locale DlcManagerRemoveAllButton}" />
                 </Button>
-            </DockPanel>
-            <DockPanel Margin="0" HorizontalAlignment="Right">
+            </StackPanel>
+            <StackPanel
+                Orientation="Horizontal"
+                Spacing="10"
+                HorizontalAlignment="Right">
                 <Button
                     Name="SaveButton"
                     MinWidth="90"
                     Margin="5"
-                    Command="{Binding SaveAndClose}">
+                    Click="SaveAndClose">
                     <TextBlock Text="{locale:Locale SettingsButtonSave}" />
                 </Button>
                 <Button
                     Name="CancelButton"
                     MinWidth="90"
                     Margin="5"
-                    Command="{Binding Close}">
+                    Click="Close">
                     <TextBlock Text="{locale:Locale InputDialogCancel}" />
                 </Button>
-            </DockPanel>
-        </DockPanel>
+            </StackPanel>
+        </Panel>
     </Grid>
-</window:StyleableWindow>
+</UserControl>

Ryujinx.Ava/UI/Windows/DownloadableContentManagerWindow.axaml.cs

@@ -1,314 +1,115 @@
-using Avalonia.Collections;
 using Avalonia.Controls;
-using Avalonia.Threading;
-using LibHac.Common;
-using LibHac.Fs;
-using LibHac.Fs.Fsa;
-using LibHac.FsSystem;
-using LibHac.Tools.Fs;
-using LibHac.Tools.FsSystem;
-using LibHac.Tools.FsSystem.NcaUtils;
+using Avalonia.Interactivity;
+using Avalonia.Styling;
+using FluentAvalonia.UI.Controls;
 using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Ava.UI.Controls;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.Models;
-using Ryujinx.Common.Configuration;
-using Ryujinx.Common.Utilities;
+using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.HLE.FileSystem;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reactive.Linq;
-using System.Text;
+using Ryujinx.Ui.Common.Helper;
 using System.Threading.Tasks;
-using Path = System.IO.Path;
+using Button = Avalonia.Controls.Button;
 
 namespace Ryujinx.Ava.UI.Windows
 {
-    public partial class DownloadableContentManagerWindow : StyleableWindow
+    public partial class DownloadableContentManagerWindow : UserControl
     {
-        private readonly List<DownloadableContentContainer> _downloadableContentContainerList;
-        private readonly string                             _downloadableContentJsonPath;
-
-        private VirtualFileSystem                      _virtualFileSystem    { get; }
-        private AvaloniaList<DownloadableContentModel> _downloadableContents { get; set; }
-
-        private ulong  _titleId   { get; }
-        private string _titleName { get; }
+        public DownloadableContentManagerViewModel ViewModel;
 
         public DownloadableContentManagerWindow()
         {
             DataContext = this;
 
             InitializeComponent();
-
-            Title = $"Ryujinx {Program.Version} - {LocaleManager.Instance[LocaleKeys.DlcWindowTitle]} - {_titleName} ({_titleId:X16})";
         }
 
         public DownloadableContentManagerWindow(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName)
         {
-            _virtualFileSystem    = virtualFileSystem;
-            _downloadableContents = new AvaloniaList<DownloadableContentModel>();
-
-            _titleId   = titleId;
-            _titleName = titleName;
-
-            _downloadableContentJsonPath = Path.Combine(AppDataManager.GamesDirPath, titleId.ToString("x16"), "dlc.json");
-
-            try
-            {
-                _downloadableContentContainerList = JsonHelper.DeserializeFromFile<List<DownloadableContentContainer>>(_downloadableContentJsonPath);
-            }
-            catch
-            {
-                _downloadableContentContainerList = new List<DownloadableContentContainer>();
-            }
-
-            DataContext = this;
+            DataContext = ViewModel = new DownloadableContentManagerViewModel(virtualFileSystem, titleId, titleName);
 
             InitializeComponent();
-
-            RemoveButton.IsEnabled = false;
-
-            DlcDataGrid.SelectionChanged += DlcDataGrid_SelectionChanged;
-
-            Title = $"Ryujinx {Program.Version} - {LocaleManager.Instance[LocaleKeys.DlcWindowTitle]} - {_titleName} ({_titleId:X16})";
-
-            LoadDownloadableContents();
-            PrintHeading();
         }
 
-        private void DlcDataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        public static async Task Show(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName)
         {
-            RemoveButton.IsEnabled = (DlcDataGrid.SelectedItems.Count > 0);
-        }
-
-        private void PrintHeading()
-        {
-            Heading.Text = LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DlcWindowHeading, _downloadableContents.Count, _titleName, _titleId.ToString("X16"));
-        }
-
-        private void LoadDownloadableContents()
-        {
-            foreach (DownloadableContentContainer downloadableContentContainer in _downloadableContentContainerList)
+            ContentDialog contentDialog = new()
             {
-                if (File.Exists(downloadableContentContainer.ContainerPath))
-                {
-                    using FileStream containerFile = File.OpenRead(downloadableContentContainer.ContainerPath);
-
-                    PartitionFileSystem partitionFileSystem = new(containerFile.AsStorage());
-
-                    _virtualFileSystem.ImportTickets(partitionFileSystem);
-
-                    foreach (DownloadableContentNca downloadableContentNca in downloadableContentContainer.DownloadableContentNcaList)
-                    {
-                        using UniqueRef<IFile> ncaFile = new();
-
-                        partitionFileSystem.OpenFile(ref ncaFile.Ref, downloadableContentNca.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
-
-                        Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), downloadableContentContainer.ContainerPath);
-                        if (nca != null)
-                        {
-                            _downloadableContents.Add(new DownloadableContentModel(nca.Header.TitleId.ToString("X16"),
-                                                                                   downloadableContentContainer.ContainerPath,
-                                                                                   downloadableContentNca.FullPath,
-                                                                                   downloadableContentNca.Enabled));
-                        }
-                    }
-                }
-            }
-
-            // NOTE: Save the list again to remove leftovers.
-            Save();
-        }
-
-        private Nca TryOpenNca(IStorage ncaStorage, string containerPath)
-        {
-            try
-            {
-                return new Nca(_virtualFileSystem.KeySet, ncaStorage);
-            }
-            catch (Exception ex)
-            {
-                Dispatcher.UIThread.InvokeAsync(async () =>
-                {
-                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogLoadNcaErrorMessage, ex.Message, containerPath));
-                });
-            }
-
-            return null;
-        }
-
-        private async Task AddDownloadableContent(string path)
-        {
-            if (!File.Exists(path) || _downloadableContents.FirstOrDefault(x => x.ContainerPath == path) != null)
-            {
-                return;
-            }
-
-            using FileStream containerFile = File.OpenRead(path);
-
-            PartitionFileSystem partitionFileSystem         = new(containerFile.AsStorage());
-            bool                containsDownloadableContent = false;
-
-            _virtualFileSystem.ImportTickets(partitionFileSystem);
-
-            foreach (DirectoryEntryEx fileEntry in partitionFileSystem.EnumerateEntries("/", "*.nca"))
-            {
-                using var ncaFile = new UniqueRef<IFile>();
-
-                partitionFileSystem.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
-
-                Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), path);
-                if (nca == null)
-                {
-                    continue;
-                }
-
-                if (nca.Header.ContentType == NcaContentType.PublicData)
-                {
-                    if ((nca.Header.TitleId & 0xFFFFFFFFFFFFE000) != _titleId)
-                    {
-                        break;
-                    }
-
-                    _downloadableContents.Add(new DownloadableContentModel(nca.Header.TitleId.ToString("X16"), path, fileEntry.FullPath, true));
-
-                    containsDownloadableContent = true;
-                }
-            }
-
-            if (!containsDownloadableContent)
-            {
-                await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogDlcNoDlcErrorMessage]);
-            }
-        }
-
-        private void RemoveDownloadableContents(bool removeSelectedOnly = false)
-        {
-            if (removeSelectedOnly)
-            {
-                AvaloniaList<DownloadableContentModel> removedItems = new();
-
-                foreach (var item in DlcDataGrid.SelectedItems)
-                {
-                    removedItems.Add(item as DownloadableContentModel);
-                }
-
-                DlcDataGrid.SelectedItems.Clear();
-
-                foreach (var item in removedItems)
-                {
-                    _downloadableContents.RemoveAll(_downloadableContents.Where(x => x.TitleId == item.TitleId).ToList());
-                }
-            }
-            else
-            {
-                _downloadableContents.Clear();
-            }
-
-            PrintHeading();
-        }
-
-        public void RemoveSelected()
-        {
-            RemoveDownloadableContents(true);
-        }
-
-        public void RemoveAll()
-        {
-            RemoveDownloadableContents();
-        }
-
-        public void EnableAll()
-        {
-            foreach(var item in _downloadableContents)
-            {
-                item.Enabled = true;
-            }
-        }
-
-        public void DisableAll()
-        {
-            foreach (var item in _downloadableContents)
-            {
-                item.Enabled = false;
-            }
-        }
-
-        public async void Add()
-        {
-            OpenFileDialog dialog = new OpenFileDialog()
-            { 
-                Title         = LocaleManager.Instance[LocaleKeys.SelectDlcDialogTitle],
-                AllowMultiple = true
+                PrimaryButtonText   = "",
+                SecondaryButtonText = "",
+                CloseButtonText     = "",
+                Content             = new DownloadableContentManagerWindow(virtualFileSystem, titleId, titleName),
+                Title               = string.Format(LocaleManager.Instance[LocaleKeys.DlcWindowTitle], titleName, titleId.ToString("X16"))
             };
 
-            dialog.Filters.Add(new FileDialogFilter
-            {
-                Name       = "NSP",
-                Extensions = { "nsp" }
-            });
+            Style bottomBorder = new(x => x.OfType<Grid>().Name("DialogSpace").Child().OfType<Border>());
+            bottomBorder.Setters.Add(new Setter(IsVisibleProperty, false));
 
-            string[] files = await dialog.ShowAsync(this);
+            contentDialog.Styles.Add(bottomBorder);
 
-            if (files != null)
-            {
-                foreach (string file in files)
-                {
-                   await AddDownloadableContent(file);
-                }
-            }
-
-            PrintHeading();
+            await ContentDialogHelper.ShowAsync(contentDialog);
         }
 
-        public void Save()
+        private void SaveAndClose(object sender, RoutedEventArgs routedEventArgs)
         {
-            _downloadableContentContainerList.Clear();
+            ViewModel.Save();
+            ((ContentDialog)Parent).Hide();
+        }
 
-            DownloadableContentContainer container = default;
+        private void Close(object sender, RoutedEventArgs e)
+        {
+            ((ContentDialog)Parent).Hide();
+        }
 
-            foreach (DownloadableContentModel downloadableContent in _downloadableContents)
+        private void RemoveDLC(object sender, RoutedEventArgs e)
+        {
+            if (sender is Button button)
             {
-                if (container.ContainerPath != downloadableContent.ContainerPath)
+                if (button.DataContext is DownloadableContentModel model)
                 {
-                    if (!string.IsNullOrWhiteSpace(container.ContainerPath))
+                    ViewModel.Remove(model);
+                }
+            }
+        }
+
+        private void OpenLocation(object sender, RoutedEventArgs e)
+        {
+            if (sender is Button button)
+            {
+                if (button.DataContext is DownloadableContentModel model)
+                {
+                    OpenHelper.LocateFile(model.ContainerPath);
+                }
+            }
+        }
+
+        private void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            foreach (var content in e.AddedItems)
+            {
+                if (content is DownloadableContentModel model)
+                {
+                    var index = ViewModel.DownloadableContents.IndexOf(model);
+
+                    if (index != -1)
                     {
-                        _downloadableContentContainerList.Add(container);
+                        ViewModel.DownloadableContents[index].Enabled = true;
                     }
-
-                    container = new DownloadableContentContainer
-                    {
-                        ContainerPath              = downloadableContent.ContainerPath,
-                        DownloadableContentNcaList = new List<DownloadableContentNca>()
-                    };
                 }
+            }
 
-                container.DownloadableContentNcaList.Add(new DownloadableContentNca
+            foreach (var content in e.RemovedItems)
+            {
+                if (content is DownloadableContentModel model)
                 {
-                    Enabled  = downloadableContent.Enabled,
-                    TitleId  = Convert.ToUInt64(downloadableContent.TitleId, 16),
-                    FullPath = downloadableContent.FullPath
-                });
-            }
+                    var index = ViewModel.DownloadableContents.IndexOf(model);
 
-            if (!string.IsNullOrWhiteSpace(container.ContainerPath))
-            {
-                _downloadableContentContainerList.Add(container);
+                    if (index != -1)
+                    {
+                        ViewModel.DownloadableContents[index].Enabled = false;
+                    }
+                }
             }
-
-            using (FileStream downloadableContentJsonStream = File.Create(_downloadableContentJsonPath, 4096, FileOptions.WriteThrough))
-            {
-                downloadableContentJsonStream.Write(Encoding.UTF8.GetBytes(JsonHelper.Serialize(_downloadableContentContainerList, true)));
-            }
-        }
-
-        public void SaveAndClose()
-        {
-            Save();
-            Close();
         }
     }
 }

Ryujinx.Ava/UI/Windows/IconColorPicker.cs

@@ -125,7 +125,7 @@ namespace Ryujinx.Ava.UI.Windows
 
         public static Bgra32[] GetBuffer(Image<Bgra32> image)
         {
-            return image.TryGetSinglePixelSpan(out var data) ? data.ToArray() : new Bgra32[0];
+            return image.TryGetSinglePixelSpan(out var data) ? data.ToArray() : Array.Empty<Bgra32>();
         }
 
         private static int GetColorScore(Dictionary<int, int> dominantColorBin, int maxHitCount, PaletteColor color)

Ryujinx.Common/Extensions/BinaryReaderExtensions.cs

@@ -12,19 +12,5 @@ namespace Ryujinx.Common
         {
             return MemoryMarshal.Cast<byte, T>(reader.ReadBytes(Unsafe.SizeOf<T>()))[0];
         }
-
-        public unsafe static void WriteStruct<T>(this BinaryWriter writer, T value)
-            where T : unmanaged
-        {
-            ReadOnlySpan<byte> data = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateReadOnlySpan(ref value, 1));
-
-            writer.Write(data);
-        }
-
-        public static void Write(this BinaryWriter writer, UInt128 value)
-        {
-            writer.Write((ulong)value);
-            writer.Write((ulong)(value >> 64));
-        }
     }
 }

Ryujinx.Common/Extensions/BinaryWriterExtensions.cs

@@ -0,0 +1,28 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Common
+{
+    public static class BinaryWriterExtensions
+    {
+        public unsafe static void WriteStruct<T>(this BinaryWriter writer, T value)
+            where T : unmanaged
+        {
+            ReadOnlySpan<byte> data = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateReadOnlySpan(ref value, 1));
+
+            writer.Write(data);
+        }
+
+        public static void Write(this BinaryWriter writer, UInt128 value)
+        {
+            writer.Write((ulong)value);
+            writer.Write((ulong)(value >> 64));
+        }
+
+        public static void Write(this BinaryWriter writer, MemoryStream stream)
+        {
+            stream.CopyTo(writer.BaseStream);
+        }
+    }
+}

Ryujinx.Common/Extensions/StreamExtensions.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Buffers.Binary;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Common
+{
+    public static class StreamExtensions
+    {
+        /// <summary>
+        /// Writes a <cref="ReadOnlySpan<int>" /> to this stream.
+        ///
+        /// This default implementation converts each buffer value to a stack-allocated
+        /// byte array, then writes it to the Stream using <cref="System.Stream.Write(byte[])" />.
+        /// </summary>
+        /// <param name="stream">The stream to be written to</param>
+        /// <param name="buffer">The buffer of values to be written</param>
+        public static void Write(this Stream stream, ReadOnlySpan<int> buffer)
+        {
+            if (buffer.Length == 0)
+            {
+                return;
+            }
+
+            if (BitConverter.IsLittleEndian)
+            {
+                ReadOnlySpan<byte> byteBuffer = MemoryMarshal.Cast<int, byte>(buffer);
+                stream.Write(byteBuffer);
+            }
+            else
+            {
+                Span<byte> byteBuffer = stackalloc byte[sizeof(int)];
+
+                foreach (int value in buffer)
+                {
+                    BinaryPrimitives.WriteInt32LittleEndian(byteBuffer, value);
+                    stream.Write(byteBuffer);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Writes a four-byte signed integer to this stream. The current position
+        /// of the stream is advanced by four.
+        /// </summary>
+        /// <param name="stream">The stream to be written to</param>
+        /// <param name="value">The value to be written</param>
+        public static void Write(this Stream stream, int value)
+        {
+            Span<byte> buffer = stackalloc byte[sizeof(int)];
+            BinaryPrimitives.WriteInt32LittleEndian(buffer, value);
+            stream.Write(buffer);
+        }
+
+        /// <summary>
+        /// Writes an eight-byte signed integer to this stream. The current position
+        /// of the stream is advanced by eight.
+        /// </summary>
+        /// <param name="stream">The stream to be written to</param>
+        /// <param name="value">The value to be written</param>
+        public static void Write(this Stream stream, long value)
+        {
+            Span<byte> buffer = stackalloc byte[sizeof(long)];
+            BinaryPrimitives.WriteInt64LittleEndian(buffer, value);
+            stream.Write(buffer);
+        }
+
+        /// <summary>
+        // Writes a four-byte unsigned integer to this stream. The current position
+        // of the stream is advanced by four.
+        /// </summary>
+        /// <param name="stream">The stream to be written to</param>
+        /// <param name="value">The value to be written</param>
+        public static void Write(this Stream stream, uint value)
+        {
+            Span<byte> buffer = stackalloc byte[sizeof(uint)];
+            BinaryPrimitives.WriteUInt32LittleEndian(buffer, value);
+            stream.Write(buffer);
+        }
+
+        /// <summary>
+        /// Writes an eight-byte unsigned integer to this stream. The current
+        /// position of the stream is advanced by eight.
+        /// </summary>
+        /// <param name="stream">The stream to be written to</param>
+        /// <param name="value">The value to be written</param>
+        public static void Write(this Stream stream, ulong value)
+        {
+            Span<byte> buffer = stackalloc byte[sizeof(ulong)];
+            BinaryPrimitives.WriteUInt64LittleEndian(buffer, value);
+            stream.Write(buffer);
+        }
+
+        /// <summary>
+        /// Writes the contents of source to stream by calling source.CopyTo(stream).
+        /// Provides consistency with other Stream.Write methods.
+        /// </summary>
+        /// <param name="stream">The stream to be written to</param>
+        /// <param name="source">The stream to be read from</param>
+        public static void Write(this Stream stream, Stream source)
+        {
+            source.CopyTo(stream);
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes to the Stream.
+        /// </summary>
+        /// <param name="stream">The stream to be written to.</param>
+        /// <param name="value">The byte to be written</param>
+        /// <param name="count">The number of times the value should be written</param>
+        public static void WriteByte(this Stream stream, byte value, int count)
+        {
+            if (count <= 0)
+            {
+                return;
+            }
+
+            const int BlockSize = 16;
+
+            int blockCount = count / BlockSize;
+            if (blockCount > 0)
+            {
+                Span<byte> span = stackalloc byte[BlockSize];
+                span.Fill(value);
+                for (int x = 0; x < blockCount; x++)
+                {
+                    stream.Write(span);
+                }
+            }
+
+            int nonBlockBytes = count % BlockSize;
+            for (int x = 0; x < nonBlockBytes; x++)
+            {
+                stream.WriteByte(value);
+            }
+        }
+    }
+}

Ryujinx.Common/Memory/MemoryStreamManager.cs

@@ -0,0 +1,99 @@
+using Microsoft.IO;
+using System;
+
+namespace Ryujinx.Common.Memory
+{
+    public static class MemoryStreamManager
+    {
+        private static readonly RecyclableMemoryStreamManager _shared = new RecyclableMemoryStreamManager();
+
+        /// <summary>
+        /// We don't expose the <c>RecyclableMemoryStreamManager</c> directly because version 2.x
+        /// returns them as <c>MemoryStream</c>. This Shared class is here to a) offer only the GetStream() versions we use
+        /// and b) return them as <c>RecyclableMemoryStream</c> so we don't have to cast.
+        /// </summary>
+        public static class Shared
+        {
+            /// <summary>
+            /// Retrieve a new <c>MemoryStream</c> object with no tag and a default initial capacity.
+            /// </summary>
+            /// <returns>A <c>RecyclableMemoryStream</c></returns>
+            public static RecyclableMemoryStream GetStream()
+                => new RecyclableMemoryStream(_shared);
+
+            /// <summary>
+            /// Retrieve a new <c>MemoryStream</c> object with the contents copied from the provided
+            /// buffer. The provided buffer is not wrapped or used after construction.
+            /// </summary>
+            /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+            /// <param name="buffer">The byte buffer to copy data from</param>
+            /// <returns>A <c>RecyclableMemoryStream</c></returns>
+            public static RecyclableMemoryStream GetStream(byte[] buffer)
+                => GetStream(Guid.NewGuid(), null, buffer, 0, buffer.Length);
+
+            /// <summary>
+            /// Retrieve a new <c>MemoryStream</c> object with the given tag and with contents copied from the provided
+            /// buffer. The provided buffer is not wrapped or used after construction.
+            /// </summary>
+            /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+            /// <param name="buffer">The byte buffer to copy data from</param>
+            /// <returns>A <c>RecyclableMemoryStream</c></returns>
+            public static RecyclableMemoryStream GetStream(ReadOnlySpan<byte> buffer)
+                => GetStream(Guid.NewGuid(), null, buffer);
+
+            /// <summary>
+            /// Retrieve a new <c>RecyclableMemoryStream</c> object with the given tag and with contents copied from the provided
+            /// buffer. The provided buffer is not wrapped or used after construction.
+            /// </summary>
+            /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+            /// <param name="id">A unique identifier which can be used to trace usages of the stream</param>
+            /// <param name="tag">A tag which can be used to track the source of the stream</param>
+            /// <param name="buffer">The byte buffer to copy data from</param>
+            /// <returns>A <c>RecyclableMemoryStream</c></returns>
+            public static RecyclableMemoryStream GetStream(Guid id, string tag, ReadOnlySpan<byte> buffer)
+            {
+                RecyclableMemoryStream stream = null;
+                try
+                {
+                    stream = new RecyclableMemoryStream(_shared, id, tag, buffer.Length);
+                    stream.Write(buffer);
+                    stream.Position = 0;
+                    return stream;
+                }
+                catch
+                {
+                    stream?.Dispose();
+                    throw;
+                }
+            }
+
+            /// <summary>
+            /// Retrieve a new <c>RecyclableMemoryStream</c> object with the given tag and with contents copied from the provided
+            /// buffer. The provided buffer is not wrapped or used after construction.
+            /// </summary>
+            /// <remarks>The new stream's position is set to the beginning of the stream when returned</remarks>
+            /// <param name="id">A unique identifier which can be used to trace usages of the stream</param>
+            /// <param name="tag">A tag which can be used to track the source of the stream</param>
+            /// <param name="buffer">The byte buffer to copy data from</param>
+            /// <param name="offset">The offset from the start of the buffer to copy from</param>
+            /// <param name="count">The number of bytes to copy from the buffer</param>
+            /// <returns>A <c>RecyclableMemoryStream</c></returns>
+            public static RecyclableMemoryStream GetStream(Guid id, string tag, byte[] buffer, int offset, int count)
+            {
+                RecyclableMemoryStream stream = null;
+                try
+                {
+                    stream = new RecyclableMemoryStream(_shared, id, tag, count);
+                    stream.Write(buffer, offset, count);
+                    stream.Position = 0;
+                    return stream;
+                }
+                catch
+                {
+                    stream?.Dispose();
+                    throw;
+                }
+            }
+        }
+    }
+}

Ryujinx.Common/Ryujinx.Common.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" />
     <PackageReference Include="MsgPack.Cli" />
     <PackageReference Include="System.Management" />
   </ItemGroup>

Ryujinx.Common/Utilities/EmbeddedResources.cs

@@ -1,3 +1,5 @@
+using Ryujinx.Common.Memory;
+using Ryujinx.Common.Utilities;
 using System;
 using System.IO;
 using System.Linq;
@@ -38,12 +40,7 @@ namespace Ryujinx.Common
                     return null;
                 }
 
-                using (var mem = new MemoryStream())
-                {
-                    stream.CopyTo(mem);
-
-                    return mem.ToArray();
-                }
+                return StreamUtils.StreamToBytes(stream);
             }
         }
 
@@ -56,12 +53,7 @@ namespace Ryujinx.Common
                     return null;
                 }
 
-                using (var mem = new MemoryStream())
-                {
-                    await stream.CopyToAsync(mem);
-
-                    return mem.ToArray();
-                }
+                return await StreamUtils.StreamToBytesAsync(stream);
             }
         }
 

Ryujinx.Common/Utilities/StreamUtils.cs

@@ -1,4 +1,8 @@
-using System.IO;
+using Microsoft.IO;
+using Ryujinx.Common.Memory;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Ryujinx.Common.Utilities
 {
@@ -6,12 +10,22 @@ namespace Ryujinx.Common.Utilities
     {
         public static byte[] StreamToBytes(Stream input)
         {
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             {
                 input.CopyTo(stream);
 
                 return stream.ToArray();
             }
         }
+
+        public static async Task<byte[]> StreamToBytesAsync(Stream input, CancellationToken cancellationToken = default)
+        {
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
+            {
+                await input.CopyToAsync(stream, cancellationToken);
+
+                return stream.ToArray();
+            }
+        }
     }
 }

Ryujinx.Cpu/MemoryHelper.cs

@@ -1,4 +1,6 @@
-using Ryujinx.Memory;
+using Microsoft.IO;
+using Ryujinx.Common.Memory;
+using Ryujinx.Memory;
 using System;
 using System.IO;
 using System.Runtime.CompilerServices;
@@ -40,7 +42,7 @@ namespace Ryujinx.Cpu
 
         public static string ReadAsciiString(IVirtualMemoryManager memory, ulong position, long maxSize = -1)
         {
-            using (MemoryStream ms = new MemoryStream())
+            using (RecyclableMemoryStream ms = MemoryStreamManager.Shared.GetStream())
             {
                 for (long offs = 0; offs < maxSize || maxSize == -1; offs++)
                 {
@@ -54,7 +56,7 @@ namespace Ryujinx.Cpu
                     ms.WriteByte(value);
                 }
 
-                return Encoding.ASCII.GetString(ms.ToArray());
+                return Encoding.ASCII.GetString(ms.GetReadOnlySequence());
             }
         }
     }

Ryujinx.Cpu/Tracking/CpuRegionHandle.cs

@@ -28,5 +28,10 @@ namespace Ryujinx.Cpu.Tracking
         public void Reprotect(bool asDirty = false) => _impl.Reprotect(asDirty);
 
         public bool OverlapsWith(ulong address, ulong size) => _impl.OverlapsWith(address, size);
+
+        public bool RangeEquals(CpuRegionHandle other)
+        {
+            return _impl.RealAddress == other._impl.RealAddress && _impl.RealSize == other._impl.RealSize;
+        }
     }
 }

Ryujinx.Graphics.GAL/Target.cs

@@ -20,5 +20,15 @@ namespace Ryujinx.Graphics.GAL
         {
             return target == Target.Texture2DMultisample || target == Target.Texture2DMultisampleArray;
         }
+
+        public static bool HasDepthOrLayers(this Target target)
+        {
+            return target == Target.Texture3D ||
+                target == Target.Texture1DArray ||
+                target == Target.Texture2DArray ||
+                target == Target.Texture2DMultisampleArray ||
+                target == Target.Cubemap ||
+                target == Target.CubemapArray;
+        }
     }
 }

Ryujinx.Graphics.Gpu/Engine/Threed/SemaphoreUpdater.cs

@@ -152,21 +152,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             ulong ticks = _context.GetTimestamp();
 
-            float divisor = type switch
-            {
-                ReportCounterType.SamplesPassed => _channel.TextureManager.RenderTargetScale * _channel.TextureManager.RenderTargetScale,
-                _ => 1f
-            };
-
             ICounterEvent counter = null;
 
             void resultHandler(object evt, ulong result)
             {
-                if (divisor != 1f)
-                {
-                    result = (ulong)MathF.Ceiling(result / divisor);
-                }
-
                 CounterData counterData = new CounterData
                 {
                     Counter = result,

Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -36,6 +36,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             public TexturePool Pool;
             public int ID;
+            public ulong GpuAddress;
         }
 
         private GpuContext _context;
@@ -162,6 +163,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         public bool IsView => _viewStorage != this;
 
+        /// <summary>
+        /// Whether or not this texture has views.
+        /// </summary>
+        public bool HasViews => _views.Count > 0;
+
         private int _referenceCount;
         private List<TexturePoolOwner> _poolOwners;
 
@@ -354,7 +360,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             texture._viewStorage = this;
 
-            Group.UpdateViews(_views);
+            Group.UpdateViews(_views, texture);
 
             if (texture.Group != null && texture.Group != Group)
             {
@@ -378,11 +384,24 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             _views.Remove(texture);
 
+            Group.RemoveView(texture);
+
             texture._viewStorage = texture;
 
             DecrementReferenceCount();
         }
 
+        /// <summary>
+        /// Replaces the texture's physical memory range. This forces tracking to regenerate.
+        /// </summary>
+        /// <param name="range">New physical memory range backing the texture</param>
+        public void ReplaceRange(MultiRange range)
+        {
+            Range = range;
+
+            Group.RangeChanged();
+        }
+
         /// <summary>
         /// Create a copy dependency to a texture that is view compatible with this one.
         /// When either texture is modified, the texture data will be copied to the other to keep them in sync.
@@ -715,6 +734,8 @@ namespace Ryujinx.Graphics.Gpu.Image
             height = Math.Max(height >> level, 1);
             depth = Math.Max(depth >> level, 1);
 
+            int sliceDepth = single ? 1 : depth;
+
             SpanOrArray<byte> result;
 
             if (Info.IsLinear)
@@ -735,7 +756,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                     width,
                     height,
                     depth,
-                    single ? 1 : depth,
+                    sliceDepth,
                     levels,
                     layers,
                     Info.FormatInfo.BlockWidth,
@@ -759,7 +780,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                     Info.FormatInfo.BlockHeight,
                     width,
                     height,
-                    depth,
+                    sliceDepth,
                     levels,
                     layers,
                     out byte[] decoded))
@@ -771,7 +792,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 if (GraphicsConfig.EnableTextureRecompression)
                 {
-                    decoded = BCnEncoder.EncodeBC7(decoded, width, height, depth, levels, layers);
+                    decoded = BCnEncoder.EncodeBC7(decoded, width, height, sliceDepth, levels, layers);
                 }
 
                 result = decoded;
@@ -782,15 +803,15 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     case Format.Etc2RgbaSrgb:
                     case Format.Etc2RgbaUnorm:
-                        result = ETC2Decoder.DecodeRgba(result, width, height, depth, levels, layers);
+                        result = ETC2Decoder.DecodeRgba(result, width, height, sliceDepth, levels, layers);
                         break;
                     case Format.Etc2RgbPtaSrgb:
                     case Format.Etc2RgbPtaUnorm:
-                        result = ETC2Decoder.DecodePta(result, width, height, depth, levels, layers);
+                        result = ETC2Decoder.DecodePta(result, width, height, sliceDepth, levels, layers);
                         break;
                     case Format.Etc2RgbSrgb:
                     case Format.Etc2RgbUnorm:
-                        result = ETC2Decoder.DecodeRgb(result, width, height, depth, levels, layers);
+                        result = ETC2Decoder.DecodeRgb(result, width, height, sliceDepth, levels, layers);
                         break;
                 }
             }
@@ -800,31 +821,31 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     case Format.Bc1RgbaSrgb:
                     case Format.Bc1RgbaUnorm:
-                        result = BCnDecoder.DecodeBC1(result, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC1(result, width, height, sliceDepth, levels, layers);
                         break;
                     case Format.Bc2Srgb:
                     case Format.Bc2Unorm:
-                        result = BCnDecoder.DecodeBC2(result, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC2(result, width, height, sliceDepth, levels, layers);
                         break;
                     case Format.Bc3Srgb:
                     case Format.Bc3Unorm:
-                        result = BCnDecoder.DecodeBC3(result, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC3(result, width, height, sliceDepth, levels, layers);
                         break;
                     case Format.Bc4Snorm:
                     case Format.Bc4Unorm:
-                        result = BCnDecoder.DecodeBC4(result, width, height, depth, levels, layers, Format == Format.Bc4Snorm);
+                        result = BCnDecoder.DecodeBC4(result, width, height, sliceDepth, levels, layers, Format == Format.Bc4Snorm);
                         break;
                     case Format.Bc5Snorm:
                     case Format.Bc5Unorm:
-                        result = BCnDecoder.DecodeBC5(result, width, height, depth, levels, layers, Format == Format.Bc5Snorm);
+                        result = BCnDecoder.DecodeBC5(result, width, height, sliceDepth, levels, layers, Format == Format.Bc5Snorm);
                         break;
                     case Format.Bc6HSfloat:
                     case Format.Bc6HUfloat:
-                        result = BCnDecoder.DecodeBC6(result, width, height, depth, levels, layers, Format == Format.Bc6HSfloat);
+                        result = BCnDecoder.DecodeBC6(result, width, height, sliceDepth, levels, layers, Format == Format.Bc6HSfloat);
                         break;
                     case Format.Bc7Srgb:
                     case Format.Bc7Unorm:
-                        result = BCnDecoder.DecodeBC7(result, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC7(result, width, height, sliceDepth, levels, layers);
                         break;
                 }
             }
@@ -1454,8 +1475,8 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             MultiRange otherRange = texture.Range;
 
-            IEnumerable<MultiRange> regions = _sizeInfo.AllRegions().Select((region) => Range.GetSlice((ulong)region.Offset, (ulong)region.Size));
-            IEnumerable<MultiRange> otherRegions = texture._sizeInfo.AllRegions().Select((region) => otherRange.GetSlice((ulong)region.Offset, (ulong)region.Size));
+            IEnumerable<MultiRange> regions = _sizeInfo.AllRegions().Select((region) => Range.Slice((ulong)region.Offset, (ulong)region.Size));
+            IEnumerable<MultiRange> otherRegions = texture._sizeInfo.AllRegions().Select((region) => otherRange.Slice((ulong)region.Offset, (ulong)region.Size));
 
             foreach (MultiRange region in regions)
             {
@@ -1484,11 +1505,12 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         /// <param name="pool">The texture pool this texture has been added to</param>
         /// <param name="id">The ID of the reference to this texture in the pool</param>
-        public void IncrementReferenceCount(TexturePool pool, int id)
+        /// <param name="gpuVa">GPU VA of the pool reference</param>
+        public void IncrementReferenceCount(TexturePool pool, int id, ulong gpuVa)
         {
             lock (_poolOwners)
             {
-                _poolOwners.Add(new TexturePoolOwner { Pool = pool, ID = id });
+                _poolOwners.Add(new TexturePoolOwner { Pool = pool, ID = id, GpuAddress = gpuVa });
             }
             _referenceCount++;
 
@@ -1585,6 +1607,36 @@ namespace Ryujinx.Graphics.Gpu.Image
             InvalidatedSequence++;
         }
 
+        /// <summary>
+        /// Queue updating texture mappings on the pool. Happens from another thread.
+        /// </summary>
+        public void UpdatePoolMappings()
+        {
+            lock (_poolOwners)
+            {
+                ulong address = 0;
+
+                foreach (var owner in _poolOwners)
+                {
+                    if (address == 0 || address == owner.GpuAddress)
+                    {
+                        address = owner.GpuAddress;
+
+                        owner.Pool.QueueUpdateMapping(this, owner.ID);
+                    }
+                    else
+                    {
+                        // If there is a different GPU VA mapping, prefer the first and delete the others.
+                        owner.Pool.ForceRemove(this, owner.ID, true);
+                    }
+                }
+
+                _poolOwners.Clear();
+            }
+
+            InvalidatedSequence++;
+        }
+
         /// <summary>
         /// Delete the texture if it is not used anymore.
         /// The texture is considered unused when the reference count is zero,
@@ -1636,7 +1688,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 Group.ClearModified(unmapRange);
             }
 
-            RemoveFromPools(true);
+            UpdatePoolMappings();
         }
 
         /// <summary>

Ryujinx.Graphics.Gpu/Image/TextureCache.cs

@@ -194,6 +194,39 @@ namespace Ryujinx.Graphics.Gpu.Image
             _cache.Lift(texture);
         }
 
+        /// <summary>
+        /// Attempts to update a texture's physical memory range.
+        /// Returns false if there is an existing texture that matches with the updated range.
+        /// </summary>
+        /// <param name="texture">Texture to update</param>
+        /// <param name="range">New physical memory range</param>
+        /// <returns>True if the mapping was updated, false otherwise</returns>
+        public bool UpdateMapping(Texture texture, MultiRange range)
+        {
+            // There cannot be an existing texture compatible with this mapping in the texture cache already.
+            int overlapCount = _textures.FindOverlaps(range, ref _textureOverlaps);
+
+            for (int i = 0; i < overlapCount; i++)
+            {
+                var other = _textureOverlaps[i];
+                
+                if (texture != other &&
+                    (texture.IsViewCompatible(other.Info, other.Range, true, other.LayerSize, _context.Capabilities, out _, out _) != TextureViewCompatibility.Incompatible ||
+                    other.IsViewCompatible(texture.Info, texture.Range, true, texture.LayerSize, _context.Capabilities, out _, out _) != TextureViewCompatibility.Incompatible))
+                {
+                    return false;
+                }
+            }
+
+            _textures.Remove(texture);
+
+            texture.ReplaceRange(range);
+
+            _textures.Add(texture);
+
+            return true;
+        }
+
         /// <summary>
         /// Tries to find an existing texture, or create a new one if not found.
         /// </summary>

Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -39,6 +39,11 @@ namespace Ryujinx.Graphics.Gpu.Image
     /// </summary>
     class TextureGroup : IDisposable
     {
+        /// <summary>
+        /// Threshold of layers to force granular handles (and thus partial loading) on array/3D textures.
+        /// </summary>
+        private const int GranularLayerThreshold = 8;
+
         private delegate void HandlesCallbackDelegate(int baseHandle, int regionCount, bool split = false);
 
         /// <summary>
@@ -116,7 +121,29 @@ namespace Ryujinx.Graphics.Gpu.Image
             _allOffsets = size.AllOffsets;
             _sliceSizes = size.SliceSizes;
 
-            (_hasLayerViews, _hasMipViews) = PropagateGranularity(hasLayerViews, hasMipViews);
+            if (Storage.Target.HasDepthOrLayers() && Storage.Info.GetSlices() > GranularLayerThreshold)
+            {
+                _hasLayerViews = true;
+                _hasMipViews = true;
+            }
+            else
+            {
+                (_hasLayerViews, _hasMipViews) = PropagateGranularity(hasLayerViews, hasMipViews);
+
+                // If the texture is partially mapped, fully subdivide handles immediately.
+
+                MultiRange range = Storage.Range;
+                for (int i = 0; i < range.Count; i++)
+                {
+                    if (range.GetSubRange(i).Address == MemoryManager.PteUnmapped)
+                    {
+                        _hasLayerViews = true;
+                        _hasMipViews = true;
+
+                        break;
+                    }
+                }
+            }
 
             RecalculateHandleRegions();
         }
@@ -249,7 +276,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             {
                 bool dirty = false;
                 bool anyModified = false;
-                bool anyUnmapped = false;
+                bool anyNotDirty = false;
 
                 for (int i = 0; i < regionCount; i++)
                 {
@@ -294,20 +321,21 @@ namespace Ryujinx.Graphics.Gpu.Image
                         dirty |= handleDirty;
                     }
 
-                    anyUnmapped |= handleUnmapped;
-
                     if (group.NeedsCopy)
                     {
                         // The texture we copied from is still being written to. Copy from it again the next time this texture is used.
                         texture.SignalGroupDirty();
                     }
 
-                    _loadNeeded[baseHandle + i] = handleDirty && !handleUnmapped;
+                    bool loadNeeded = handleDirty && !handleUnmapped;
+
+                    anyNotDirty |= !loadNeeded;
+                    _loadNeeded[baseHandle + i] = loadNeeded;
                 }
 
                 if (dirty)
                 {
-                    if (anyUnmapped || (_handles.Length > 1 && (anyModified || split)))
+                    if (anyNotDirty || (_handles.Length > 1 && (anyModified || split)))
                     {
                         // Partial texture invalidation. Only update the layers/levels with dirty flags of the storage.
 
@@ -331,24 +359,56 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="regionCount">The number of handles to synchronize</param>
         private void SynchronizePartial(int baseHandle, int regionCount)
         {
+            int spanEndIndex = -1;
+            int spanBase = 0;
+            ReadOnlySpan<byte> dataSpan = ReadOnlySpan<byte>.Empty;
+
             for (int i = 0; i < regionCount; i++)
             {
                 if (_loadNeeded[baseHandle + i])
                 {
                     var info = GetHandleInformation(baseHandle + i);
 
+                    // Ensure the data for this handle is loaded in the span.
+                    if (spanEndIndex <= i - 1)
+                    {
+                        spanEndIndex = i;
+
+                        if (_is3D)
+                        {
+                            // Look ahead to see how many handles need to be loaded.
+                            for (int j = i + 1; j < regionCount; j++)
+                            {
+                                if (_loadNeeded[baseHandle + j])
+                                {
+                                    spanEndIndex = j;
+                                }
+                                else
+                                {
+                                    break;
+                                }
+                            }
+                        }
+
+                        var endInfo = spanEndIndex == i ? info : GetHandleInformation(baseHandle + spanEndIndex);
+
+                        spanBase = _allOffsets[info.Index];
+                        int spanLast = _allOffsets[endInfo.Index + endInfo.Layers * endInfo.Levels - 1];
+                        int endOffset = Math.Min(spanLast + _sliceSizes[endInfo.BaseLevel + endInfo.Levels - 1], (int)Storage.Size);
+                        int size = endOffset - spanBase;
+
+                        dataSpan = _physicalMemory.GetSpan(Storage.Range.Slice((ulong)spanBase, (ulong)size));
+                    }
+
                     // Only one of these will be greater than 1, as partial sync is only called when there are sub-image views.
                     for (int layer = 0; layer < info.Layers; layer++)
                     {
                         for (int level = 0; level < info.Levels; level++)
                         {
                             int offsetIndex = GetOffsetIndex(info.BaseLayer + layer, info.BaseLevel + level);
-
                             int offset = _allOffsets[offsetIndex];
-                            int endOffset = Math.Min(offset + _sliceSizes[info.BaseLevel + level], (int)Storage.Size);
-                            int size = endOffset - offset;
 
-                            ReadOnlySpan<byte> data = _physicalMemory.GetSpan(Storage.Range.GetSlice((ulong)offset, (ulong)size));
+                            ReadOnlySpan<byte> data = dataSpan.Slice(offset - spanBase);
 
                             SpanOrArray<byte> result = Storage.ConvertToHostCompatibleFormat(data, info.BaseLevel + level, true);
 
@@ -413,7 +473,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             int endOffset = Math.Min(offset + _sliceSizes[level], (int)Storage.Size);
             int size = endOffset - offset;
 
-            using WritableRegion region = _physicalMemory.GetWritableRegion(Storage.Range.GetSlice((ulong)offset, (ulong)size), tracked);
+            using WritableRegion region = _physicalMemory.GetWritableRegion(Storage.Range.Slice((ulong)offset, (ulong)size), tracked);
 
             Storage.GetTextureDataSliceFromGpu(region.Memory.Span, layer, level, tracked, texture);
         }
@@ -865,8 +925,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <returns>A TextureGroupHandle covering the given views</returns>
         private TextureGroupHandle GenerateHandles(int viewStart, int views)
         {
+            int viewEnd = viewStart + views - 1;
+            (_, int lastLevel) = GetLayerLevelForView(viewEnd);
+
             int offset = _allOffsets[viewStart];
-            int endOffset = (viewStart + views == _allOffsets.Length) ? (int)Storage.Size : _allOffsets[viewStart + views];
+            int endOffset = _allOffsets[viewEnd] + _sliceSizes[lastLevel];
             int size = endOffset - offset;
 
             var result = new List<CpuRegionHandle>();
@@ -926,7 +989,8 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// Update the views in this texture group, rebuilding the memory tracking if required.
         /// </summary>
         /// <param name="views">The views list of the storage texture</param>
-        public void UpdateViews(List<Texture> views)
+        /// <param name="texture">The texture that has been added, if that is the only change, otherwise null</param>
+        public void UpdateViews(List<Texture> views, Texture texture)
         {
             // This is saved to calculate overlapping views for each handle.
             _views = views;
@@ -964,17 +1028,44 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             if (!regionsRebuilt)
             {
-                // Must update the overlapping views on all handles, but only if they were not just recreated.
-
-                foreach (TextureGroupHandle handle in _handles)
+                if (texture != null)
                 {
-                    handle.RecalculateOverlaps(this, views);
+                    int offset = FindOffset(texture);
+
+                    foreach (TextureGroupHandle handle in _handles)
+                    {
+                        handle.AddOverlap(offset, texture);
+                    }
+                }
+                else
+                {
+                    // Must update the overlapping views on all handles, but only if they were not just recreated.
+
+                    foreach (TextureGroupHandle handle in _handles)
+                    {
+                        handle.RecalculateOverlaps(this, views);
+                    }
                 }
             }
 
             SignalAllDirty();
         }
 
+
+        /// <summary>
+        /// Removes a view from the group, removing it from all overlap lists.
+        /// </summary>
+        /// <param name="view">View to remove from the group</param>
+        public void RemoveView(Texture view)
+        {
+            int offset = FindOffset(view);
+
+            foreach (TextureGroupHandle handle in _handles)
+            {
+                handle.RemoveOverlap(offset, view);
+            }
+        }
+
         /// <summary>
         /// Inherit handle state from an old set of handles, such as modified and dirty flags.
         /// </summary>
@@ -1057,7 +1148,8 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// The dirty flags from the previous handles will be kept.
         /// </summary>
         /// <param name="handles">The handles to replace the current handles with</param>
-        private void ReplaceHandles(TextureGroupHandle[] handles)
+        /// <param name="rangeChanged">True if the storage memory range changed since the last region handle generation</param>
+        private void ReplaceHandles(TextureGroupHandle[] handles, bool rangeChanged)
         {
             if (_handles != null)
             {
@@ -1065,9 +1157,50 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 foreach (TextureGroupHandle groupHandle in handles)
                 {
-                    foreach (CpuRegionHandle handle in groupHandle.Handles)
+                    if (rangeChanged)
                     {
-                        handle.Reprotect();
+                        // When the storage range changes, this becomes a little different.
+                        // If a range does not match one in the original, treat it as modified.
+                        // It has been newly mapped and its data must be synchronized.
+
+                        if (groupHandle.Handles.Length == 0)
+                        {
+                            continue;
+                        }
+
+                        foreach (var oldGroup in _handles)
+                        {
+                            if (!groupHandle.OverlapsWith(oldGroup.Offset, oldGroup.Size))
+                            {
+                                continue;
+                            }
+
+                            foreach (CpuRegionHandle handle in groupHandle.Handles)
+                            {
+                                bool hasMatch = false;
+
+                                foreach (var oldHandle in oldGroup.Handles)
+                                {
+                                    if (oldHandle.RangeEquals(handle))
+                                    {
+                                        hasMatch = true;
+                                        break;
+                                    }
+                                }
+
+                                if (hasMatch)
+                                {
+                                    handle.Reprotect();
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        foreach (CpuRegionHandle handle in groupHandle.Handles)
+                        {
+                            handle.Reprotect();
+                        }
                     }
                 }
 
@@ -1089,7 +1222,8 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <summary>
         /// Recalculate handle regions for this texture group, and inherit existing state into the new handles.
         /// </summary>
-        private void RecalculateHandleRegions()
+        /// <param name="rangeChanged">True if the storage memory range changed since the last region handle generation</param>
+        private void RecalculateHandleRegions(bool rangeChanged = false)
         {
             TextureGroupHandle[] handles;
 
@@ -1171,7 +1305,21 @@ namespace Ryujinx.Graphics.Gpu.Image
                 }
             }
 
-            ReplaceHandles(handles);
+            ReplaceHandles(handles, rangeChanged);
+        }
+
+        /// <summary>
+        /// Regenerates handles when the storage range has been remapped.
+        /// This forces the regions to be fully subdivided.
+        /// </summary>
+        public void RangeChanged()
+        {
+            _hasLayerViews = true;
+            _hasMipViews = true;
+
+            RecalculateHandleRegions(true);
+
+            SignalAllDirty();
         }
 
         /// <summary>
@@ -1271,13 +1419,13 @@ namespace Ryujinx.Graphics.Gpu.Image
             for (int i = 0; i < _allOffsets.Length; i++)
             {
                 (int layer, int level) = GetLayerLevelForView(i);
-                MultiRange handleRange = Storage.Range.GetSlice((ulong)_allOffsets[i], 1);
+                MultiRange handleRange = Storage.Range.Slice((ulong)_allOffsets[i], 1);
                 ulong handleBase = handleRange.GetSubRange(0).Address;
 
                 for (int j = 0; j < other._handles.Length; j++)
                 {
                     (int otherLayer, int otherLevel) = other.GetLayerLevelForView(j);
-                    MultiRange otherHandleRange = other.Storage.Range.GetSlice((ulong)other._allOffsets[j], 1);
+                    MultiRange otherHandleRange = other.Storage.Range.Slice((ulong)other._allOffsets[j], 1);
                     ulong otherHandleBase = otherHandleRange.GetSubRange(0).Address;
 
                     if (handleBase == otherHandleBase)
@@ -1354,7 +1502,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 // Handles list is not modified by another thread, only replaced, so this is thread safe.
                 // Remove modified flags from all overlapping handles, so that the textures don't flush to unmapped/remapped GPU memory.
 
-                MultiRange subRange = Storage.Range.GetSlice((ulong)handle.Offset, (ulong)handle.Size);
+                MultiRange subRange = Storage.Range.Slice((ulong)handle.Offset, (ulong)handle.Size);
 
                 if (range.OverlapsWith(subRange))
                 {

Ryujinx.Graphics.Gpu/Image/TextureGroupHandle.cs

@@ -159,6 +159,42 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
         }
 
+        /// <summary>
+        /// Adds a single texture view as an overlap if its range overlaps.
+        /// </summary>
+        /// <param name="offset">The offset of the view in the group</param>
+        /// <param name="view">The texture to add as an overlap</param>
+        public void AddOverlap(int offset, Texture view)
+        {
+            // Overlaps can be accessed from the memory tracking signal handler, so access must be atomic.
+
+            if (OverlapsWith(offset, (int)view.Size))
+            {
+                lock (Overlaps)
+                {
+                    Overlaps.Add(view);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Removes a single texture view as an overlap if its range overlaps.
+        /// </summary>
+        /// <param name="offset">The offset of the view in the group</param>
+        /// <param name="view">The texture to add as an overlap</param>
+        public void RemoveOverlap(int offset, Texture view)
+        {
+            // Overlaps can be accessed from the memory tracking signal handler, so access must be atomic.
+
+            if (OverlapsWith(offset, (int)view.Size))
+            {
+                lock (Overlaps)
+                {
+                    Overlaps.Remove(view);
+                }
+            }
+        }
+
         /// <summary>
         /// Registers a sync action to happen for this handle, and an interim flush action on the tracking handle.
         /// </summary>

Ryujinx.Graphics.Gpu/Image/TexturePool.cs

@@ -1,9 +1,12 @@
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Texture;
+using Ryujinx.Memory.Range;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Threading;
 
 namespace Ryujinx.Graphics.Gpu.Image
 {
@@ -12,8 +15,63 @@ namespace Ryujinx.Graphics.Gpu.Image
     /// </summary>
     class TexturePool : Pool<Texture, TextureDescriptor>, IPool<TexturePool>
     {
+        /// <summary>
+        /// A request to dereference a texture from a pool.
+        /// </summary>
+        private struct DereferenceRequest
+        {
+            /// <summary>
+            /// Whether the dereference is due to a mapping change or not.
+            /// </summary>
+            public readonly bool IsRemapped;
+
+            /// <summary>
+            /// The texture being dereferenced.
+            /// </summary>
+            public readonly Texture Texture;
+
+            /// <summary>
+            /// The ID of the pool entry this reference belonged to.
+            /// </summary>
+            public readonly int ID;
+
+            /// <summary>
+            /// Create a dereference request for a texture with a specific pool ID, and remapped flag.
+            /// </summary>
+            /// <param name="isRemapped">Whether the dereference is due to a mapping change or not</param>
+            /// <param name="texture">The texture being dereferenced</param>
+            /// <param name="id">The ID of the pool entry, used to restore remapped textures</param>
+            private DereferenceRequest(bool isRemapped, Texture texture, int id)
+            {
+                IsRemapped = isRemapped;
+                Texture = texture;
+                ID = id;
+            }
+
+            /// <summary>
+            /// Create a dereference request for a texture removal.
+            /// </summary>
+            /// <param name="texture">The texture being removed</param>
+            /// <returns>A texture removal dereference request</returns>
+            public static DereferenceRequest Remove(Texture texture)
+            {
+                return new DereferenceRequest(false, texture, 0);
+            }
+
+            /// <summary>
+            /// Create a dereference request for a texture remapping with a specific pool ID.
+            /// </summary>
+            /// <param name="texture">The texture being remapped</param>
+            /// <param name="id">The ID of the pool entry, used to restore remapped textures</param>
+            /// <returns>A remap dereference request</returns>
+            public static DereferenceRequest Remap(Texture texture, int id)
+            {
+                return new DereferenceRequest(true, texture, id);
+            }
+        }
+
         private readonly GpuChannel _channel;
-        private readonly ConcurrentQueue<Texture> _dereferenceQueue = new ConcurrentQueue<Texture>();
+        private readonly ConcurrentQueue<DereferenceRequest> _dereferenceQueue = new ConcurrentQueue<DereferenceRequest>();
         private TextureDescriptor _defaultDescriptor;
 
         /// <summary>
@@ -58,7 +116,11 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     TextureInfo info = GetInfo(descriptor, out int layerSize);
 
-                    ProcessDereferenceQueue();
+                    // The dereference queue can put our texture back on the cache.
+                    if ((texture = ProcessDereferenceQueue(id)) != null)
+                    {
+                        return ref descriptor;
+                    }
 
                     texture = PhysicalMemory.TextureCache.FindOrCreateTexture(_channel.MemoryManager, TextureSearchFlags.ForSampler, info, layerSize);
 
@@ -69,10 +131,10 @@ namespace Ryujinx.Graphics.Gpu.Image
                     }
                 }
 
-                texture.IncrementReferenceCount(this, id);
-
                 Items[id] = texture;
 
+                texture.IncrementReferenceCount(this, id, descriptor.UnpackAddress());
+
                 DescriptorCache[id] = descriptor;
             }
             else
@@ -155,11 +217,14 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="deferred">If true, queue the dereference to happen on the render thread, otherwise dereference immediately</param>
         public void ForceRemove(Texture texture, int id, bool deferred)
         {
-            Items[id] = null;
+            var previous = Interlocked.Exchange(ref Items[id], null);
 
             if (deferred)
             {
-                _dereferenceQueue.Enqueue(texture);
+                if (previous != null)
+                {
+                    _dereferenceQueue.Enqueue(DereferenceRequest.Remove(texture));
+                }
             }
             else
             {
@@ -167,16 +232,91 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
         }
 
+        /// <summary>
+        /// Queues a request to update a texture's mapping. 
+        /// Mapping is updated later to avoid deleting the texture if it is still sparsely mapped.
+        /// </summary>
+        /// <param name="texture">Texture with potential mapping change</param>
+        /// <param name="id">ID in cache of texture with potential mapping change</param>
+        public void QueueUpdateMapping(Texture texture, int id)
+        {
+            if (Interlocked.Exchange(ref Items[id], null) == texture)
+            {
+                _dereferenceQueue.Enqueue(DereferenceRequest.Remap(texture, id));
+            }
+        }
+
         /// <summary>
         /// Process the dereference queue, decrementing the reference count for each texture in it.
         /// This is used to ensure that texture disposal happens on the render thread.
         /// </summary>
-        private void ProcessDereferenceQueue()
+        /// <param name="id">The ID of the entry that triggered this method</param>
+        /// <returns>Texture that matches the entry ID if it has been readded to the cache.</returns>
+        private Texture ProcessDereferenceQueue(int id = -1)
         {
-            while (_dereferenceQueue.TryDequeue(out Texture toRemove))
+            while (_dereferenceQueue.TryDequeue(out DereferenceRequest request))
             {
-                toRemove.DecrementReferenceCount();
+                Texture texture = request.Texture;
+
+                // Unmapped storage textures can swap their ranges. The texture must be storage with no views or dependencies.
+                // TODO: Would need to update ranges on views, or guarantee that ones where the range changes can be instantly deleted.
+
+                if (request.IsRemapped && texture.Group.Storage == texture && !texture.HasViews && !texture.Group.HasCopyDependencies)
+                {
+                    // Has the mapping for this texture changed?
+                    ref readonly TextureDescriptor descriptor = ref GetDescriptorRef(request.ID);
+
+                    ulong address = descriptor.UnpackAddress();
+
+                    MultiRange range = _channel.MemoryManager.GetPhysicalRegions(address, texture.Size);
+
+                    // If the texture is not mapped at all, delete its reference.
+
+                    if (range.Count == 1 && range.GetSubRange(0).Address == MemoryManager.PteUnmapped)
+                    {
+                        texture.DecrementReferenceCount();
+                        continue;
+                    }
+
+                    Items[request.ID] = texture;
+
+                    // Create a new pool reference, as the last one was removed on unmap.
+
+                    texture.IncrementReferenceCount(this, request.ID, address);
+                    texture.DecrementReferenceCount();
+
+                    // Refetch the range. Changes since the last check could have been lost
+                    // as the cache entry was not restored (required to queue mapping change).
+
+                    range = _channel.MemoryManager.GetPhysicalRegions(address, texture.Size);
+
+                    if (!range.Equals(texture.Range))
+                    {
+                        // Part of the texture was mapped or unmapped. Replace the range and regenerate tracking handles.
+                        if (!_channel.MemoryManager.Physical.TextureCache.UpdateMapping(texture, range))
+                        {
+                            // Texture could not be remapped due to a collision, just delete it.
+                            if (Interlocked.Exchange(ref Items[request.ID], null) != null)
+                            {
+                                // If this is null, a request was already queued to decrement reference.
+                                texture.DecrementReferenceCount(this, request.ID);
+                            }
+                            continue;
+                        }
+                    }
+
+                    if (request.ID == id)
+                    {
+                        return texture;
+                    }
+                }
+                else
+                {
+                    texture.DecrementReferenceCount();
+                }
             }
+
+            return null;
         }
 
         /// <summary>
@@ -213,9 +353,10 @@ namespace Ryujinx.Graphics.Gpu.Image
                         _channel.MemoryManager.Physical.TextureCache.AddShortCache(texture, ref cachedDescriptor);
                     }
 
-                    texture.DecrementReferenceCount(this, id);
-
-                    Items[id] = null;
+                    if (Interlocked.Exchange(ref Items[id], null) != null)
+                    {
+                        texture.DecrementReferenceCount(this, id);
+                    }
                 }
             }
         }

Ryujinx.Graphics.Gpu/Shader/DiskCache/ShaderBinarySerializer.cs

@@ -1,3 +1,5 @@
+using Ryujinx.Common;
+using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Shader;
 using Ryujinx.Graphics.Shader.Translation;
@@ -11,16 +13,15 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
     {
         public static byte[] Pack(ShaderSource[] sources)
         {
-            using MemoryStream output = new MemoryStream();
-            using BinaryWriter writer = new BinaryWriter(output);
+            using MemoryStream output = MemoryStreamManager.Shared.GetStream();
 
-            writer.Write(sources.Length);
+            output.Write(sources.Length);
 
-            for (int i = 0; i < sources.Length; i++)
+            foreach (ShaderSource source in sources)
             {
-                writer.Write((int)sources[i].Stage);
-                writer.Write(sources[i].BinaryCode.Length);
-                writer.Write(sources[i].BinaryCode);
+                output.Write((int)source.Stage);
+                output.Write(source.BinaryCode.Length);
+                output.Write(source.BinaryCode);
             }
 
             return output.ToArray();

Ryujinx.Graphics.OpenGL/OpenGLRenderer.cs

@@ -178,7 +178,7 @@ namespace Ryujinx.Graphics.OpenGL
             }
 
             _pipeline.Initialize(this);
-            _counters.Initialize();
+            _counters.Initialize(_pipeline);
 
             // This is required to disable [0, 1] clamping for SNorm outputs on compatibility profiles.
             // This call is expected to fail if we're running with a core profile,

Ryujinx.Graphics.OpenGL/Pipeline.cs

@@ -773,6 +773,16 @@ namespace Ryujinx.Graphics.OpenGL
             _tfEnabled = false;
         }
 
+        public double GetCounterDivisor(CounterType type)
+        {
+            if (type == CounterType.SamplesPassed)
+            {
+                return _renderScale[0].X * _renderScale[0].X;
+            }
+
+            return 1;
+        }
+
         public void SetAlphaTest(bool enable, float reference, CompareOp op)
         {
             if (!enable)

Ryujinx.Graphics.OpenGL/Queries/BufferedQuery.cs

@@ -10,6 +10,7 @@ namespace Ryujinx.Graphics.OpenGL.Queries
     {
         private const int MaxQueryRetries = 5000;
         private const long DefaultValue = -1;
+        private const ulong HighMask = 0xFFFFFFFF00000000;
 
         public int Query { get; }
 
@@ -63,11 +64,17 @@ namespace Ryujinx.Graphics.OpenGL.Queries
             }
         }
 
+        private bool WaitingForValue(long data)
+        {
+            return data == DefaultValue ||
+                ((ulong)data & HighMask) == (unchecked((ulong)DefaultValue) & HighMask);
+        }
+
         public bool TryGetResult(out long result)
         {
             result = Marshal.ReadInt64(_bufferMap);
 
-            return result != DefaultValue;
+            return !WaitingForValue(result);
         }
 
         public long AwaitResult(AutoResetEvent wakeSignal = null)
@@ -76,7 +83,7 @@ namespace Ryujinx.Graphics.OpenGL.Queries
 
             if (wakeSignal == null)
             {
-                while (data == DefaultValue)
+                while (WaitingForValue(data))
                 {
                     data = Marshal.ReadInt64(_bufferMap);
                 }
@@ -84,10 +91,10 @@ namespace Ryujinx.Graphics.OpenGL.Queries
             else
             {
                 int iterations = 0;
-                while (data == DefaultValue && iterations++ < MaxQueryRetries)
+                while (WaitingForValue(data) && iterations++ < MaxQueryRetries)
                 {
                     data = Marshal.ReadInt64(_bufferMap);
-                    if (data == DefaultValue)
+                    if (WaitingForValue(data))
                     {
                         wakeSignal.WaitOne(1);
                     }

Ryujinx.Graphics.OpenGL/Queries/CounterQueue.cs

@@ -13,6 +13,8 @@ namespace Ryujinx.Graphics.OpenGL.Queries
         public CounterType Type { get; }
         public bool Disposed { get; private set; }
 
+        private readonly Pipeline _pipeline;
+
         private Queue<CounterQueueEvent> _events = new Queue<CounterQueueEvent>();
         private CounterQueueEvent _current;
 
@@ -28,10 +30,12 @@ namespace Ryujinx.Graphics.OpenGL.Queries
 
         private Thread _consumerThread;
 
-        internal CounterQueue(CounterType type)
+        internal CounterQueue(Pipeline pipeline, CounterType type)
         {
             Type = type;
 
+            _pipeline = pipeline;
+
             QueryTarget glType = GetTarget(Type);
 
             _queryPool = new Queue<BufferedQuery>(QueryPoolInitialSize);
@@ -119,7 +123,7 @@ namespace Ryujinx.Graphics.OpenGL.Queries
                     _current.ReserveForHostAccess();
                 }
 
-                _current.Complete(draws > 0);
+                _current.Complete(draws > 0, _pipeline.GetCounterDivisor(Type));
                 _events.Enqueue(_current);
 
                 _current.OnResult += resultHandler;

Ryujinx.Graphics.OpenGL/Queries/CounterQueueEvent.cs

@@ -26,6 +26,7 @@ namespace Ryujinx.Graphics.OpenGL.Queries
 
         private object _lock = new object();
         private ulong _result = ulong.MaxValue;
+        private double _divisor = 1f;
 
         public CounterQueueEvent(CounterQueue queue, QueryTarget type, ulong drawIndex)
         {
@@ -45,9 +46,11 @@ namespace Ryujinx.Graphics.OpenGL.Queries
             ClearCounter = true;
         }
 
-        internal void Complete(bool withResult)
+        internal void Complete(bool withResult, double divisor)
         {
             _counter.End(withResult);
+
+            _divisor = divisor;
         }
 
         internal bool TryConsume(ref ulong result, bool block, AutoResetEvent wakeSignal = null)
@@ -78,7 +81,7 @@ namespace Ryujinx.Graphics.OpenGL.Queries
                     }
                 }
 
-                result += (ulong)queryResult;
+                result += _divisor == 1 ? (ulong)queryResult : (ulong)Math.Ceiling(queryResult / _divisor);
 
                 _result = result;
 

Ryujinx.Graphics.OpenGL/Queries/Counters.cs

@@ -14,12 +14,12 @@ namespace Ryujinx.Graphics.OpenGL.Queries
             _counterQueues = new CounterQueue[count];
         }
 
-        public void Initialize()
+        public void Initialize(Pipeline pipeline)
         {
             for (int index = 0; index < _counterQueues.Length; index++)
             {
                 CounterType type = (CounterType)index;
-                _counterQueues[index] = new CounterQueue(type);
+                _counterQueues[index] = new CounterQueue(pipeline, type);
             }
         }
 

Ryujinx.Graphics.Texture/LayoutConverter.cs

@@ -112,7 +112,7 @@ namespace Ryujinx.Graphics.Texture
             int outSize = GetTextureSize(
                 width,
                 height,
-                depth,
+                sliceDepth,
                 levels,
                 layers,
                 blockWidth,

Ryujinx.Graphics.Vulkan/PipelineBase.cs

@@ -684,6 +684,16 @@ namespace Ryujinx.Graphics.Vulkan
             _tfEnabled = false;
         }
 
+        public double GetCounterDivisor(CounterType type)
+        {
+            if (type == CounterType.SamplesPassed)
+            {
+                return _renderScale[0].X * _renderScale[0].X;
+            }
+
+            return 1;
+        }
+
         public bool IsCommandBufferActive(CommandBuffer cb)
         {
             return CommandBuffer.Handle == cb.Handle;

Ryujinx.Graphics.Vulkan/Queries/BufferedQuery.cs

@@ -12,6 +12,7 @@ namespace Ryujinx.Graphics.Vulkan.Queries
         private const int MaxQueryRetries = 5000;
         private const long DefaultValue = -1;
         private const long DefaultValueInt = 0xFFFFFFFF;
+        private const ulong HighMask = 0xFFFFFFFF00000000;
 
         private readonly Vk _api;
         private readonly Device _device;
@@ -125,6 +126,12 @@ namespace Ryujinx.Graphics.Vulkan.Queries
             }
         }
 
+        private bool WaitingForValue(long data)
+        {
+            return data == _defaultValue ||
+                (!_result32Bit && ((ulong)data & HighMask) == ((ulong)_defaultValue & HighMask));
+        }
+
         public bool TryGetResult(out long result)
         {
             result = Marshal.ReadInt64(_bufferMap);
@@ -138,7 +145,7 @@ namespace Ryujinx.Graphics.Vulkan.Queries
 
             if (wakeSignal == null)
             {
-                while (data == _defaultValue)
+                while (WaitingForValue(data))
                 {
                     data = Marshal.ReadInt64(_bufferMap);
                 }
@@ -146,10 +153,10 @@ namespace Ryujinx.Graphics.Vulkan.Queries
             else
             {
                 int iterations = 0;
-                while (data == _defaultValue && iterations++ < MaxQueryRetries)
+                while (WaitingForValue(data) && iterations++ < MaxQueryRetries)
                 {
                     data = Marshal.ReadInt64(_bufferMap);
-                    if (data == _defaultValue)
+                    if (WaitingForValue(data))
                     {
                         wakeSignal.WaitOne(1);
                     }

Ryujinx.Graphics.Vulkan/Queries/CounterQueue.cs

@@ -148,7 +148,7 @@ namespace Ryujinx.Graphics.Vulkan.Queries
                     _current.ReserveForHostAccess();
                 }
 
-                _current.Complete(draws > 0 && Type != CounterType.TransformFeedbackPrimitivesWritten);
+                _current.Complete(draws > 0 && Type != CounterType.TransformFeedbackPrimitivesWritten, _pipeline.GetCounterDivisor(Type));
                 _events.Enqueue(_current);
 
                 _current.OnResult += resultHandler;

Ryujinx.Graphics.Vulkan/Queries/CounterQueueEvent.cs

@@ -24,6 +24,7 @@ namespace Ryujinx.Graphics.Vulkan.Queries
 
         private object _lock = new object();
         private ulong _result = ulong.MaxValue;
+        private double _divisor = 1f;
 
         public CounterQueueEvent(CounterQueue queue, CounterType type, ulong drawIndex)
         {
@@ -52,9 +53,11 @@ namespace Ryujinx.Graphics.Vulkan.Queries
             ClearCounter = true;
         }
 
-        internal void Complete(bool withResult)
+        internal void Complete(bool withResult, double divisor)
         {
             _counter.End(withResult);
+
+            _divisor = divisor;
         }
 
         internal bool TryConsume(ref ulong result, bool block, AutoResetEvent wakeSignal = null)
@@ -85,7 +88,7 @@ namespace Ryujinx.Graphics.Vulkan.Queries
                     }
                 }
 
-                result += (ulong)queryResult;
+                result += _divisor == 1 ? (ulong)queryResult : (ulong)Math.Ceiling(queryResult / _divisor);
 
                 _result = result;
 

Ryujinx.Graphics.Vulkan/Queries/Counters.cs

@@ -17,7 +17,7 @@ namespace Ryujinx.Graphics.Vulkan.Queries
 
             _counterQueues = new CounterQueue[count];
 
-            for (int index = 0; index < count; index++)
+            for (int index = 0; index < _counterQueues.Length; index++)
             {
                 CounterType type = (CounterType)index;
                 _counterQueues[index] = new CounterQueue(gd, device, pipeline, type);

Ryujinx.Graphics.Vulkan/Ryujinx.Graphics.Vulkan.csproj

@@ -29,9 +29,6 @@
     <PackageReference Include="Silk.NET.Vulkan" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.KHR" />
-    <PackageReference Include="System.IO.FileSystem.Primitives" />
-    <PackageReference Include="System.Net.NameResolution" />
-    <PackageReference Include="System.Threading.ThreadPool" />
   </ItemGroup>
 
   <ItemGroup>

Ryujinx.Graphics.Vulkan/SpecInfo.cs

@@ -29,7 +29,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             uint structSize = 0;
 
-            for (int i = 0; i < count; ++i)
+            for (int i = 0; i < Map.Length; ++i)
             {
                 var typeSize = SizeOf(description[i].Type);
                 Map[i] = new SpecializationMapEntry(description[i].Id, structSize, typeSize);
@@ -46,11 +46,10 @@ namespace Ryujinx.Graphics.Vulkan
         // For advanced mapping with overlapping or staggered fields
         public SpecDescription(SpecializationMapEntry[] map)
         {
-            int count = map.Length;
             Map = map;
 
             uint structSize = 0;
-            for (int i = 0; i < count; ++i)
+            for (int i = 0; i < map.Length; ++i)
             {
                 structSize = Math.Max(structSize, map[i].Offset + (uint)map[i].Size);
             }

Ryujinx.Graphics.Vulkan/Window.cs

@@ -60,10 +60,9 @@ namespace Ryujinx.Graphics.Vulkan
         private void RecreateSwapchain()
         {
             var oldSwapchain = _swapchain;
-            int imageCount = _swapchainImageViews.Length;
             _vsyncModeChanged = false;
 
-            for (int i = 0; i < imageCount; i++)
+            for (int i = 0; i < _swapchainImageViews.Length; i++)
             {
                 _swapchainImageViews[i].Dispose();
             }
@@ -147,7 +146,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             _swapchainImageViews = new Auto<DisposableImageView>[imageCount];
 
-            for (int i = 0; i < imageCount; i++)
+            for (int i = 0; i < _swapchainImageViews.Length; i++)
             {
                 _swapchainImageViews[i] = CreateSwapchainImageView(_swapchainImages[i], surfaceFormat.Format);
             }

Ryujinx.HLE/FileSystem/ContentManager.cs

@@ -9,6 +9,7 @@ using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
 using LibHac.Tools.Ncm;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Common.Utilities;
 using Ryujinx.HLE.Exceptions;
 using Ryujinx.HLE.HOS.Services.Ssl;
@@ -637,12 +638,12 @@ namespace Ryujinx.HLE.FileSystem
 
         private Stream GetZipStream(ZipArchiveEntry entry)
         {
-            MemoryStream dest = new MemoryStream();
+            MemoryStream dest = MemoryStreamManager.Shared.GetStream();
 
-            Stream src = entry.Open();
-
-            src.CopyTo(dest);
-            src.Dispose();
+            using (Stream src = entry.Open())
+            {
+                src.CopyTo(dest);
+            }
 
             return dest;
         }

Ryujinx.HLE/HOS/Applets/Browser/BrowserApplet.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Common;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS.Services.Am.AppletAE;
 using System;
 using System.Collections.Generic;
@@ -70,7 +71,7 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
 
         private byte[] BuildResponseOld(WebCommonReturnValue result)
         {
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter writer = new BinaryWriter(stream))
             {
                 writer.WriteStruct(result);
@@ -80,7 +81,7 @@ namespace Ryujinx.HLE.HOS.Applets.Browser
         }
         private byte[] BuildResponseNew(List<BrowserOutput> outputArguments)
         {
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter writer = new BinaryWriter(stream))
             {
                 writer.WriteStruct(new WebArgHeader

Ryujinx.HLE/HOS/Applets/Controller/ControllerApplet.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS.Services.Am.AppletAE;
 using Ryujinx.HLE.HOS.Services.Hid;
 using Ryujinx.HLE.HOS.Services.Hid.Types;
@@ -123,7 +124,7 @@ namespace Ryujinx.HLE.HOS.Applets
 
         private byte[] BuildResponse(ControllerSupportResultInfo result)
         {
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter writer = new BinaryWriter(stream))
             {
                 writer.Write(MemoryMarshal.AsBytes(MemoryMarshal.CreateReadOnlySpan(ref result, Unsafe.SizeOf<ControllerSupportResultInfo>())));
@@ -134,7 +135,7 @@ namespace Ryujinx.HLE.HOS.Applets
 
         private byte[] BuildResponse()
         {
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter writer = new BinaryWriter(stream))
             {
                 writer.Write((ulong)ResultCode.Success);

Ryujinx.HLE/HOS/Applets/PlayerSelect/PlayerSelectApplet.cs

@@ -1,4 +1,5 @@
-using Ryujinx.HLE.HOS.Services.Account.Acc;
+using Ryujinx.Common.Memory;
+using Ryujinx.HLE.HOS.Services.Account.Acc;
 using Ryujinx.HLE.HOS.Services.Am.AppletAE;
 using System;
 using System.IO;
@@ -43,7 +44,7 @@ namespace Ryujinx.HLE.HOS.Applets
         {
             UserProfile currentUser = _system.AccountManager.LastOpenedUser;
 
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter writer = new BinaryWriter(stream))
             {
                 writer.Write((ulong)PlayerSelectResult.Success);

Ryujinx.HLE/HOS/Horizon.cs

@@ -338,7 +338,7 @@ namespace Ryujinx.HLE.HOS
 
                 ProcessCreationInfo creationInfo = new ProcessCreationInfo("Service", 1, 0, 0x8000000, 1, flags, 0, 0);
 
-                int[] defaultCapabilities = new int[]
+                uint[] defaultCapabilities = new uint[]
                 {
                     0x030363F7,
                     0x1FFFFFCF,
@@ -552,4 +552,4 @@ namespace Ryujinx.HLE.HOS
             IsPaused = pause;
         }
     }
-}
+}

Ryujinx.HLE/HOS/Ipc/IpcHandleDesc.cs

@@ -1,3 +1,6 @@
+using Microsoft.IO;
+using Ryujinx.Common;
+using Ryujinx.Common.Memory;
 using System;
 using System.IO;
 
@@ -18,20 +21,27 @@ namespace Ryujinx.HLE.HOS.Ipc
 
             HasPId = (word & 1) != 0;
 
-            ToCopy = new int[(word >> 1) & 0xf];
-            ToMove = new int[(word >> 5) & 0xf];
-
             PId = HasPId ? reader.ReadUInt64() : 0;
 
-            for (int index = 0; index < ToCopy.Length; index++)
+            int toCopySize = (word >> 1) & 0xf;
+            int[] toCopy = toCopySize == 0 ? Array.Empty<int>() : new int[toCopySize];
+
+            for (int index = 0; index < toCopy.Length; index++)
             {
-                ToCopy[index] = reader.ReadInt32();
+                toCopy[index] = reader.ReadInt32();
             }
 
-            for (int index = 0; index < ToMove.Length; index++)
+            ToCopy = toCopy;
+
+            int toMoveSize = (word >> 5) & 0xf;
+            int[] toMove = toMoveSize == 0 ? Array.Empty<int>() : new int[toMoveSize];
+
+            for (int index = 0; index < toMove.Length; index++)
             {
-                ToMove[index] = reader.ReadInt32();
+                toMove[index] = reader.ReadInt32();
             }
+
+            ToMove = toMove;
         }
 
         public IpcHandleDesc(int[] copy, int[] move)
@@ -49,44 +59,35 @@ namespace Ryujinx.HLE.HOS.Ipc
 
         public static IpcHandleDesc MakeCopy(params int[] handles)
         {
-            return new IpcHandleDesc(handles, new int[0]);
+            return new IpcHandleDesc(handles, Array.Empty<int>());
         }
 
         public static IpcHandleDesc MakeMove(params int[] handles)
         {
-            return new IpcHandleDesc(new int[0], handles);
+            return new IpcHandleDesc(Array.Empty<int>(), handles);
         }
 
-        public byte[] GetBytes()
+        public RecyclableMemoryStream GetStream()
         {
-            using (MemoryStream ms = new MemoryStream())
+            RecyclableMemoryStream ms = MemoryStreamManager.Shared.GetStream();
+
+            int word = HasPId ? 1 : 0;
+
+            word |= (ToCopy.Length & 0xf) << 1;
+            word |= (ToMove.Length & 0xf) << 5;
+
+            ms.Write(word);
+
+            if (HasPId)
             {
-                BinaryWriter writer = new BinaryWriter(ms);
-
-                int word = HasPId ? 1 : 0;
-
-                word |= (ToCopy.Length & 0xf) << 1;
-                word |= (ToMove.Length & 0xf) << 5;
-
-                writer.Write(word);
-
-                if (HasPId)
-                {
-                    writer.Write(PId);
-                }
-
-                foreach (int handle in ToCopy)
-                {
-                    writer.Write(handle);
-                }
-
-                foreach (int handle in ToMove)
-                {
-                    writer.Write(handle);
-                }
-
-                return ms.ToArray();
+                ms.Write(PId);
             }
+
+            ms.Write(ToCopy);
+            ms.Write(ToMove);
+
+            ms.Position = 0;
+            return ms;
         }
     }
 }

Ryujinx.HLE/HOS/Ipc/IpcMessage.cs

@@ -1,3 +1,8 @@
+using Microsoft.IO;
+using Ryujinx.Common;
+using Ryujinx.Common.Memory;
+using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -31,9 +36,9 @@ namespace Ryujinx.HLE.HOS.Ipc
             ObjectIds = new List<int>();
         }
 
-        public IpcMessage(byte[] data, long cmdPtr) : this()
+        public IpcMessage(ReadOnlySpan<byte> data, long cmdPtr) : this()
         {
-            using (MemoryStream ms = new MemoryStream(data))
+            using (RecyclableMemoryStream ms = MemoryStreamManager.Shared.GetStream(data))
             {
                 BinaryReader reader = new BinaryReader(ms);
 
@@ -113,124 +118,119 @@ namespace Ryujinx.HLE.HOS.Ipc
 
             for (int index = 0; index < recvListCount; index++)
             {
-                RecvListBuff.Add(new IpcRecvListBuffDesc(reader));
+                RecvListBuff.Add(new IpcRecvListBuffDesc(reader.ReadUInt64()));
             }
         }
 
-        public byte[] GetBytes(long cmdPtr, ulong recvListAddr)
+        public RecyclableMemoryStream GetStream(long cmdPtr, ulong recvListAddr)
         {
-            using (MemoryStream ms = new MemoryStream())
+            RecyclableMemoryStream ms = MemoryStreamManager.Shared.GetStream();
+
+            int word0;
+            int word1;
+
+            word0  = (int)Type;
+            word0 |= (PtrBuff.Count      & 0xf) << 16;
+            word0 |= (SendBuff.Count     & 0xf) << 20;
+            word0 |= (ReceiveBuff.Count  & 0xf) << 24;
+            word0 |= (ExchangeBuff.Count & 0xf) << 28;
+
+            using RecyclableMemoryStream handleDataStream = HandleDesc?.GetStream();
+
+            int dataLength = RawData?.Length ?? 0;
+
+            dataLength = (dataLength + 3) & ~3;
+
+            int rawLength = dataLength;
+
+            int pad0 = (int)GetPadSize16(cmdPtr + 8 + (handleDataStream?.Length ?? 0) + PtrBuff.Count * 8);
+
+            // Apparently, padding after Raw Data is 16 bytes, however when there is
+            // padding before Raw Data too, we need to subtract the size of this padding.
+            // This is the weirdest padding I've seen so far...
+            int pad1 = 0x10 - pad0;
+
+            dataLength = (dataLength + pad0 + pad1) / 4;
+
+            word1 = (dataLength & 0x3ff) | (2 << 10);
+
+            if (HandleDesc != null)
             {
-                BinaryWriter writer = new BinaryWriter(ms);
-
-                int word0;
-                int word1;
-
-                word0  = (int)Type;
-                word0 |= (PtrBuff.Count      & 0xf) << 16;
-                word0 |= (SendBuff.Count     & 0xf) << 20;
-                word0 |= (ReceiveBuff.Count  & 0xf) << 24;
-                word0 |= (ExchangeBuff.Count & 0xf) << 28;
-
-                byte[] handleData = new byte[0];
-
-                if (HandleDesc != null)
-                {
-                    handleData = HandleDesc.GetBytes();
-                }
-
-                int dataLength = RawData?.Length ?? 0;
-
-                dataLength = (dataLength + 3) & ~3;
-
-                int rawLength = dataLength;
-
-                int pad0 = (int)GetPadSize16(cmdPtr + 8 + handleData.Length + PtrBuff.Count * 8);
-
-                // Apparently, padding after Raw Data is 16 bytes, however when there is
-                // padding before Raw Data too, we need to subtract the size of this padding.
-                // This is the weirdest padding I've seen so far...
-                int pad1 = 0x10 - pad0;
-
-                dataLength = (dataLength + pad0 + pad1) / 4;
-
-                word1 = (dataLength & 0x3ff) | (2 << 10);
-
-                if (HandleDesc != null)
-                {
-                    word1 |= 1 << 31;
-                }
-
-                writer.Write(word0);
-                writer.Write(word1);
-                writer.Write(handleData);
-
-                for (int index = 0; index < PtrBuff.Count; index++)
-                {
-                    writer.Write(PtrBuff[index].GetWord0());
-                    writer.Write(PtrBuff[index].GetWord1());
-                }
-
-                ms.Seek(pad0, SeekOrigin.Current);
-
-                if (RawData != null)
-                {
-                    writer.Write(RawData);
-                    ms.Seek(rawLength - RawData.Length, SeekOrigin.Current);
-                }
-
-                writer.Write(new byte[pad1]);
-                writer.Write(recvListAddr);
-
-                return ms.ToArray();
+                word1 |= 1 << 31;
             }
+
+            ms.Write(word0);
+            ms.Write(word1);
+
+            if (handleDataStream != null)
+            {
+                ms.Write(handleDataStream);
+            }
+
+            foreach (IpcPtrBuffDesc ptrBuffDesc in PtrBuff)
+            {
+                ms.Write(ptrBuffDesc.GetWord0());
+                ms.Write(ptrBuffDesc.GetWord1());
+            }
+
+            ms.WriteByte(0, pad0);
+
+            if (RawData != null)
+            {
+                ms.Write(RawData);
+                ms.WriteByte(0, rawLength - RawData.Length);
+            }
+
+            ms.WriteByte(0, pad1);
+
+            ms.Write(recvListAddr);
+
+            ms.Position = 0;
+
+            return ms;
         }
 
-        public byte[] GetBytesTipc()
+        public RecyclableMemoryStream GetStreamTipc()
         {
             Debug.Assert(PtrBuff.Count == 0);
 
-            using (MemoryStream ms = new MemoryStream())
+            RecyclableMemoryStream ms = MemoryStreamManager.Shared.GetStream();
+
+            int word0;
+            int word1;
+
+            word0 = (int)Type;
+            word0 |= (SendBuff.Count & 0xf) << 20;
+            word0 |= (ReceiveBuff.Count & 0xf) << 24;
+            word0 |= (ExchangeBuff.Count & 0xf) << 28;
+
+            using RecyclableMemoryStream handleDataStream = HandleDesc?.GetStream();
+
+            int dataLength = RawData?.Length ?? 0;
+
+            dataLength = ((dataLength + 3) & ~3) / 4;
+
+            word1 = (dataLength & 0x3ff);
+
+            if (HandleDesc != null)
             {
-                BinaryWriter writer = new BinaryWriter(ms);
-
-                int word0;
-                int word1;
-
-                word0 = (int)Type;
-                word0 |= (SendBuff.Count & 0xf) << 20;
-                word0 |= (ReceiveBuff.Count & 0xf) << 24;
-                word0 |= (ExchangeBuff.Count & 0xf) << 28;
-
-                byte[] handleData = new byte[0];
-
-                if (HandleDesc != null)
-                {
-                    handleData = HandleDesc.GetBytes();
-                }
-
-                int dataLength = RawData?.Length ?? 0;
-
-                dataLength = ((dataLength + 3) & ~3) / 4;
-
-                word1 = (dataLength & 0x3ff);
-
-                if (HandleDesc != null)
-                {
-                    word1 |= 1 << 31;
-                }
-
-                writer.Write(word0);
-                writer.Write(word1);
-                writer.Write(handleData);
-
-                if (RawData != null)
-                {
-                    writer.Write(RawData);
-                }
-
-                return ms.ToArray();
+                word1 |= 1 << 31;
             }
+
+            ms.Write(word0);
+            ms.Write(word1);
+
+            if (handleDataStream != null)
+            {
+                ms.Write(handleDataStream);
+            }
+
+            if (RawData != null)
+            {
+                ms.Write(RawData);
+            }
+
+            return ms;
         }
 
         private long GetPadSize16(long position)

Ryujinx.HLE/HOS/Ipc/IpcRecvListBuffDesc.cs

@@ -13,13 +13,11 @@ namespace Ryujinx.HLE.HOS.Ipc
             Size = size;
         }
 
-        public IpcRecvListBuffDesc(BinaryReader reader)
+        public IpcRecvListBuffDesc(ulong packedValue)
         {
-            ulong value = reader.ReadUInt64();
+            Position = packedValue & 0xffffffffffff;
 
-            Position = value & 0xffffffffffff;
-
-            Size = (ushort)(value >> 48);
+            Size = (ushort)(packedValue >> 48);
         }
     }
 }

Ryujinx.HLE/HOS/Kernel/Common/KTimeManager.cs

@@ -1,7 +1,6 @@
 using Ryujinx.Common;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 
 namespace Ryujinx.HLE.HOS.Kernel.Common
@@ -17,7 +16,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Common
 
             public WaitingObject(IKFutureSchedulerObject schedulerObj, long timePoint)
             {
-                Object    = schedulerObj;
+                Object = schedulerObj;
                 TimePoint = timePoint;
             }
         }
@@ -28,6 +27,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Common
         private bool _keepRunning;
         private long _enforceWakeupFromSpinWait;
 
+        private const long NanosecondsPerSecond = 1000000000L;
+        private const long NanosecondsPerMillisecond = 1000000L;
+
         public KTimeManager(KernelContext context)
         {
             _context = context;
@@ -56,7 +58,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Common
             {
                 _waitingObjects.Add(new WaitingObject(schedulerObj, timePoint));
 
-                if (timeout < 1000000)
+                if (timeout < NanosecondsPerMillisecond)
                 {
                     Interlocked.Exchange(ref _enforceWakeupFromSpinWait, 1);
                 }
@@ -86,7 +88,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Common
                     {
                         Interlocked.Exchange(ref _enforceWakeupFromSpinWait, 0);
 
-                        next = _waitingObjects.OrderBy(x => x.TimePoint).FirstOrDefault();
+                        next = GetNextWaitingObject();
                     }
 
                     if (next != null)
@@ -140,9 +142,29 @@ namespace Ryujinx.HLE.HOS.Kernel.Common
             }
         }
 
+        private WaitingObject GetNextWaitingObject()
+        {
+            WaitingObject selected = null;
+
+            long lowestTimePoint = long.MaxValue;
+
+            for (int index = _waitingObjects.Count - 1; index >= 0; index--)
+            {
+                WaitingObject current = _waitingObjects[index];
+
+                if (current.TimePoint <= lowestTimePoint)
+                {
+                    selected = current;
+                    lowestTimePoint = current.TimePoint;
+                }
+            }
+
+            return selected;
+        }
+
         public static long ConvertNanosecondsToMilliseconds(long time)
         {
-            time /= 1000000;
+            time /= NanosecondsPerMillisecond;
 
             if ((ulong)time > int.MaxValue)
             {
@@ -154,18 +176,18 @@ namespace Ryujinx.HLE.HOS.Kernel.Common
 
         public static long ConvertMillisecondsToNanoseconds(long time)
         {
-            return time * 1000000;
+            return time * NanosecondsPerMillisecond;
         }
 
         public static long ConvertNanosecondsToHostTicks(long ns)
         {
-            long nsDiv = ns / 1000000000;
-            long nsMod = ns % 1000000000;
-            long tickDiv = PerformanceCounter.TicksPerSecond / 1000000000;
-            long tickMod = PerformanceCounter.TicksPerSecond % 1000000000;
+            long nsDiv = ns / NanosecondsPerSecond;
+            long nsMod = ns % NanosecondsPerSecond;
+            long tickDiv = PerformanceCounter.TicksPerSecond / NanosecondsPerSecond;
+            long tickMod = PerformanceCounter.TicksPerSecond % NanosecondsPerSecond;
 
-            long baseTicks = (nsMod * tickMod + PerformanceCounter.TicksPerSecond - 1) / 1000000000;
-            return (nsDiv * tickDiv) * 1000000000 + nsDiv * tickMod + nsMod * tickDiv + baseTicks;
+            long baseTicks = (nsMod * tickMod + PerformanceCounter.TicksPerSecond - 1) / NanosecondsPerSecond;
+            return (nsDiv * tickDiv) * NanosecondsPerSecond + nsDiv * tickMod + nsMod * tickDiv + baseTicks;
         }
 
         public static long ConvertGuestTicksToNanoseconds(long ticks)

Ryujinx.HLE/HOS/Kernel/KernelConstants.cs

@@ -7,6 +7,8 @@ namespace Ryujinx.HLE.HOS.Kernel
         public const int InitialKipId = 1;
         public const int InitialProcessId = 0x51;
 
+        public const int SupervisorCallCount = 0xC0;
+
         public const int MemoryBlockAllocatorSize = 0x2710;
 
         public const ulong UserSlabHeapBase = DramMemoryMap.SlabHeapBase;
@@ -15,4 +17,4 @@ namespace Ryujinx.HLE.HOS.Kernel
 
         public const ulong CounterFrequency = 19200000;
     }
-}
+}

Ryujinx.HLE/HOS/Kernel/KernelStatic.cs

@@ -18,7 +18,7 @@ namespace Ryujinx.HLE.HOS.Kernel
         public static Result StartInitialProcess(
             KernelContext context,
             ProcessCreationInfo creationInfo,
-            ReadOnlySpan<int> capabilities,
+            ReadOnlySpan<uint> capabilities,
             int mainThreadPriority,
             ThreadStart customThreadStart)
         {

Ryujinx.HLE/HOS/Kernel/Process/CapabilityExtensions.cs

@@ -0,0 +1,22 @@
+using System.Numerics;
+
+namespace Ryujinx.HLE.HOS.Kernel.Process
+{
+    static class CapabilityExtensions
+    {
+        public static CapabilityType GetCapabilityType(this uint cap)
+        {
+            return (CapabilityType)(((cap + 1) & ~cap) - 1);
+        }
+
+        public static uint GetFlag(this CapabilityType type)
+        {
+            return (uint)type + 1;
+        }
+
+        public static uint GetId(this CapabilityType type)
+        {
+            return (uint)BitOperations.TrailingZeroCount(type.GetFlag());
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/Process/CapabilityType.cs

@@ -0,0 +1,19 @@
+namespace Ryujinx.HLE.HOS.Kernel.Process
+{
+    enum CapabilityType : uint
+    {
+        CorePriority  = (1u <<  3) - 1,
+        SyscallMask   = (1u <<  4) - 1,
+        MapRange      = (1u <<  6) - 1,
+        MapIoPage     = (1u <<  7) - 1,
+        MapRegion     = (1u << 10) - 1,
+        InterruptPair = (1u << 11) - 1,
+        ProgramType   = (1u << 13) - 1,
+        KernelVersion = (1u << 14) - 1,
+        HandleTable   = (1u << 15) - 1,
+        DebugFlags    = (1u << 16) - 1,
+
+        Invalid       = 0u,
+        Padding       = ~0u
+    }
+}

Ryujinx.HLE/HOS/Kernel/Process/KHandleTable.cs

@@ -19,7 +19,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
         private int _activeSlotsCount;
 
-        private int _size;
+        private uint _size;
 
         private ushort _idCounter;
 
@@ -28,9 +28,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
             _context = context;
         }
 
-        public Result Initialize(int size)
+        public Result Initialize(uint size)
         {
-            if ((uint)size > 1024)
+            if (size > 1024)
             {
                 return KernelResult.OutOfMemory;
             }

Ryujinx.HLE/HOS/Kernel/Process/KProcess.cs

@@ -16,11 +16,11 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 {
     class KProcess : KSynchronizationObject
     {
-        public const int KernelVersionMajor = 10;
-        public const int KernelVersionMinor = 4;
-        public const int KernelVersionRevision = 0;
+        public const uint KernelVersionMajor = 10;
+        public const uint KernelVersionMinor = 4;
+        public const uint KernelVersionRevision = 0;
 
-        public const int KernelVersionPacked =
+        public const uint KernelVersionPacked =
             (KernelVersionMajor << 19) |
             (KernelVersionMinor << 15) |
             (KernelVersionRevision << 0);
@@ -119,7 +119,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
         public Result InitializeKip(
             ProcessCreationInfo creationInfo,
-            ReadOnlySpan<int> capabilities,
+            ReadOnlySpan<uint> capabilities,
             KPageList pageList,
             KResourceLimit resourceLimit,
             MemoryRegion memRegion,
@@ -190,7 +190,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
         public Result Initialize(
             ProcessCreationInfo creationInfo,
-            ReadOnlySpan<int> capabilities,
+            ReadOnlySpan<uint> capabilities,
             KResourceLimit resourceLimit,
             MemoryRegion memRegion,
             IProcessContextFactory contextFactory,

Ryujinx.HLE/HOS/Kernel/Process/KProcessCapabilities.cs

@@ -1,4 +1,3 @@
-using Ryujinx.HLE.HOS.Kernel.Common;
 using Ryujinx.HLE.HOS.Kernel.Memory;
 using Ryujinx.HLE.HOS.Kernel.Threading;
 using Ryujinx.Horizon.Common;
@@ -9,48 +8,49 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 {
     class KProcessCapabilities
     {
-        public byte[] SvcAccessMask { get; private set; }
-        public byte[] IrqAccessMask { get; private set; }
+        public byte[] SvcAccessMask { get; }
+        public byte[] IrqAccessMask { get; }
 
         public ulong AllowedCpuCoresMask    { get; private set; }
         public ulong AllowedThreadPriosMask { get; private set; }
 
-        public int DebuggingFlags       { get; private set; }
-        public int HandleTableSize      { get; private set; }
-        public int KernelReleaseVersion { get; private set; }
-        public int ApplicationType      { get; private set; }
+        public uint DebuggingFlags       { get; private set; }
+        public uint HandleTableSize      { get; private set; }
+        public uint KernelReleaseVersion { get; private set; }
+        public uint ApplicationType      { get; private set; }
 
         public KProcessCapabilities()
         {
-            SvcAccessMask = new byte[0x10];
+            // length / number of bits of the underlying type
+            SvcAccessMask = new byte[KernelConstants.SupervisorCallCount / 8];
             IrqAccessMask = new byte[0x80];
         }
 
-        public Result InitializeForKernel(ReadOnlySpan<int> capabilities, KPageTableBase memoryManager)
+        public Result InitializeForKernel(ReadOnlySpan<uint> capabilities, KPageTableBase memoryManager)
         {
             AllowedCpuCoresMask    = 0xf;
             AllowedThreadPriosMask = ulong.MaxValue;
-            DebuggingFlags        &= ~3;
+            DebuggingFlags        &= ~3u;
             KernelReleaseVersion   = KProcess.KernelVersionPacked;
 
             return Parse(capabilities, memoryManager);
         }
 
-        public Result InitializeForUser(ReadOnlySpan<int> capabilities, KPageTableBase memoryManager)
+        public Result InitializeForUser(ReadOnlySpan<uint> capabilities, KPageTableBase memoryManager)
         {
             return Parse(capabilities, memoryManager);
         }
 
-        private Result Parse(ReadOnlySpan<int> capabilities, KPageTableBase memoryManager)
+        private Result Parse(ReadOnlySpan<uint> capabilities, KPageTableBase memoryManager)
         {
             int mask0 = 0;
             int mask1 = 0;
 
             for (int index = 0; index < capabilities.Length; index++)
             {
-                int cap = capabilities[index];
+                uint cap = capabilities[index];
 
-                if (((cap + 1) & ~cap) != 0x40)
+                if (cap.GetCapabilityType() != CapabilityType.MapRange)
                 {
                     Result result = ParseCapability(cap, ref mask0, ref mask1, memoryManager);
 
@@ -66,7 +66,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                         return KernelResult.InvalidCombination;
                     }
 
-                    int prevCap = cap;
+                    uint prevCap = cap;
 
                     cap = capabilities[++index];
 
@@ -85,8 +85,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                         return KernelResult.InvalidSize;
                     }
 
-                    long address = ((long)(uint)prevCap << 5) & 0xffffff000;
-                    long size    = ((long)(uint)cap     << 5) & 0xfffff000;
+                    long address = ((long)prevCap << 5) & 0xffffff000;
+                    long size    = ((long)cap     << 5) & 0xfffff000;
 
                     if (((ulong)(address + size - 1) >> 36) != 0)
                     {
@@ -118,20 +118,20 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
             return Result.Success;
         }
 
-        private Result ParseCapability(int cap, ref int mask0, ref int mask1, KPageTableBase memoryManager)
+        private Result ParseCapability(uint cap, ref int mask0, ref int mask1, KPageTableBase memoryManager)
         {
-            int code = (cap + 1) & ~cap;
+            CapabilityType code = cap.GetCapabilityType();
 
-            if (code == 1)
+            if (code == CapabilityType.Invalid)
             {
                 return KernelResult.InvalidCapability;
             }
-            else if (code == 0)
+            else if (code == CapabilityType.Padding)
             {
                 return Result.Success;
             }
 
-            int codeMask = 1 << (32 - BitOperations.LeadingZeroCount((uint)code + 1));
+            int codeMask = 1 << (32 - BitOperations.LeadingZeroCount(code.GetFlag() + 1));
 
             // Check if the property was already set.
             if (((mask0 & codeMask) & 0x1e008) != 0)
@@ -143,23 +143,23 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
             switch (code)
             {
-                case 8:
+                case CapabilityType.CorePriority:
                 {
                     if (AllowedCpuCoresMask != 0 || AllowedThreadPriosMask != 0)
                     {
                         return KernelResult.InvalidCapability;
                     }
 
-                    int lowestCpuCore  = (cap >> 16) & 0xff;
-                    int highestCpuCore = (cap >> 24) & 0xff;
+                    uint lowestCpuCore  = (cap >> 16) & 0xff;
+                    uint highestCpuCore = (cap >> 24) & 0xff;
 
                     if (lowestCpuCore > highestCpuCore)
                     {
                         return KernelResult.InvalidCombination;
                     }
 
-                    int highestThreadPrio = (cap >>  4) & 0x3f;
-                    int lowestThreadPrio  = (cap >> 10) & 0x3f;
+                    uint highestThreadPrio = (cap >>  4) & 0x3f;
+                    uint lowestThreadPrio  = (cap >> 10) & 0x3f;
 
                     if (lowestThreadPrio > highestThreadPrio)
                     {
@@ -177,9 +177,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     break;
                 }
 
-                case 0x10:
+                case CapabilityType.SyscallMask:
                 {
-                    int slot = (cap >> 29) & 7;
+                    int slot = ((int)cap >> 29) & 7;
 
                     int svcSlotMask = 1 << slot;
 
@@ -190,7 +190,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
                     mask1 |= svcSlotMask;
 
-                    int svcMask = (cap >> 5) & 0xffffff;
+                    uint svcMask = (cap >> 5) & 0xffffff;
 
                     int baseSvc = slot * 24;
 
@@ -203,7 +203,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
                         int svcId = baseSvc + index;
 
-                        if (svcId > 0x7f)
+                        if (svcId >= KernelConstants.SupervisorCallCount)
                         {
                             return KernelResult.MaximumExceeded;
                         }
@@ -214,20 +214,27 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     break;
                 }
 
-                case 0x80:
+                case CapabilityType.MapIoPage:
                 {
-                    long address = ((long)(uint)cap << 4) & 0xffffff000;
+                    long address = ((long)cap << 4) & 0xffffff000;
 
                     memoryManager.MapIoMemory(address, KPageTableBase.PageSize, KMemoryPermission.ReadAndWrite);
 
                     break;
                 }
 
-                case 0x800:
+                case CapabilityType.MapRegion:
+                {
+                    // TODO: Implement capabilities for MapRegion
+
+                    break;
+                }
+
+                case CapabilityType.InterruptPair:
                 {
                     // TODO: GIC distributor check.
-                    int irq0 = (cap >> 12) & 0x3ff;
-                    int irq1 = (cap >> 22) & 0x3ff;
+                    int irq0 = ((int)cap >> 12) & 0x3ff;
+                    int irq1 = ((int)cap >> 22) & 0x3ff;
 
                     if (irq0 != 0x3ff)
                     {
@@ -242,11 +249,11 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     break;
                 }
 
-                case 0x2000:
+                case CapabilityType.ProgramType:
                 {
-                    int applicationType = cap >> 14;
+                    uint applicationType = (cap >> 14);
 
-                    if ((uint)applicationType > 7)
+                    if (applicationType > 7)
                     {
                         return KernelResult.ReservedValue;
                     }
@@ -256,7 +263,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     break;
                 }
 
-                case 0x4000:
+                case CapabilityType.KernelVersion:
                 {
                     // Note: This check is bugged on kernel too, we are just replicating the bug here.
                     if ((KernelReleaseVersion >> 17) != 0 || cap < 0x80000)
@@ -269,11 +276,11 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     break;
                 }
 
-                case 0x8000:
+                case CapabilityType.HandleTable:
                 {
-                    int handleTableSize = cap >> 26;
+                    uint handleTableSize = cap >> 26;
 
-                    if ((uint)handleTableSize > 0x3ff)
+                    if (handleTableSize > 0x3ff)
                     {
                         return KernelResult.ReservedValue;
                     }
@@ -283,16 +290,16 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     break;
                 }
 
-                case 0x10000:
+                case CapabilityType.DebugFlags:
                 {
-                    int debuggingFlags = cap >> 19;
+                    uint debuggingFlags = cap >> 19;
 
-                    if ((uint)debuggingFlags > 3)
+                    if (debuggingFlags > 3)
                     {
                         return KernelResult.ReservedValue;
                     }
 
-                    DebuggingFlags &= ~3;
+                    DebuggingFlags &= ~3u;
                     DebuggingFlags |= debuggingFlags;
 
                     break;
@@ -304,18 +311,18 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
             return Result.Success;
         }
 
-        private static ulong GetMaskFromMinMax(int min, int max)
+        private static ulong GetMaskFromMinMax(uint min, uint max)
         {
-            int range = max - min + 1;
+            uint range = max - min + 1;
 
             if (range == 64)
             {
                 return ulong.MaxValue;
             }
 
-            ulong mask = (1UL << range) - 1;
+            ulong mask = (1UL << (int)range) - 1;
 
-            return mask << min;
+            return mask << (int)min;
         }
     }
 }

Ryujinx.HLE/HOS/Kernel/Process/ProcessCreationFlags.cs

@@ -1,5 +1,8 @@
-namespace Ryujinx.HLE.HOS.Kernel.Process
+using System;
+
+namespace Ryujinx.HLE.HOS.Kernel.Process
 {
+    [Flags]
     enum ProcessCreationFlags
     {
         Is64Bit = 1 << 0,

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

@@ -54,7 +54,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
         public Result CreateProcess(
             out int handle,
             ProcessCreationInfo info,
-            ReadOnlySpan<int> capabilities,
+            ReadOnlySpan<uint> capabilities,
             IProcessContextFactory contextFactory,
             ThreadStart customThreadStart = null)
         {
@@ -553,7 +553,7 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
 
             KProcess currentProcess = KernelStatic.GetCurrentProcess();
 
-            KSynchronizationObject[] syncObjs = new KSynchronizationObject[handles.Length];
+            KSynchronizationObject[] syncObjs = handles.Length == 0 ? Array.Empty<KSynchronizationObject>() : new KSynchronizationObject[handles.Length];
 
             for (int index = 0; index < handles.Length; index++)
             {
@@ -3002,4 +3002,4 @@ namespace Ryujinx.HLE.HOS.Kernel.SupervisorCall
             return (address & 3) != 0;
         }
     }
-}
+}

Ryujinx.HLE/HOS/Kernel/Threading/KPriorityQueue.cs

@@ -5,11 +5,11 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 {
     class KPriorityQueue
     {
-        private LinkedList<KThread>[][] _scheduledThreadsPerPrioPerCore;
-        private LinkedList<KThread>[][] _suggestedThreadsPerPrioPerCore;
+        private readonly LinkedList<KThread>[][] _scheduledThreadsPerPrioPerCore;
+        private readonly LinkedList<KThread>[][] _suggestedThreadsPerPrioPerCore;
 
-        private long[] _scheduledPrioritiesPerCore;
-        private long[] _suggestedPrioritiesPerCore;
+        private readonly long[] _scheduledPrioritiesPerCore;
+        private readonly long[] _suggestedPrioritiesPerCore;
 
         public KPriorityQueue()
         {
@@ -32,43 +32,134 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
             _suggestedPrioritiesPerCore = new long[KScheduler.CpuCoresCount];
         }
 
-        public IEnumerable<KThread> SuggestedThreads(int core)
+        public readonly ref struct KThreadEnumerable
         {
-            return Iterate(_suggestedThreadsPerPrioPerCore, _suggestedPrioritiesPerCore, core);
-        }
+            readonly LinkedList<KThread>[][] _listPerPrioPerCore;
+            readonly long[] _prios;
+            readonly int _core;
 
-        public IEnumerable<KThread> ScheduledThreads(int core)
-        {
-            return Iterate(_scheduledThreadsPerPrioPerCore, _scheduledPrioritiesPerCore, core);
-        }
-
-        private IEnumerable<KThread> Iterate(LinkedList<KThread>[][] listPerPrioPerCore, long[] prios, int core)
-        {
-            long prioMask = prios[core];
-
-            int prio = BitOperations.TrailingZeroCount(prioMask);
-
-            prioMask &= ~(1L << prio);
-
-            while (prio < KScheduler.PrioritiesCount)
+            public KThreadEnumerable(LinkedList<KThread>[][] listPerPrioPerCore, long[] prios, int core)
             {
-                LinkedList<KThread> list = listPerPrioPerCore[prio][core];
+                _listPerPrioPerCore = listPerPrioPerCore;
+                _prios = prios;
+                _core = core;
+            }
 
-                LinkedListNode<KThread> node = list.First;
+            public Enumerator GetEnumerator()
+            {
+                return new Enumerator(_listPerPrioPerCore, _prios, _core);
+            }
 
-                while (node != null)
+            public ref struct Enumerator
+            {
+                private readonly LinkedList<KThread>[][] _listPerPrioPerCore;
+                private readonly int _core;
+                private long _prioMask;
+                private int _prio;
+                private LinkedList<KThread> _list;
+                private LinkedListNode<KThread> _node;
+
+                public Enumerator(LinkedList<KThread>[][] listPerPrioPerCore, long[] prios, int core)
                 {
-                    yield return node.Value;
-
-                    node = node.Next;
+                    _listPerPrioPerCore = listPerPrioPerCore;
+                    _core = core;
+                    _prioMask = prios[core];
+                    _prio = BitOperations.TrailingZeroCount(_prioMask);
+                    _prioMask &= ~(1L << _prio);
                 }
 
-                prio = BitOperations.TrailingZeroCount(prioMask);
+                public KThread Current => _node?.Value;
 
-                prioMask &= ~(1L << prio);
+                public bool MoveNext()
+                {
+                    _node = _node?.Next;
+
+                    if (_node == null)
+                    {
+                        if (!MoveNextListAndFirstNode())
+                        {
+                            return false;
+                        }
+                    }
+
+                    return _node != null;
+                }
+
+                private bool MoveNextListAndFirstNode()
+                {
+                    if (_prio < KScheduler.PrioritiesCount)
+                    {
+                        _list = _listPerPrioPerCore[_prio][_core];
+
+                        _node = _list.First;
+
+                        _prio = BitOperations.TrailingZeroCount(_prioMask);
+
+                        _prioMask &= ~(1L << _prio);
+
+                        return true;
+                    }
+                    else
+                    {
+                        _list = null;
+                        _node = null;
+                        return false;
+                    }
+                }
             }
         }
 
+        public KThreadEnumerable ScheduledThreads(int core)
+        {
+            return new KThreadEnumerable(_scheduledThreadsPerPrioPerCore, _scheduledPrioritiesPerCore, core);
+        }
+
+        public KThreadEnumerable SuggestedThreads(int core)
+        {
+            return new KThreadEnumerable(_suggestedThreadsPerPrioPerCore, _suggestedPrioritiesPerCore, core);
+        }
+
+        public KThread ScheduledThreadsFirstOrDefault(int core)
+        {
+            return ScheduledThreadsElementAtOrDefault(core, 0);
+        }
+
+        public KThread ScheduledThreadsElementAtOrDefault(int core, int index)
+        {
+            int currentIndex = 0;
+            foreach (var scheduledThread in ScheduledThreads(core))
+            {
+                if (currentIndex == index)
+                {
+                    return scheduledThread;
+                }
+                else
+                {
+                    currentIndex++;
+                }
+            }
+
+            return null;
+        }
+
+        public KThread ScheduledThreadsWithDynamicPriorityFirstOrDefault(int core, int dynamicPriority)
+        {
+            foreach (var scheduledThread in ScheduledThreads(core))
+            {
+                if (scheduledThread.DynamicPriority == dynamicPriority)
+                {
+                    return scheduledThread;
+                }
+            }
+
+            return null;
+        }
+
+        public bool HasScheduledThreads(int core)
+        {
+            return ScheduledThreadsFirstOrDefault(core) != null;
+        }
+
         public void TransferToCore(int prio, int dstCore, KThread thread)
         {
             int srcCore = thread.ActiveCore;

Ryujinx.HLE/HOS/Kernel/Threading/KScheduler.cs

@@ -1,8 +1,6 @@
 using Ryujinx.Common;
 using Ryujinx.HLE.HOS.Kernel.Process;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Numerics;
 using System.Threading;
 
@@ -17,6 +15,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
         private static readonly int[] PreemptionPriorities = new int[] { 59, 59, 59, 63 };
 
+        private static readonly int[] _srcCoresHighestPrioThreads = new int[CpuCoresCount];
+
         private readonly KernelContext _context;
         private readonly int _coreId;
 
@@ -86,7 +86,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
             for (int core = 0; core < CpuCoresCount; core++)
             {
-                KThread thread = context.PriorityQueue.ScheduledThreads(core).FirstOrDefault();
+                KThread thread = context.PriorityQueue.ScheduledThreadsFirstOrDefault(core);
 
                 if (thread != null &&
                     thread.Owner != null &&
@@ -115,12 +115,12 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
             {
                 // If the core is not idle (there's already a thread running on it),
                 // then we don't need to attempt load balancing.
-                if (context.PriorityQueue.ScheduledThreads(core).Any())
+                if (context.PriorityQueue.HasScheduledThreads(core))
                 {
                     continue;
                 }
 
-                int[] srcCoresHighestPrioThreads = new int[CpuCoresCount];
+                Array.Fill(_srcCoresHighestPrioThreads, 0);
 
                 int srcCoresHighestPrioThreadsCount = 0;
 
@@ -136,7 +136,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                         break;
                     }
 
-                    srcCoresHighestPrioThreads[srcCoresHighestPrioThreadsCount++] = suggested.ActiveCore;
+                    _srcCoresHighestPrioThreads[srcCoresHighestPrioThreadsCount++] = suggested.ActiveCore;
                 }
 
                 // Not yet selected candidate found.
@@ -158,9 +158,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                 // (the first one that doesn't make the source core idle if moved).
                 for (int index = 0; index < srcCoresHighestPrioThreadsCount; index++)
                 {
-                    int srcCore = srcCoresHighestPrioThreads[index];
+                    int srcCore = _srcCoresHighestPrioThreads[index];
 
-                    KThread src = context.PriorityQueue.ScheduledThreads(srcCore).ElementAtOrDefault(1);
+                    KThread src = context.PriorityQueue.ScheduledThreadsElementAtOrDefault(srcCore, 1);
 
                     if (src != null)
                     {
@@ -422,9 +422,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
         private static void RotateScheduledQueue(KernelContext context, int core, int prio)
         {
-            IEnumerable<KThread> scheduledThreads = context.PriorityQueue.ScheduledThreads(core);
-
-            KThread selectedThread = scheduledThreads.FirstOrDefault(x => x.DynamicPriority == prio);
+            KThread selectedThread = context.PriorityQueue.ScheduledThreadsWithDynamicPriorityFirstOrDefault(core, prio);
             KThread nextThread = null;
 
             // Yield priority queue.
@@ -433,14 +431,14 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                 nextThread = context.PriorityQueue.Reschedule(prio, core, selectedThread);
             }
 
-            IEnumerable<KThread> SuitableCandidates()
+            static KThread FirstSuitableCandidateOrDefault(KernelContext context, int core, KThread selectedThread, KThread nextThread, Predicate< KThread> predicate)
             {
                 foreach (KThread suggested in context.PriorityQueue.SuggestedThreads(core))
                 {
                     int suggestedCore = suggested.ActiveCore;
                     if (suggestedCore >= 0)
                     {
-                        KThread selectedSuggestedCore = context.PriorityQueue.ScheduledThreads(suggestedCore).FirstOrDefault();
+                        KThread selectedSuggestedCore = context.PriorityQueue.ScheduledThreadsFirstOrDefault(suggestedCore);
 
                         if (selectedSuggestedCore == suggested || (selectedSuggestedCore != null && selectedSuggestedCore.DynamicPriority < 2))
                         {
@@ -453,14 +451,19 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                         nextThread == null ||
                         nextThread.LastScheduledTime >= suggested.LastScheduledTime)
                     {
-                        yield return suggested;
+                        if (predicate(suggested))
+                        {
+                            return suggested;
+                        }
                     }
                 }
+
+                return null;
             }
 
             // Select candidate threads that could run on this core.
             // Only take into account threads that are not yet selected.
-            KThread dst = SuitableCandidates().FirstOrDefault(x => x.DynamicPriority == prio);
+            KThread dst = FirstSuitableCandidateOrDefault(context, core, selectedThread, nextThread, x => x.DynamicPriority == prio);
 
             if (dst != null)
             {
@@ -469,11 +472,11 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
             // If the priority of the currently selected thread is lower or same as the preemption priority,
             // then try to migrate a thread with lower priority.
-            KThread bestCandidate = context.PriorityQueue.ScheduledThreads(core).FirstOrDefault();
+            KThread bestCandidate = context.PriorityQueue.ScheduledThreadsFirstOrDefault(core);
 
             if (bestCandidate != null && bestCandidate.DynamicPriority >= prio)
             {
-                dst = SuitableCandidates().FirstOrDefault(x => x.DynamicPriority < bestCandidate.DynamicPriority);
+                dst = FirstSuitableCandidateOrDefault(context, core, selectedThread, nextThread, x => x.DynamicPriority < bestCandidate.DynamicPriority);
 
                 if (dst != null)
                 {
@@ -534,7 +537,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
             // Move current thread to the end of the queue.
             KThread nextThread = context.PriorityQueue.Reschedule(prio, core, currentThread);
 
-            IEnumerable<KThread> SuitableCandidates()
+            static KThread FirstSuitableCandidateOrDefault(KernelContext context, int core, KThread nextThread, int lessThanOrEqualPriority)
             {
                 foreach (KThread suggested in context.PriorityQueue.SuggestedThreads(core))
                 {
@@ -554,12 +557,17 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                     if (suggested.LastScheduledTime <= nextThread.LastScheduledTime ||
                         suggested.DynamicPriority < nextThread.DynamicPriority)
                     {
-                        yield return suggested;
+                        if (suggested.DynamicPriority <= lessThanOrEqualPriority)
+                        {
+                            return suggested;
+                        }
                     }
                 }
+
+                return null;
             }
 
-            KThread dst = SuitableCandidates().FirstOrDefault(x => x.DynamicPriority <= prio);
+            KThread dst = FirstSuitableCandidateOrDefault(context, core, nextThread, prio);
 
             if (dst != null)
             {
@@ -596,7 +604,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
             context.PriorityQueue.TransferToCore(currentThread.DynamicPriority, -1, currentThread);
 
-            if (!context.PriorityQueue.ScheduledThreads(core).Any())
+            if (!context.PriorityQueue.HasScheduledThreads(core))
             {
                 KThread selectedThread = null;
 
@@ -609,7 +617,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                         continue;
                     }
 
-                    KThread firstCandidate = context.PriorityQueue.ScheduledThreads(suggestedCore).FirstOrDefault();
+                    KThread firstCandidate = context.PriorityQueue.ScheduledThreadsFirstOrDefault(suggestedCore);
 
                     if (firstCandidate == suggested)
                     {

Ryujinx.HLE/HOS/Kernel/Threading/KSynchronization.cs

@@ -59,7 +59,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
             }
             else
             {
-                LinkedListNode<KThread>[] syncNodes = new LinkedListNode<KThread>[syncObjs.Length];
+                LinkedListNode<KThread>[] syncNodes = syncObjs.Length == 0 ? Array.Empty<LinkedListNode<KThread>>() : new LinkedListNode<KThread>[syncObjs.Length];
 
                 for (int index = 0; index < syncObjs.Length; index++)
                 {

Ryujinx.HLE/HOS/ProgramLoader.cs

@@ -80,7 +80,7 @@ namespace Ryujinx.HLE.HOS
 
             ulong codeBaseAddress = kip.Is64BitAddressSpace ? 0x8000000UL : 0x200000UL;
 
-            ulong codeAddress = codeBaseAddress + (ulong)kip.TextOffset;
+            ulong codeAddress = codeBaseAddress + kip.TextOffset;
 
             ProcessCreationFlags flags = 0;
 
@@ -231,13 +231,13 @@ namespace Ryujinx.HLE.HOS
 
                 nsoSize = BitUtils.AlignUp<uint>(nsoSize, KPageTableBase.PageSize);
 
-                nsoBase[index] = codeStart + (ulong)codeSize;
+                nsoBase[index] = codeStart + codeSize;
 
                 codeSize += nsoSize;
 
                 if (arguments != null && argsSize == 0)
                 {
-                    argsStart = (ulong)codeSize;
+                    argsStart = codeSize;
 
                     argsSize = (uint)BitUtils.AlignDown(arguments.Length * 2 + ArgsTotalSize - 1, KPageTableBase.PageSize);
 
@@ -318,7 +318,7 @@ namespace Ryujinx.HLE.HOS
 
             result = process.Initialize(
                 creationInfo,
-                MemoryMarshal.Cast<byte, int>(npdm.KernelCapabilityData).ToArray(),
+                MemoryMarshal.Cast<byte, uint>(npdm.KernelCapabilityData),
                 resourceLimit,
                 memoryRegion,
                 processContextFactory);

Ryujinx.HLE/HOS/Services/Am/AppletAE/Storage/StorageHelper.cs

@@ -1,4 +1,5 @@
-using Ryujinx.HLE.HOS.Services.Account.Acc;
+using Ryujinx.Common.Memory;
+using Ryujinx.HLE.HOS.Services.Account.Acc;
 using System.IO;
 
 namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.Storage
@@ -10,7 +11,7 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.Storage
         public static byte[] MakeLaunchParams(UserProfile userProfile)
         {
             // Size needs to be at least 0x88 bytes otherwise application errors.
-            using (MemoryStream ms = new MemoryStream())
+            using (MemoryStream ms = MemoryStreamManager.Shared.GetStream())
             {
                 BinaryWriter writer = new BinaryWriter(ms);
 

Ryujinx.HLE/HOS/Services/Sdb/Pl/SharedFontManager.cs

@@ -5,6 +5,7 @@ using LibHac.FsSystem;
 using LibHac.Ncm;
 using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common.Memory;
 using Ryujinx.HLE.Exceptions;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS.Kernel.Memory;
@@ -160,7 +161,7 @@ namespace Ryujinx.HLE.HOS.Services.Sdb.Pl
             static uint KXor(uint data) => data ^ FontKey;
 
             using (BinaryReader reader    = new BinaryReader(bfttfStream))
-            using (MemoryStream ttfStream = new MemoryStream())
+            using (MemoryStream ttfStream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter output    = new BinaryWriter(ttfStream))
             {
                 if (KXor(reader.ReadUInt32()) != BFTTFMagic)

Ryujinx.HLE/HOS/Services/ServerBase.cs

@@ -1,3 +1,5 @@
+using Ryujinx.Common;
+using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS.Ipc;
 using Ryujinx.HLE.HOS.Kernel;
 using Ryujinx.HLE.HOS.Kernel.Ipc;
@@ -5,6 +7,7 @@ using Ryujinx.HLE.HOS.Kernel.Process;
 using Ryujinx.HLE.HOS.Kernel.Threading;
 using Ryujinx.Horizon.Common;
 using System;
+using System.Buffers;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
@@ -19,7 +22,7 @@ namespace Ryujinx.HLE.HOS.Services
         // not large enough.
         private const int PointerBufferSize = 0x8000;
 
-        private readonly static int[] DefaultCapabilities = new int[]
+        private readonly static uint[] DefaultCapabilities = new uint[]
         {
             0x030363F7,
             0x1FFFFFCF,
@@ -29,6 +32,8 @@ namespace Ryujinx.HLE.HOS.Services
             0x01007FFF
         };
 
+        private readonly object _handleLock = new();
+
         private readonly KernelContext _context;
         private KProcess _selfProcess;
 
@@ -37,14 +42,27 @@ namespace Ryujinx.HLE.HOS.Services
         private readonly Dictionary<int, IpcService> _sessions = new Dictionary<int, IpcService>();
         private readonly Dictionary<int, Func<IpcService>> _ports = new Dictionary<int, Func<IpcService>>();
 
+        private readonly MemoryStream _requestDataStream;
+        private readonly BinaryReader _requestDataReader;
+
+        private readonly MemoryStream _responseDataStream;
+        private readonly BinaryWriter _responseDataWriter;
+
         public ManualResetEvent InitDone { get; }
         public string Name { get; }
         public Func<IpcService> SmObjectFactory { get; }
 
         public ServerBase(KernelContext context, string name, Func<IpcService> smObjectFactory = null)
         {
-            InitDone = new ManualResetEvent(false);
             _context = context;
+
+            _requestDataStream = MemoryStreamManager.Shared.GetStream();
+            _requestDataReader = new BinaryReader(_requestDataStream);
+
+            _responseDataStream = MemoryStreamManager.Shared.GetStream();
+            _responseDataWriter = new BinaryWriter(_responseDataStream);
+
+            InitDone = new ManualResetEvent(false);
             Name = name;
             SmObjectFactory = smObjectFactory;
 
@@ -61,7 +79,10 @@ namespace Ryujinx.HLE.HOS.Services
 
         private void AddPort(int serverPortHandle, Func<IpcService> objectFactory)
         {
-            _portHandles.Add(serverPortHandle);
+            lock (_handleLock)
+            {
+                _portHandles.Add(serverPortHandle);
+            }
             _ports.Add(serverPortHandle, objectFactory);
         }
 
@@ -76,7 +97,10 @@ namespace Ryujinx.HLE.HOS.Services
 
         public void AddSessionObj(int serverSessionHandle, IpcService obj)
         {
-            _sessionHandles.Add(serverSessionHandle);
+            lock (_handleLock)
+            {
+                _sessionHandles.Add(serverSessionHandle);
+            }
             _sessions.Add(serverSessionHandle, obj);
         }
 
@@ -110,15 +134,23 @@ namespace Ryujinx.HLE.HOS.Services
 
             while (true)
             {
-                int[] portHandles = _portHandles.ToArray();
-                int[] sessionHandles = _sessionHandles.ToArray();
-                int[] handles = new int[portHandles.Length + sessionHandles.Length];
+                int handleCount;
+                int portHandleCount;
+                int[] handles;
 
-                portHandles.CopyTo(handles, 0);
-                sessionHandles.CopyTo(handles, portHandles.Length);
+                lock (_handleLock)
+                {
+                    portHandleCount = _portHandles.Count;
+                    handleCount = portHandleCount + _sessionHandles.Count;
+
+                    handles = ArrayPool<int>.Shared.Rent(handleCount);
+
+                    _portHandles.CopyTo(handles, 0);
+                    _sessionHandles.CopyTo(handles, portHandleCount);
+                }
 
                 // We still need a timeout here to allow the service to pick up and listen new sessions...
-                var rc = _context.Syscall.ReplyAndReceive(out int signaledIndex, handles, replyTargetHandle, 1000000L);
+                var rc = _context.Syscall.ReplyAndReceive(out int signaledIndex, handles.AsSpan(0, handleCount), replyTargetHandle, 1000000L);
 
                 thread.HandlePostSyscall();
 
@@ -129,7 +161,7 @@ namespace Ryujinx.HLE.HOS.Services
 
                 replyTargetHandle = 0;
 
-                if (rc == Result.Success && signaledIndex >= portHandles.Length)
+                if (rc == Result.Success && signaledIndex >= portHandleCount)
                 {
                     // We got a IPC request, process it, pass to the appropriate service if needed.
                     int signaledHandle = handles[signaledIndex];
@@ -156,6 +188,8 @@ namespace Ryujinx.HLE.HOS.Services
                     _selfProcess.CpuMemory.Write(messagePtr + 0x4, 2 << 10);
                     _selfProcess.CpuMemory.Write(messagePtr + 0x8, heapAddr | ((ulong)PointerBufferSize << 48));
                 }
+
+                ArrayPool<int>.Shared.Return(handles);
             }
 
             Dispose();
@@ -166,13 +200,9 @@ namespace Ryujinx.HLE.HOS.Services
             KProcess process = KernelStatic.GetCurrentProcess();
             KThread thread = KernelStatic.GetCurrentThread();
             ulong messagePtr = thread.TlsAddress;
-            ulong messageSize = 0x100;
 
-            byte[] reqData = new byte[messageSize];
+            IpcMessage request = ReadRequest(process, messagePtr);
 
-            process.CpuMemory.Read(messagePtr, reqData);
-
-            IpcMessage request = new IpcMessage(reqData, (long)messagePtr);
             IpcMessage response = new IpcMessage();
 
             ulong tempAddr = recvListAddr;
@@ -202,158 +232,160 @@ namespace Ryujinx.HLE.HOS.Services
             bool shouldReply = true;
             bool isTipcCommunication = false;
 
-            using (MemoryStream raw = new MemoryStream(request.RawData))
+            _requestDataStream.SetLength(0);
+            _requestDataStream.Write(request.RawData);
+            _requestDataStream.Position = 0;
+
+            if (request.Type == IpcMessageType.HipcRequest ||
+                request.Type == IpcMessageType.HipcRequestWithContext)
             {
-                BinaryReader reqReader = new BinaryReader(raw);
+                response.Type = IpcMessageType.HipcResponse;
 
-                if (request.Type == IpcMessageType.HipcRequest ||
-                    request.Type == IpcMessageType.HipcRequestWithContext)
+                _responseDataStream.SetLength(0);
+
+                ServiceCtx context = new ServiceCtx(
+                    _context.Device,
+                    process,
+                    process.CpuMemory,
+                    thread,
+                    request,
+                    response,
+                    _requestDataReader,
+                    _responseDataWriter);
+
+                _sessions[serverSessionHandle].CallHipcMethod(context);
+
+                response.RawData = _responseDataStream.ToArray();
+            }
+            else if (request.Type == IpcMessageType.HipcControl ||
+                        request.Type == IpcMessageType.HipcControlWithContext)
+            {
+                uint magic = (uint)_requestDataReader.ReadUInt64();
+                uint cmdId = (uint)_requestDataReader.ReadUInt64();
+
+                switch (cmdId)
                 {
-                    response.Type = IpcMessageType.HipcResponse;
+                    case 0:
+                        FillHipcResponse(response, 0, _sessions[serverSessionHandle].ConvertToDomain());
+                        break;
 
-                    using (MemoryStream resMs = new MemoryStream())
-                    {
-                        BinaryWriter resWriter = new BinaryWriter(resMs);
+                    case 3:
+                        FillHipcResponse(response, 0, PointerBufferSize);
+                        break;
 
-                        ServiceCtx context = new ServiceCtx(
-                            _context.Device,
-                            process,
-                            process.CpuMemory,
-                            thread,
-                            request,
-                            response,
-                            reqReader,
-                            resWriter);
+                    // TODO: Whats the difference between IpcDuplicateSession/Ex?
+                    case 2:
+                    case 4:
+                        int unknown = _requestDataReader.ReadInt32();
 
-                        _sessions[serverSessionHandle].CallHipcMethod(context);
+                        _context.Syscall.CreateSession(out int dupServerSessionHandle, out int dupClientSessionHandle, false, 0);
 
-                        response.RawData = resMs.ToArray();
-                    }
+                        AddSessionObj(dupServerSessionHandle, _sessions[serverSessionHandle]);
+
+                        response.HandleDesc = IpcHandleDesc.MakeMove(dupClientSessionHandle);
+
+                        FillHipcResponse(response, 0);
+
+                        break;
+
+                    default: throw new NotImplementedException(cmdId.ToString());
                 }
-                else if (request.Type == IpcMessageType.HipcControl ||
-                         request.Type == IpcMessageType.HipcControlWithContext)
+            }
+            else if (request.Type == IpcMessageType.HipcCloseSession || request.Type == IpcMessageType.TipcCloseSession)
+            {
+                _context.Syscall.CloseHandle(serverSessionHandle);
+                lock (_handleLock)
                 {
-                    uint magic = (uint)reqReader.ReadUInt64();
-                    uint cmdId = (uint)reqReader.ReadUInt64();
-
-                    switch (cmdId)
-                    {
-                        case 0:
-                            request = FillResponse(response, 0, _sessions[serverSessionHandle].ConvertToDomain());
-                            break;
-
-                        case 3:
-                            request = FillResponse(response, 0, PointerBufferSize);
-                            break;
-
-                        // TODO: Whats the difference between IpcDuplicateSession/Ex?
-                        case 2:
-                        case 4:
-                            int unknown = reqReader.ReadInt32();
-
-                            _context.Syscall.CreateSession(out int dupServerSessionHandle, out int dupClientSessionHandle, false, 0);
-
-                            AddSessionObj(dupServerSessionHandle, _sessions[serverSessionHandle]);
-
-                            response.HandleDesc = IpcHandleDesc.MakeMove(dupClientSessionHandle);
-
-                            request = FillResponse(response, 0);
-
-                            break;
-
-                        default: throw new NotImplementedException(cmdId.ToString());
-                    }
-                }
-                else if (request.Type == IpcMessageType.HipcCloseSession || request.Type == IpcMessageType.TipcCloseSession)
-                {
-                    _context.Syscall.CloseHandle(serverSessionHandle);
                     _sessionHandles.Remove(serverSessionHandle);
-                    IpcService service = _sessions[serverSessionHandle];
-                    if (service is IDisposable disposableObj)
-                    {
-                        disposableObj.Dispose();
-                    }
-                    _sessions.Remove(serverSessionHandle);
-                    shouldReply = false;
                 }
-                // If the type is past 0xF, we are using TIPC
-                else if (request.Type > IpcMessageType.TipcCloseSession)
-                {
-                    isTipcCommunication = true;
-
-                    // Response type is always the same as request on TIPC.
-                    response.Type = request.Type;
-
-                    using (MemoryStream resMs = new MemoryStream())
-                    {
-                        BinaryWriter resWriter = new BinaryWriter(resMs);
-
-                        ServiceCtx context = new ServiceCtx(
-                            _context.Device,
-                            process,
-                            process.CpuMemory,
-                            thread,
-                            request,
-                            response,
-                            reqReader,
-                            resWriter);
-
-                        _sessions[serverSessionHandle].CallTipcMethod(context);
-
-                        response.RawData = resMs.ToArray();
-                    }
-
-                    process.CpuMemory.Write(messagePtr, response.GetBytesTipc());
-                }
-                else
-                {
-                    throw new NotImplementedException(request.Type.ToString());
-                }
-
-                if (!isTipcCommunication)
-                {
-                    process.CpuMemory.Write(messagePtr, response.GetBytes((long)messagePtr, recvListAddr | ((ulong)PointerBufferSize << 48)));
-                }
-
-                return shouldReply;
+                IpcService service = _sessions[serverSessionHandle];
+                (service as IDisposable)?.Dispose();
+                _sessions.Remove(serverSessionHandle);
+                shouldReply = false;
             }
-        }
-
-        private static IpcMessage FillResponse(IpcMessage response, long result, params int[] values)
-        {
-            using (MemoryStream ms = new MemoryStream())
+            // If the type is past 0xF, we are using TIPC
+            else if (request.Type > IpcMessageType.TipcCloseSession)
             {
-                BinaryWriter writer = new BinaryWriter(ms);
+                isTipcCommunication = true;
 
-                foreach (int value in values)
-                {
-                    writer.Write(value);
-                }
+                // Response type is always the same as request on TIPC.
+                response.Type = request.Type;
 
-                return FillResponse(response, result, ms.ToArray());
+                _responseDataStream.SetLength(0);
+
+                ServiceCtx context = new ServiceCtx(
+                    _context.Device,
+                    process,
+                    process.CpuMemory,
+                    thread,
+                    request,
+                    response,
+                    _requestDataReader,
+                    _responseDataWriter);
+
+                _sessions[serverSessionHandle].CallTipcMethod(context);
+
+                response.RawData = _responseDataStream.ToArray();
+
+                using var responseStream = response.GetStreamTipc();
+                process.CpuMemory.Write(messagePtr, responseStream.GetReadOnlySequence());
             }
+            else
+            {
+                throw new NotImplementedException(request.Type.ToString());
+            }
+
+            if (!isTipcCommunication)
+            {
+                using var responseStream = response.GetStream((long)messagePtr, recvListAddr | ((ulong)PointerBufferSize << 48));
+                process.CpuMemory.Write(messagePtr, responseStream.GetReadOnlySequence());
+            }
+
+            return shouldReply;
         }
 
-        private static IpcMessage FillResponse(IpcMessage response, long result, byte[] data = null)
+        private static IpcMessage ReadRequest(KProcess process, ulong messagePtr)
+        {
+            const int messageSize = 0x100;
+
+            byte[] reqData = ArrayPool<byte>.Shared.Rent(messageSize);
+
+            Span<byte> reqDataSpan = reqData.AsSpan(0, messageSize);
+            reqDataSpan.Clear();
+
+            process.CpuMemory.Read(messagePtr, reqDataSpan);
+
+            IpcMessage request = new IpcMessage(reqDataSpan, (long)messagePtr);
+
+            ArrayPool<byte>.Shared.Return(reqData);
+
+            return request;
+        }
+
+        private void FillHipcResponse(IpcMessage response, long result)
+        {
+            FillHipcResponse(response, result, ReadOnlySpan<byte>.Empty);
+        }
+
+        private void FillHipcResponse(IpcMessage response, long result, int value)
+        {
+            Span<byte> span = stackalloc byte[sizeof(int)];
+            BinaryPrimitives.WriteInt32LittleEndian(span, value);
+            FillHipcResponse(response, result, span);
+        }
+
+        private void FillHipcResponse(IpcMessage response, long result, ReadOnlySpan<byte> data)
         {
             response.Type = IpcMessageType.HipcResponse;
 
-            using (MemoryStream ms = new MemoryStream())
-            {
-                BinaryWriter writer = new BinaryWriter(ms);
+            _responseDataStream.SetLength(0);
 
-                writer.Write(IpcMagic.Sfco);
-                writer.Write(result);
+            _responseDataStream.Write(IpcMagic.Sfco);
+            _responseDataStream.Write(result);
 
-                if (data != null)
-                {
-                    writer.Write(data);
-                }
+            _responseDataStream.Write(data);
 
-                response.RawData = ms.ToArray();
-            }
-
-            return response;
+            response.RawData = _responseDataStream.ToArray();
         }
 
         protected virtual void Dispose(bool disposing)
@@ -372,6 +404,11 @@ namespace Ryujinx.HLE.HOS.Services
 
                 _sessions.Clear();
 
+                _requestDataReader.Dispose();
+                _requestDataStream.Dispose();
+                _responseDataWriter.Dispose();
+                _responseDataStream.Dispose();
+
                 InitDone.Dispose();
             }
         }

Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneContentManager.cs

@@ -233,7 +233,7 @@ namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
                 // If the location name is too long, error out.
                 if (locationName.Length > 0x24)
                 {
-                    outLocationNameArray = new string[0];
+                    outLocationNameArray = Array.Empty<string>();
 
                     return ResultCode.LocationNameTooLong;
                 }

Ryujinx.HLE/Loaders/Executables/KipExecutable.cs

@@ -22,7 +22,7 @@ namespace Ryujinx.HLE.Loaders.Executables
         public uint DataSize { get; }
         public uint BssSize  { get; }
 
-        public int[] Capabilities       { get; }
+        public uint[] Capabilities      { get; }
         public bool UsesSecureMemory    { get; }
         public bool Is64BitAddressSpace { get; }
         public bool Is64Bit             { get; }
@@ -57,11 +57,11 @@ namespace Ryujinx.HLE.Loaders.Executables
             Version     = reader.Version;
             Name        = reader.Name.ToString();
 
-            Capabilities = new int[32];
+            Capabilities = new uint[32];
 
             for (int index = 0; index < Capabilities.Length; index++)
             {
-                Capabilities[index] = (int)reader.Capabilities[index];
+                Capabilities[index] = reader.Capabilities[index];
             }
 
             reader.GetSegmentSize(KipReader.SegmentType.Data, out int uncompressedSize).ThrowIfFailure();

Ryujinx.HLE/Utilities/StringUtils.cs

@@ -1,4 +1,6 @@
 using LibHac.Common;
+using Microsoft.IO;
+using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS;
 using System;
 using System.Globalization;
@@ -77,7 +79,7 @@ namespace Ryujinx.HLE.Utilities
             ulong position = context.Request.PtrBuff[index].Position;
             ulong size     = context.Request.PtrBuff[index].Size;
 
-            using (MemoryStream ms = new MemoryStream())
+            using (RecyclableMemoryStream ms = MemoryStreamManager.Shared.GetStream())
             {
                 while (size-- > 0)
                 {
@@ -91,7 +93,7 @@ namespace Ryujinx.HLE.Utilities
                     ms.WriteByte(value);
                 }
 
-                return Encoding.UTF8.GetString(ms.ToArray());
+                return Encoding.UTF8.GetString(ms.GetReadOnlySequence());
             }
         }
 
@@ -110,7 +112,7 @@ namespace Ryujinx.HLE.Utilities
             ulong position = context.Request.SendBuff[index].Position;
             ulong size     = context.Request.SendBuff[index].Size;
 
-            using (MemoryStream ms = new MemoryStream())
+            using (RecyclableMemoryStream ms = MemoryStreamManager.Shared.GetStream())
             {
                 while (size-- > 0)
                 {
@@ -124,7 +126,7 @@ namespace Ryujinx.HLE.Utilities
                     ms.WriteByte(value);
                 }
 
-                return Encoding.UTF8.GetString(ms.ToArray());
+                return Encoding.UTF8.GetString(ms.GetReadOnlySequence());
             }
         }
 

Ryujinx.Input.SDL2/SDL2GamepadDriver.cs

@@ -27,7 +27,9 @@ namespace Ryujinx.Input.SDL2
             SDL2Driver.Instance.OnJoystickDisconnected += HandleJoyStickDisconnected;
 
             // Add already connected gamepads
-            for (int joystickIndex = 0; joystickIndex < SDL_NumJoysticks(); joystickIndex++)
+            int numJoysticks = SDL_NumJoysticks();
+
+            for (int joystickIndex = 0; joystickIndex < numJoysticks; joystickIndex++)
             {
                 HandleJoyStickConnected(joystickIndex, SDL_JoystickGetDeviceInstanceID(joystickIndex));
             }

Ryujinx.Input/Motion/CemuHook/Client.cs

@@ -1,14 +1,15 @@
-using Force.Crc32;
-using Ryujinx.Common;
+using Ryujinx.Common;
 using Ryujinx.Common.Configuration.Hid;
 using Ryujinx.Common.Configuration.Hid.Controller;
 using Ryujinx.Common.Configuration.Hid.Controller.Motion;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Input.HLE;
 using Ryujinx.Input.Motion.CemuHook.Protocol;
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.IO.Hashing;
 using System.Net;
 using System.Net.Sockets;
 using System.Numerics;
@@ -381,7 +382,7 @@ namespace Ryujinx.Input.Motion.CemuHook
 
             Header header = GenerateHeader(clientId);
 
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter writer = new BinaryWriter(stream))
             {
                 writer.WriteStruct(header);
@@ -401,10 +402,10 @@ namespace Ryujinx.Input.Motion.CemuHook
                 writer.Seek(6, SeekOrigin.Begin);
                 writer.Write(header.Length);
 
-                header.Crc32 = Crc32Algorithm.Compute(stream.ToArray());
+                Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
 
                 writer.Seek(8, SeekOrigin.Begin);
-                writer.Write(header.Crc32);
+                writer.Write(header.Crc32.AsSpan());
 
                 byte[] data = stream.ToArray();
 
@@ -421,7 +422,7 @@ namespace Ryujinx.Input.Motion.CemuHook
 
             Header header = GenerateHeader(clientId);
 
-            using (MemoryStream stream = new MemoryStream())
+            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
             using (BinaryWriter writer = new BinaryWriter(stream))
             {
                 writer.WriteStruct(header);
@@ -440,10 +441,10 @@ namespace Ryujinx.Input.Motion.CemuHook
                 writer.Seek(6, SeekOrigin.Begin);
                 writer.Write(header.Length);
 
-                header.Crc32 = Crc32Algorithm.Compute(stream.ToArray());
+                Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
 
                 writer.Seek(8, SeekOrigin.Begin);
-                writer.Write(header.Crc32);
+                writer.Write(header.Crc32.AsSpan());
 
                 byte[] data = stream.ToArray();
 
@@ -458,8 +459,7 @@ namespace Ryujinx.Input.Motion.CemuHook
                 Id          = (uint)clientId,
                 MagicString = Magic,
                 Version     = Version,
-                Length      = 0,
-                Crc32       = 0
+                Length      = 0
             };
 
             return header;

Ryujinx.Input/Motion/CemuHook/Protocol/Header.cs

@@ -1,14 +1,15 @@
-using System.Runtime.InteropServices;
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
 
 namespace Ryujinx.Input.Motion.CemuHook.Protocol
 {
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct Header
     {
-        public uint   MagicString;
+        public uint MagicString;
         public ushort Version;
         public ushort Length;
-        public uint   Crc32;
-        public uint   Id;
+        public Array4<byte> Crc32;
+        public uint Id;
     }
 }

Ryujinx.Input/Ryujinx.Input.csproj

@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Crc32.NET" />
+    <PackageReference Include="System.IO.Hashing" />
   </ItemGroup>
 
   <ItemGroup>

Ryujinx.Memory.Tests/MockVirtualMemoryManager.cs

@@ -78,7 +78,7 @@ namespace Ryujinx.Memory.Tests
 
         IEnumerable<MemoryRange> IVirtualMemoryManager.GetPhysicalRegions(ulong va, ulong size)
         {
-            return NoMappings ? new MemoryRange[0] : new MemoryRange[] { new MemoryRange(va, size) };
+            return NoMappings ? Array.Empty<MemoryRange>() : new MemoryRange[] { new MemoryRange(va, size) };
         }
 
         public bool IsMapped(ulong va)

Ryujinx.Memory/IVirtualMemoryManager.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Memory.Range;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 
 namespace Ryujinx.Memory
@@ -77,6 +78,21 @@ namespace Ryujinx.Memory
         /// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
         void Write(ulong va, ReadOnlySpan<byte> data);
 
+        /// <summary>
+        /// Writes data to CPU mapped memory, with write tracking.
+        /// </summary>
+        /// <param name="va">Virtual address to write the data into</param>
+        /// <param name="data">Data to be written</param>
+        /// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
+        public void Write(ulong va, ReadOnlySequence<byte> data)
+        {
+            foreach (ReadOnlyMemory<byte> segment in data)
+            {
+                Write(va, segment.Span);
+                va += (ulong)segment.Length;
+            }
+        }
+
         /// <summary>
         /// Writes data to the application process, returning false if the data was not changed.
         /// This triggers read memory tracking, as a redundancy check would be useless if the data is not up to date.

Ryujinx.Memory/Range/MultiRange.cs

@@ -8,6 +8,8 @@ namespace Ryujinx.Memory.Range
     /// </summary>
     public readonly struct MultiRange : IEquatable<MultiRange>
     {
+        private const ulong InvalidAddress = ulong.MaxValue;
+
         private readonly MemoryRange _singleRange;
         private readonly MemoryRange[] _ranges;
 
@@ -18,16 +20,6 @@ namespace Ryujinx.Memory.Range
         /// </summary>
         public int Count => HasSingleRange ? 1 : _ranges.Length;
 
-        /// <summary>
-        /// Minimum start address of all sub-ranges.
-        /// </summary>
-        public ulong MinAddress { get; }
-
-        /// <summary>
-        /// Maximum end address of all sub-ranges.
-        /// </summary>
-        public ulong MaxAddress { get; }
-
         /// <summary>
         /// Creates a new multi-range with a single physical region.
         /// </summary>
@@ -37,8 +29,6 @@ namespace Ryujinx.Memory.Range
         {
             _singleRange = new MemoryRange(address, size);
             _ranges = null;
-            MinAddress = address;
-            MaxAddress = address + size;
         }
 
         /// <summary>
@@ -50,30 +40,6 @@ namespace Ryujinx.Memory.Range
         {
             _singleRange = MemoryRange.Empty;
             _ranges = ranges ?? throw new ArgumentNullException(nameof(ranges));
-
-            if (ranges.Length != 0)
-            {
-                MinAddress = ulong.MaxValue;
-                MaxAddress = 0UL;
-
-                foreach (MemoryRange range in ranges)
-                {
-                    if (MinAddress > range.Address)
-                    {
-                        MinAddress = range.Address;
-                    }
-
-                    if (MaxAddress < range.EndAddress)
-                    {
-                        MaxAddress = range.EndAddress;
-                    }
-                }
-            }
-            else
-            {
-                MinAddress = 0UL;
-                MaxAddress = 0UL;
-            }
         }
 
         /// <summary>
@@ -82,7 +48,7 @@ namespace Ryujinx.Memory.Range
         /// <param name="offset">Offset of the slice into the multi-range in bytes</param>
         /// <param name="size">Size of the slice in bytes</param>
         /// <returns>A new multi-range representing the given slice of this one</returns>
-        public MultiRange GetSlice(ulong offset, ulong size)
+        public MultiRange Slice(ulong offset, ulong size)
         {
             if (HasSingleRange)
             {
@@ -107,7 +73,16 @@ namespace Ryujinx.Memory.Range
                     else if (offset < range.Size)
                     {
                         ulong sliceSize = Math.Min(size, range.Size - offset);
-                        ranges.Add(new MemoryRange(range.Address + offset, sliceSize));
+
+                        if (range.Address == InvalidAddress)
+                        {
+                            ranges.Add(new MemoryRange(range.Address, sliceSize));
+                        }
+                        else
+                        {
+                            ranges.Add(new MemoryRange(range.Address + offset, sliceSize));
+                        }
+
                         size -= sliceSize;
                     }
 

Ryujinx/Ui/Windows/AvatarWindow.cs

@@ -6,6 +6,7 @@ using LibHac.FsSystem;
 using LibHac.Ncm;
 using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common.Memory;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.Ui.Common.Configuration;
 using SixLabors.ImageSharp;
@@ -136,8 +137,8 @@ namespace Ryujinx.Ui.Windows
 
                             romfs.OpenFile(ref file.Ref, ("/" + item.FullPath).ToU8Span(), OpenMode.Read).ThrowIfFailure();
 
-                            using (MemoryStream stream    = new MemoryStream())
-                            using (MemoryStream streamPng = new MemoryStream())
+                            using (MemoryStream stream    = MemoryStreamManager.Shared.GetStream())
+                            using (MemoryStream streamPng = MemoryStreamManager.Shared.GetStream())
                             {
                                 file.Get.AsStream().CopyTo(stream);
 
@@ -169,7 +170,7 @@ namespace Ryujinx.Ui.Windows
 
         private byte[] ProcessImage(byte[] data)
         {
-            using (MemoryStream streamJpg = new MemoryStream())
+            using (MemoryStream streamJpg = MemoryStreamManager.Shared.GetStream())
             {
                 Image avatarImage = Image.Load(data, new PngDecoder());
 

Ryujinx/Ui/Windows/UserProfilesManagerWindow.cs

@@ -1,4 +1,5 @@
 using Gtk;
+using Ryujinx.Common.Memory;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS.Services.Account.Acc;
 using Ryujinx.Ui.Common.Configuration;
@@ -181,7 +182,7 @@ namespace Ryujinx.Ui.Windows
             {
                 image.Mutate(x => x.Resize(256, 256));
 
-                using (MemoryStream streamJpg = new MemoryStream())
+                using (MemoryStream streamJpg = MemoryStreamManager.Shared.GetStream())
                 {
                     image.SaveAsJpeg(streamJpg);
 

distribution/macos/create_app_bundle.sh

@@ -6,31 +6,31 @@ PUBLISH_DIRECTORY=$1
 OUTPUT_DIRECTORY=$2
 ENTITLEMENTS_FILE_PATH=$3
 
-APP_BUNDLE_DIRECTORY=$OUTPUT_DIRECTORY/Ryujinx.app
+APP_BUNDLE_DIRECTORY="$OUTPUT_DIRECTORY/Ryujinx.app"
 
-rm -rf $APP_BUNDLE_DIRECTORY
-mkdir -p $APP_BUNDLE_DIRECTORY/Contents
-mkdir $APP_BUNDLE_DIRECTORY/Contents/Frameworks
-mkdir $APP_BUNDLE_DIRECTORY/Contents/MacOS
-mkdir $APP_BUNDLE_DIRECTORY/Contents/Resources
+rm -rf "$APP_BUNDLE_DIRECTORY"
+mkdir -p "$APP_BUNDLE_DIRECTORY/Contents"
+mkdir "$APP_BUNDLE_DIRECTORY/Contents/Frameworks"
+mkdir "$APP_BUNDLE_DIRECTORY/Contents/MacOS"
+mkdir "$APP_BUNDLE_DIRECTORY/Contents/Resources"
 
 # Copy executables first
-cp $PUBLISH_DIRECTORY/Ryujinx.Ava $APP_BUNDLE_DIRECTORY/Contents/MacOS/Ryujinx
-chmod u+x $APP_BUNDLE_DIRECTORY/Contents/MacOS/Ryujinx
+cp "$PUBLISH_DIRECTORY/Ryujinx.Ava" "$APP_BUNDLE_DIRECTORY/Contents/MacOS/Ryujinx"
+chmod u+x "$APP_BUNDLE_DIRECTORY/Contents/MacOS/Ryujinx"
 
 # Then all libraries
-cp $PUBLISH_DIRECTORY/*.dylib $APP_BUNDLE_DIRECTORY/Contents/Frameworks
+cp "$PUBLISH_DIRECTORY"/*.dylib "$APP_BUNDLE_DIRECTORY/Contents/Frameworks"
 
 # Then resources
-cp Info.plist $APP_BUNDLE_DIRECTORY/Contents
-cp Ryujinx.icns $APP_BUNDLE_DIRECTORY/Contents/Resources/Ryujinx.icns
-cp updater.sh $APP_BUNDLE_DIRECTORY/Contents/Resources/updater.sh
-cp -r $PUBLISH_DIRECTORY/THIRDPARTY.md $APP_BUNDLE_DIRECTORY/Contents/Resources
+cp Info.plist "$APP_BUNDLE_DIRECTORY/Contents"
+cp Ryujinx.icns "$APP_BUNDLE_DIRECTORY/Contents/Resources/Ryujinx.icns"
+cp updater.sh "$APP_BUNDLE_DIRECTORY/Contents/Resources/updater.sh"
+cp -r "$PUBLISH_DIRECTORY/THIRDPARTY.md" "$APP_BUNDLE_DIRECTORY/Contents/Resources"
 
-echo -n "APPL????" > $APP_BUNDLE_DIRECTORY/Contents/PkgInfo
+echo -n "APPL????" > "$APP_BUNDLE_DIRECTORY/Contents/PkgInfo"
 
 # Fixup libraries and executable
-python3 bundle_fix_up.py $APP_BUNDLE_DIRECTORY MacOS/Ryujinx
+python3 bundle_fix_up.py "$APP_BUNDLE_DIRECTORY" MacOS/Ryujinx
 
 # Now sign it
 if ! [ -x "$(command -v codesign)" ];
@@ -44,9 +44,9 @@ then
     # NOTE: Currently require https://github.com/indygreg/apple-platform-rs/pull/44 to work on other OSes.
     # cargo install --git "https://github.com/marysaka/apple-platform-rs" --branch "fix/adhoc-app-bundle" apple-codesign --bin "rcodesign"
     echo "Usign rcodesign for ad-hoc signing"
-    rcodesign sign --entitlements-xml-path $ENTITLEMENTS_FILE_PATH $APP_BUNDLE_DIRECTORY
+    rcodesign sign --entitlements-xml-path "$ENTITLEMENTS_FILE_PATH" "$APP_BUNDLE_DIRECTORY"
 else
     echo "Usign codesign for ad-hoc signing"
-    codesign --entitlements $ENTITLEMENTS_FILE_PATH -f --deep -s - $APP_BUNDLE_DIRECTORY
+    codesign --entitlements "$ENTITLEMENTS_FILE_PATH" -f --deep -s - "$APP_BUNDLE_DIRECTORY"
 fi
 

distribution/macos/create_macos_release.sh

@@ -7,54 +7,54 @@ if [ "$#" -ne 6 ]; then
     exit 1
 fi
 
-mkdir -p $1
-mkdir -p $2
-mkdir -p $3
+mkdir -p "$1"
+mkdir -p "$2"
+mkdir -p "$3"
 
-BASE_DIR=$(readlink -f $1)
-TEMP_DIRECTORY=$(readlink -f $2)
-OUTPUT_DIRECTORY=$(readlink -f $3)
-ENTITLEMENTS_FILE_PATH=$(readlink -f $4)
+BASE_DIR=$(readlink -f "$1")
+TEMP_DIRECTORY=$(readlink -f "$2")
+OUTPUT_DIRECTORY=$(readlink -f "$3")
+ENTITLEMENTS_FILE_PATH=$(readlink -f "$4")
 VERSION=$5
 SOURCE_REVISION_ID=$6
 
 RELEASE_TAR_FILE_NAME=Ryujinx-$VERSION-macos_universal.app.tar
-ARM64_APP_BUNDLE=$TEMP_DIRECTORY/output_arm64/Ryujinx.app
-X64_APP_BUNDLE=$TEMP_DIRECTORY/output_x64/Ryujinx.app
-UNIVERSAL_APP_BUNDLE=$OUTPUT_DIRECTORY/Ryujinx.app
+ARM64_APP_BUNDLE="$TEMP_DIRECTORY/output_arm64/Ryujinx.app"
+X64_APP_BUNDLE="$TEMP_DIRECTORY/output_x64/Ryujinx.app"
+UNIVERSAL_APP_BUNDLE="$OUTPUT_DIRECTORY/Ryujinx.app"
 EXECUTABLE_SUB_PATH=Contents/MacOS/Ryujinx
 
-rm -rf $TEMP_DIRECTORY
-mkdir -p $TEMP_DIRECTORY
+rm -rf "$TEMP_DIRECTORY"
+mkdir -p "$TEMP_DIRECTORY"
 
 DOTNET_COMMON_ARGS="-p:DebugType=embedded -p:Version=$VERSION -p:SourceRevisionId=$SOURCE_REVISION_ID --self-contained true"
 
 dotnet restore
 dotnet build -c Release Ryujinx.Ava
-dotnet publish -c Release -r osx-arm64 -o $TEMP_DIRECTORY/publish_arm64 $DOTNET_COMMON_ARGS Ryujinx.Ava
-dotnet publish -c Release -r osx-x64 -o $TEMP_DIRECTORY/publish_x64 $DOTNET_COMMON_ARGS Ryujinx.Ava
+dotnet publish -c Release -r osx-arm64 -o "$TEMP_DIRECTORY/publish_arm64" $DOTNET_COMMON_ARGS Ryujinx.Ava
+dotnet publish -c Release -r osx-x64 -o "$TEMP_DIRECTORY/publish_x64" $DOTNET_COMMON_ARGS Ryujinx.Ava
 
 # Get ride of the support library for ARMeilleur for x64 (that's only for arm64)
-rm -rf $TEMP_DIRECTORY/publish_x64/libarmeilleure-jitsupport.dylib
+rm -rf "$TEMP_DIRECTORY/publish_x64/libarmeilleure-jitsupport.dylib"
 
 # Get ride of libsoundio from arm64 builds as we don't have a arm64 variant
 # TODO: remove this once done
-rm -rf $TEMP_DIRECTORY/publish_arm64/libsoundio.dylib
+rm -rf "$TEMP_DIRECTORY/publish_arm64/libsoundio.dylib"
 
-pushd $BASE_DIR/distribution/macos
-./create_app_bundle.sh $TEMP_DIRECTORY/publish_x64 $TEMP_DIRECTORY/output_x64 $ENTITLEMENTS_FILE_PATH
-./create_app_bundle.sh $TEMP_DIRECTORY/publish_arm64 $TEMP_DIRECTORY/output_arm64 $ENTITLEMENTS_FILE_PATH
+pushd "$BASE_DIR/distribution/macos"
+./create_app_bundle.sh "$TEMP_DIRECTORY/publish_x64" "$TEMP_DIRECTORY/output_x64" "$ENTITLEMENTS_FILE_PATH"
+./create_app_bundle.sh "$TEMP_DIRECTORY/publish_arm64" "$TEMP_DIRECTORY/output_arm64" "$ENTITLEMENTS_FILE_PATH"
 popd
 
-rm -rf $UNIVERSAL_APP_BUNDLE
-mkdir -p $OUTPUT_DIRECTORY
+rm -rf "$UNIVERSAL_APP_BUNDLE"
+mkdir -p "$OUTPUT_DIRECTORY"
 
 # Let's copy one of the two different app bundle and remove the executable
-cp -R $ARM64_APP_BUNDLE $UNIVERSAL_APP_BUNDLE
-rm $UNIVERSAL_APP_BUNDLE/$EXECUTABLE_SUB_PATH
+cp -R "$ARM64_APP_BUNDLE" "$UNIVERSAL_APP_BUNDLE"
+rm "$UNIVERSAL_APP_BUNDLE/$EXECUTABLE_SUB_PATH"
 
 # Make it libraries universal
-python3 $BASE_DIR/distribution/macos/construct_universal_dylib.py $ARM64_APP_BUNDLE $X64_APP_BUNDLE $UNIVERSAL_APP_BUNDLE "**/*.dylib"
+python3 "$BASE_DIR/distribution/macos/construct_universal_dylib.py" "$ARM64_APP_BUNDLE" "$X64_APP_BUNDLE" "$UNIVERSAL_APP_BUNDLE" "**/*.dylib"
 
 if ! [ -x "$(command -v lipo)" ];
 then
@@ -69,12 +69,12 @@ else
 fi
 
 # Make it the executable universal
-$LIPO $ARM64_APP_BUNDLE/$EXECUTABLE_SUB_PATH $X64_APP_BUNDLE/$EXECUTABLE_SUB_PATH -output $UNIVERSAL_APP_BUNDLE/$EXECUTABLE_SUB_PATH -create
+$LIPO "$ARM64_APP_BUNDLE/$EXECUTABLE_SUB_PATH" "$X64_APP_BUNDLE/$EXECUTABLE_SUB_PATH" -output "$UNIVERSAL_APP_BUNDLE/$EXECUTABLE_SUB_PATH" -create
 
 # Patch up the Info.plist to have appropriate version
-sed -r -i.bck "s/\%\%RYUJINX_BUILD_VERSION\%\%/$VERSION/g;" $UNIVERSAL_APP_BUNDLE/Contents/Info.plist
-sed -r -i.bck "s/\%\%RYUJINX_BUILD_GIT_HASH\%\%/$SOURCE_REVISION_ID/g;" $UNIVERSAL_APP_BUNDLE/Contents/Info.plist
-rm $UNIVERSAL_APP_BUNDLE/Contents/Info.plist.bck
+sed -r -i.bck "s/\%\%RYUJINX_BUILD_VERSION\%\%/$VERSION/g;" "$UNIVERSAL_APP_BUNDLE/Contents/Info.plist"
+sed -r -i.bck "s/\%\%RYUJINX_BUILD_GIT_HASH\%\%/$SOURCE_REVISION_ID/g;" "$UNIVERSAL_APP_BUNDLE/Contents/Info.plist"
+rm "$UNIVERSAL_APP_BUNDLE/Contents/Info.plist.bck"
 
 # Now sign it
 if ! [ -x "$(command -v codesign)" ];
@@ -88,16 +88,16 @@ then
     # NOTE: Currently require https://github.com/indygreg/apple-platform-rs/pull/44 to work on other OSes.
     # cargo install --git "https://github.com/marysaka/apple-platform-rs" --branch "fix/adhoc-app-bundle" apple-codesign --bin "rcodesign"
     echo "Usign rcodesign for ad-hoc signing"
-    rcodesign sign --entitlements-xml-path $ENTITLEMENTS_FILE_PATH $UNIVERSAL_APP_BUNDLE
+    rcodesign sign --entitlements-xml-path "$ENTITLEMENTS_FILE_PATH" "$UNIVERSAL_APP_BUNDLE"
 else
     echo "Usign codesign for ad-hoc signing"
-    codesign --entitlements $ENTITLEMENTS_FILE_PATH -f --deep -s - $UNIVERSAL_APP_BUNDLE
+    codesign --entitlements "$ENTITLEMENTS_FILE_PATH" -f --deep -s - "$UNIVERSAL_APP_BUNDLE"
 fi
 
 echo "Creating archive"
-pushd $OUTPUT_DIRECTORY
+pushd "$OUTPUT_DIRECTORY"
 tar --exclude "Ryujinx.app/Contents/MacOS/Ryujinx" -cvf $RELEASE_TAR_FILE_NAME Ryujinx.app 1> /dev/null
-python3 $BASE_DIR/distribution/misc/add_tar_exec.py $RELEASE_TAR_FILE_NAME "Ryujinx.app/Contents/MacOS/Ryujinx" "Ryujinx.app/Contents/MacOS/Ryujinx"
+python3 "$BASE_DIR/distribution/misc/add_tar_exec.py" $RELEASE_TAR_FILE_NAME "Ryujinx.app/Contents/MacOS/Ryujinx" "Ryujinx.app/Contents/MacOS/Ryujinx"
 gzip -9 < $RELEASE_TAR_FILE_NAME > $RELEASE_TAR_FILE_NAME.gz
 rm $RELEASE_TAR_FILE_NAME
 popd

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "7.0.100",
+    "version": "7.0.200",
     "rollForward": "latestFeature"
   }
 }