Add multi-level function table (#2228)

* Add AddressTable<T>

* Use AddressTable<T> for dispatch

* Remove JumpTable & co.

* Add fallback for out of range addresses

* Add PPTC support

* Add documentation to `AddressTable<T>`

* Make AddressTable<T> configurable

* Fix table walk

* Fix IsMapped check

* Remove CountTableCapacity

* Add PPTC support for fast path

* Rename IsMapped to IsValid

* Remove stale comment

* Change format of address in exception message

* Add TranslatorStubs

* Split DispatchStub

Avoids recompilation of stubs during tests.

* Add hint for 64bit or 32bit

* Add documentation to `Symbol`

* Add documentation to `TranslatorStubs`

Make `TranslatorStubs` disposable as well.

* Add documentation to `SymbolType`

* Add `AddressTableEventSource` to monitor function table size

Add an EventSource which measures the amount of unmanaged bytes
allocated by AddressTable<T> instances.

 dotnet-counters monitor -n Ryujinx --counters ARMeilleure

* Add `AllowLcqInFunctionTable` optimization toggle

This is to reduce the impact this change has on the test duration.
Before everytime a test was ran, the FunctionTable would be initialized
and populated so that the newly compiled test would get registered to
it.

* Implement unmanaged dispatcher

Uses the DispatchStub to dispatch into the next translation, which
allows execution to stay in unmanaged for longer and skips a
ConcurrentDictionary look up when the target translation has been
registered to the FunctionTable.

* Remove redundant null check

* Tune levels of FunctionTable

Uses 5 levels instead of 4 and change unit of AddressTableEventSource
from KB to MB.

* Use 64-bit function table

Improves codegen for direct branches:

    mov qword [rax+0x408],0x10603560
 -  mov rcx,sub_10603560_OFFSET
 -  mov ecx,[rcx]
 -  mov ecx,ecx
 -  mov rdx,JIT_CACHE_BASE
 -  add rdx,rcx
 +  mov rcx,sub_10603560
 +  mov rdx,[rcx]
    mov rcx,rax

Improves codegen for dispatch stub:

    and rax,byte +0x1f
 -  mov eax,[rcx+rax*4]
 -  mov eax,eax
 -  mov rcx,JIT_CACHE_BASE
 -  lea rax,[rcx+rax]
 +  mov rax,[rcx+rax*8]
    mov rcx,rbx

* Remove `JitCacheSymbol` & `JitCache.Offset`

* Turn `Translator.Translate` into an instance method

We do not have to add more parameter to this method and related ones as
new structures are added & needed for translation.

* Add symbol only when PTC is enabled

Address LDj3SNuD's feedback

* Change `NativeContext.Running` to a 32-bit integer

* Fix PageTable symbol for host mapped

1 files changed, 0 insertions, 125 deletions

diff --git a/ARMeilleure/Translation/DirectCallStubs.cs b/ARMeilleure/Translation/DirectCallStubs.cs
deleted file mode 100644
index 85af6901..00000000
--- a/ARMeilleure/Translation/DirectCallStubs.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-using ARMeilleure.Instructions;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using System;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-
-using static ARMeilleure.IntermediateRepresentation.OperandHelper;
-
-namespace ARMeilleure.Translation
-{
-    static class DirectCallStubs
-    {
-        private delegate long GuestFunction(IntPtr nativeContextPtr);
-
-        private static IntPtr _directCallStubPtr;
-        private static IntPtr _directTailCallStubPtr;
-        private static IntPtr _indirectCallStubPtr;
-        private static IntPtr _indirectTailCallStubPtr;
-
-        private static readonly object _lock = new object();
-        private static bool _initialized;
-
-        public static void InitializeStubs()
-        {
-            if (_initialized) return;
-
-            lock (_lock)
-            {
-                if (_initialized) return;
-
-                Translator.PreparePool();
-
-                _directCallStubPtr       = Marshal.GetFunctionPointerForDelegate<GuestFunction>(GenerateDirectCallStub(false));
-                _directTailCallStubPtr   = Marshal.GetFunctionPointerForDelegate<GuestFunction>(GenerateDirectCallStub(true));
-                _indirectCallStubPtr     = Marshal.GetFunctionPointerForDelegate<GuestFunction>(GenerateIndirectCallStub(false));
-                _indirectTailCallStubPtr = Marshal.GetFunctionPointerForDelegate<GuestFunction>(GenerateIndirectCallStub(true));
-
-                Translator.ResetPool();
-
-                Translator.DisposePools();
-
-                _initialized = true;
-            }
-        }
-
-        public static IntPtr DirectCallStub(bool tailCall)
-        {
-            Debug.Assert(_initialized);
-
-            return tailCall ? _directTailCallStubPtr : _directCallStubPtr;
-        }
-
-        public static IntPtr IndirectCallStub(bool tailCall)
-        {
-            Debug.Assert(_initialized);
-
-            return tailCall ? _indirectTailCallStubPtr : _indirectCallStubPtr;
-        }
-
-        private static void EmitCall(EmitterContext context, Operand address, bool tailCall)
-        {
-            if (tailCall)
-            {
-                context.Tailcall(address, context.LoadArgument(OperandType.I64, 0));
-            }
-            else
-            {
-                context.Return(context.Call(address, OperandType.I64, context.LoadArgument(OperandType.I64, 0)));
-            }
-        }
-
-        /// <summary>
-        /// Generates a stub that is used to find function addresses. Used for direct calls when their jump table does not have the host address yet.
-        /// Takes a NativeContext like a translated guest function, and extracts the target address from the NativeContext.
-        /// When the target function is compiled in highCq, all table entries are updated to point to that function instead of this stub by the translator.
-        /// </summary>
-        private static GuestFunction GenerateDirectCallStub(bool tailCall)
-        {
-            EmitterContext context = new EmitterContext();
-
-            Operand nativeContextPtr = context.LoadArgument(OperandType.I64, 0);
-
-            Operand address = context.Load(OperandType.I64, context.Add(nativeContextPtr, Const((long)NativeContext.GetCallAddressOffset())));
-
-            Operand functionAddr = context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress)), address);
-            EmitCall(context, functionAddr, tailCall);
-
-            ControlFlowGraph cfg = context.GetControlFlowGraph();
-
-            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
-
-            return Compiler.Compile<GuestFunction>(cfg, argTypes, OperandType.I64, CompilerOptions.HighCq);
-        }
-
-        /// <summary>
-        /// Generates a stub that is used to find function addresses and add them to an indirect table.
-        /// Used for indirect calls entries (already claimed) when their jump table does not have the host address yet.
-        /// Takes a NativeContext like a translated guest function, and extracts the target indirect table entry from the NativeContext.
-        /// If the function we find is highCq, the entry in the table is updated to point to that function rather than this stub.
-        /// </summary>
-        private static GuestFunction GenerateIndirectCallStub(bool tailCall)
-        {
-            EmitterContext context = new EmitterContext();
-
-            Operand nativeContextPtr = context.LoadArgument(OperandType.I64, 0);
-
-            Operand entryAddress = context.Load(OperandType.I64, context.Add(nativeContextPtr, Const((long)NativeContext.GetCallAddressOffset())));
-            Operand address = context.Load(OperandType.I64, entryAddress);
-
-            // We need to find the missing function. If the function is HighCq, then it replaces this stub in the indirect table.
-            // Either way, we call it afterwards.
-            Operand functionAddr = context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetIndirectFunctionAddress)), address, entryAddress);
-
-            // Call and save the function.
-            EmitCall(context, functionAddr, tailCall);
-
-            ControlFlowGraph cfg = context.GetControlFlowGraph();
-
-            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
-
-            return Compiler.Compile<GuestFunction>(cfg, argTypes, OperandType.I64, CompilerOptions.HighCq);
-        }
-    }
-}