diff --git a/src/ARMeilleure/Instructions/InstEmitSimdArithmetic.cs b/src/ARMeilleure/Instructions/InstEmitSimdArithmetic.cs
index 13d9fac68..694633f97 100644
--- a/src/ARMeilleure/Instructions/InstEmitSimdArithmetic.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdArithmetic.cs
@@ -406,7 +406,7 @@ namespace ARMeilleure.Instructions
                 {
                     Operand res = EmitSoftFloatCall(context, nameof(SoftFloat32.FPSub), op1, op2);
 
-                    return EmitUnaryMathCall(context, nameof(Math.Abs), res);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Abs), res);
                 });
             }
         }
@@ -451,7 +451,7 @@ namespace ARMeilleure.Instructions
                 {
                     Operand res = EmitSoftFloatCall(context, nameof(SoftFloat32.FPSub), op1, op2);
 
-                    return EmitUnaryMathCall(context, nameof(Math.Abs), res);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Abs), res);
                 });
             }
         }
@@ -483,7 +483,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitScalarUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Abs), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Abs), op1);
                 });
             }
         }
@@ -522,7 +522,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitVectorUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Abs), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Abs), op1);
                 });
             }
         }
@@ -2246,7 +2246,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitScalarUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Floor), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Floor), op1);
                 });
             }
         }
@@ -2265,7 +2265,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitVectorUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Floor), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Floor), op1);
                 });
             }
         }
@@ -2322,7 +2322,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitScalarUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Ceiling), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), op1);
                 });
             }
         }
@@ -2341,7 +2341,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitVectorUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Ceiling), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), op1);
                 });
             }
         }
@@ -2390,7 +2390,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitScalarUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Truncate), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Truncate), op1);
                 });
             }
         }
@@ -2409,7 +2409,7 @@ namespace ARMeilleure.Instructions
             {
                 EmitVectorUnaryOpF(context, (op1) =>
                 {
-                    return EmitUnaryMathCall(context, nameof(Math.Truncate), op1);
+                    return EmitUnaryMathCall(context, nameof(MathHelper.Truncate), op1);
                 });
             }
         }
diff --git a/src/ARMeilleure/Instructions/InstEmitSimdArithmetic32.cs b/src/ARMeilleure/Instructions/InstEmitSimdArithmetic32.cs
index c807fc858..284f3f576 100644
--- a/src/ARMeilleure/Instructions/InstEmitSimdArithmetic32.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdArithmetic32.cs
@@ -43,7 +43,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitScalarUnaryOpF32(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Abs), op1));
+                EmitScalarUnaryOpF32(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Abs), op1));
             }
         }
 
@@ -66,7 +66,7 @@ namespace ARMeilleure.Instructions
                 }
                 else
                 {
-                    EmitVectorUnaryOpF32(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Abs), op1));
+                    EmitVectorUnaryOpF32(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Abs), op1));
                 }
             }
             else
diff --git a/src/ARMeilleure/Instructions/InstEmitSimdCmp.cs b/src/ARMeilleure/Instructions/InstEmitSimdCmp.cs
index aab677869..8fcb06286 100644
--- a/src/ARMeilleure/Instructions/InstEmitSimdCmp.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdCmp.cs
@@ -726,8 +726,8 @@ namespace ARMeilleure.Instructions
 
                 if (absolute)
                 {
-                    ne = EmitUnaryMathCall(context, nameof(Math.Abs), ne);
-                    me = EmitUnaryMathCall(context, nameof(Math.Abs), me);
+                    ne = EmitUnaryMathCall(context, nameof(MathHelper.Abs), ne);
+                    me = EmitUnaryMathCall(context, nameof(MathHelper.Abs), me);
                 }
 
                 Operand e = EmitSoftFloatCall(context, name, ne, me);
diff --git a/src/ARMeilleure/Instructions/InstEmitSimdCvt.cs b/src/ARMeilleure/Instructions/InstEmitSimdCvt.cs
index 3363a7c77..a5d4744f7 100644
--- a/src/ARMeilleure/Instructions/InstEmitSimdCvt.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdCvt.cs
@@ -333,7 +333,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitFcvt_s_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Floor), op1));
+                EmitFcvt_s_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Floor), op1));
             }
         }
 
@@ -349,7 +349,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitFcvt(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Floor), op1), signed: true, scalar: false);
+                EmitFcvt(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Floor), op1), signed: true, scalar: false);
             }
         }
 
@@ -365,7 +365,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitFcvt_u_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Floor), op1));
+                EmitFcvt_u_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Floor), op1));
             }
         }
 
@@ -538,7 +538,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitFcvt_s_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Ceiling), op1));
+                EmitFcvt_s_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), op1));
             }
         }
 
@@ -554,7 +554,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitFcvt_u_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Ceiling), op1));
+                EmitFcvt_u_Gp(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), op1));
             }
         }
 
diff --git a/src/ARMeilleure/Instructions/InstEmitSimdCvt32.cs b/src/ARMeilleure/Instructions/InstEmitSimdCvt32.cs
index 8eef6b14d..216726df9 100644
--- a/src/ARMeilleure/Instructions/InstEmitSimdCvt32.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdCvt32.cs
@@ -357,10 +357,10 @@ namespace ARMeilleure.Instructions
                         toConvert = EmitRoundMathCall(context, MidpointRounding.ToEven, toConvert);
                         break;
                     case 0b10: // Towards positive infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Ceiling), toConvert);
+                        toConvert = EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), toConvert);
                         break;
                     case 0b11: // Towards negative infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Floor), toConvert);
+                        toConvert = EmitUnaryMathCall(context, nameof(MathHelper.Floor), toConvert);
                         break;
                 }
 
@@ -494,10 +494,10 @@ namespace ARMeilleure.Instructions
                         toConvert = EmitRoundMathCall(context, MidpointRounding.ToEven, toConvert);
                         break;
                     case 0b10: // Towards positive infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Ceiling), toConvert);
+                        toConvert = EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), toConvert);
                         break;
                     case 0b11: // Towards negative infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Floor), toConvert);
+                        toConvert = EmitUnaryMathCall(context, nameof(MathHelper.Floor), toConvert);
                         break;
                 }
 
@@ -534,7 +534,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitVectorUnaryOpF32(context, (m) => EmitUnaryMathCall(context, nameof(Math.Floor), m));
+                EmitVectorUnaryOpF32(context, (m) => EmitUnaryMathCall(context, nameof(MathHelper.Floor), m));
             }
         }
 
@@ -574,7 +574,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitVectorUnaryOpF32(context, (m) => EmitUnaryMathCall(context, nameof(Math.Ceiling), m));
+                EmitVectorUnaryOpF32(context, (m) => EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), m));
             }
         }
 
@@ -613,7 +613,7 @@ namespace ARMeilleure.Instructions
             }
             else
             {
-                EmitScalarUnaryOpF32(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Truncate), op1));
+                EmitScalarUnaryOpF32(context, (op1) => EmitUnaryMathCall(context, nameof(MathHelper.Truncate), op1));
             }
         }
 
diff --git a/src/ARMeilleure/Instructions/InstEmitSimdHelper.cs b/src/ARMeilleure/Instructions/InstEmitSimdHelper.cs
index abd0d9acc..634e5c18b 100644
--- a/src/ARMeilleure/Instructions/InstEmitSimdHelper.cs
+++ b/src/ARMeilleure/Instructions/InstEmitSimdHelper.cs
@@ -460,8 +460,8 @@ namespace ARMeilleure.Instructions
             IOpCodeSimd op = (IOpCodeSimd)context.CurrOp;
 
             MethodInfo info = (op.Size & 1) == 0
-                ? typeof(MathF).GetMethod(name, new Type[] { typeof(float) })
-                : typeof(Math).GetMethod(name, new Type[] { typeof(double) });
+                ? typeof(MathHelperF).GetMethod(name, new Type[] { typeof(float) })
+                : typeof(MathHelper).GetMethod(name, new Type[] { typeof(double) });
 
             return context.Call(info, n);
         }
@@ -470,11 +470,11 @@ namespace ARMeilleure.Instructions
         {
             IOpCodeSimd op = (IOpCodeSimd)context.CurrOp;
 
-            string name = nameof(Math.Round);
+            string name = nameof(MathHelper.Round);
 
             MethodInfo info = (op.Size & 1) == 0
-                ? typeof(MathF).GetMethod(name, new Type[] { typeof(float), typeof(MidpointRounding) })
-                : typeof(Math).GetMethod(name, new Type[] { typeof(double), typeof(MidpointRounding) });
+                ? typeof(MathHelperF).GetMethod(name, new Type[] { typeof(float), typeof(int) })
+                : typeof(MathHelper).GetMethod(name, new Type[] { typeof(double), typeof(int) });
 
             return context.Call(info, n, Const((int)roundMode));
         }
@@ -510,16 +510,16 @@ namespace ARMeilleure.Instructions
 
             context.MarkLabel(lbl1);
             context.BranchIf(lbl2, rMode, rP, Comparison.NotEqual);
-            context.Copy(res, EmitUnaryMathCall(context, nameof(Math.Ceiling), op));
+            context.Copy(res, EmitUnaryMathCall(context, nameof(MathHelper.Ceiling), op));
             context.Branch(lblEnd);
 
             context.MarkLabel(lbl2);
             context.BranchIf(lbl3, rMode, rM, Comparison.NotEqual);
-            context.Copy(res, EmitUnaryMathCall(context, nameof(Math.Floor), op));
+            context.Copy(res, EmitUnaryMathCall(context, nameof(MathHelper.Floor), op));
             context.Branch(lblEnd);
 
             context.MarkLabel(lbl3);
-            context.Copy(res, EmitUnaryMathCall(context, nameof(Math.Truncate), op));
+            context.Copy(res, EmitUnaryMathCall(context, nameof(MathHelper.Truncate), op));
             context.Branch(lblEnd);
 
             context.MarkLabel(lblEnd);
diff --git a/src/ARMeilleure/Instructions/MathHelper.cs b/src/ARMeilleure/Instructions/MathHelper.cs
new file mode 100644
index 000000000..acf9a5028
--- /dev/null
+++ b/src/ARMeilleure/Instructions/MathHelper.cs
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ARMeilleure.Instructions
+{
+    static class MathHelper
+    {
+        [UnmanagedCallersOnly]
+        public static double Abs(double value)
+        {
+            return Math.Abs(value);
+        }
+
+        [UnmanagedCallersOnly]
+        public static double Ceiling(double value)
+        {
+            return Math.Ceiling(value);
+        }
+
+        [UnmanagedCallersOnly]
+        public static double Floor(double value)
+        {
+            return Math.Floor(value);
+        }
+
+        [UnmanagedCallersOnly]
+        public static double Round(double value, int mode)
+        {
+            return Math.Round(value, (MidpointRounding)mode);
+        }
+
+        [UnmanagedCallersOnly]
+        public static double Truncate(double value)
+        {
+            return Math.Truncate(value);
+        }
+    }
+
+    static class MathHelperF
+    {
+        [UnmanagedCallersOnly]
+        public static float Abs(float value)
+        {
+            return MathF.Abs(value);
+        }
+
+        [UnmanagedCallersOnly]
+        public static float Ceiling(float value)
+        {
+            return MathF.Ceiling(value);
+        }
+
+        [UnmanagedCallersOnly]
+        public static float Floor(float value)
+        {
+            return MathF.Floor(value);
+        }
+
+        [UnmanagedCallersOnly]
+        public static float Round(float value, int mode)
+        {
+            return MathF.Round(value, (MidpointRounding)mode);
+        }
+
+        [UnmanagedCallersOnly]
+        public static float Truncate(float value)
+        {
+            return MathF.Truncate(value);
+        }
+    }
+}
diff --git a/src/ARMeilleure/Instructions/NativeInterface.cs b/src/ARMeilleure/Instructions/NativeInterface.cs
index 0cd3754f7..9d6279613 100644
--- a/src/ARMeilleure/Instructions/NativeInterface.cs
+++ b/src/ARMeilleure/Instructions/NativeInterface.cs
@@ -2,6 +2,7 @@ using ARMeilleure.Memory;
 using ARMeilleure.State;
 using ARMeilleure.Translation;
 using System;
+using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Instructions
 {
@@ -34,6 +35,7 @@ namespace ARMeilleure.Instructions
             Context = null;
         }
 
+        [UnmanagedCallersOnly]
         public static void Break(ulong address, int imm)
         {
             Statistics.PauseTimer();
@@ -43,6 +45,7 @@ namespace ARMeilleure.Instructions
             Statistics.ResumeTimer();
         }
 
+        [UnmanagedCallersOnly]
         public static void SupervisorCall(ulong address, int imm)
         {
             Statistics.PauseTimer();
@@ -52,6 +55,7 @@ namespace ARMeilleure.Instructions
             Statistics.ResumeTimer();
         }
 
+        [UnmanagedCallersOnly]
         public static void Undefined(ulong address, int opCode)
         {
             Statistics.PauseTimer();
@@ -62,26 +66,31 @@ namespace ARMeilleure.Instructions
         }
 
         #region "System registers"
+        [UnmanagedCallersOnly]
         public static ulong GetCtrEl0()
         {
             return GetContext().CtrEl0;
         }
 
+        [UnmanagedCallersOnly]
         public static ulong GetDczidEl0()
         {
             return GetContext().DczidEl0;
         }
 
+        [UnmanagedCallersOnly]
         public static ulong GetCntfrqEl0()
         {
             return GetContext().CntfrqEl0;
         }
 
+        [UnmanagedCallersOnly]
         public static ulong GetCntpctEl0()
         {
             return GetContext().CntpctEl0;
         }
 
+        [UnmanagedCallersOnly]
         public static ulong GetCntvctEl0()
         {
             return GetContext().CntvctEl0;
@@ -89,26 +98,31 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Read"
+        [UnmanagedCallersOnly]
         public static byte ReadByte(ulong address)
         {
             return GetMemoryManager().ReadGuest<byte>(address);
         }
 
+        [UnmanagedCallersOnly]
         public static ushort ReadUInt16(ulong address)
         {
             return GetMemoryManager().ReadGuest<ushort>(address);
         }
 
+        [UnmanagedCallersOnly]
         public static uint ReadUInt32(ulong address)
         {
             return GetMemoryManager().ReadGuest<uint>(address);
         }
 
+        [UnmanagedCallersOnly]
         public static ulong ReadUInt64(ulong address)
         {
             return GetMemoryManager().ReadGuest<ulong>(address);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 ReadVector128(ulong address)
         {
             return GetMemoryManager().ReadGuest<V128>(address);
@@ -116,47 +130,56 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Write"
+        [UnmanagedCallersOnly]
         public static void WriteByte(ulong address, byte value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+        [UnmanagedCallersOnly]
         public static void WriteUInt16(ulong address, ushort value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+        [UnmanagedCallersOnly]
         public static void WriteUInt32(ulong address, uint value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+        [UnmanagedCallersOnly]
         public static void WriteUInt64(ulong address, ulong value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+        [UnmanagedCallersOnly]
         public static void WriteVector128(ulong address, V128 value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
         #endregion
 
+        [UnmanagedCallersOnly]
         public static void EnqueueForRejit(ulong address)
         {
             Context.Translator.EnqueueForRejit(address, GetContext().ExecutionMode);
         }
 
-        public static void SignalMemoryTracking(ulong address, ulong size, bool write)
+        [UnmanagedCallersOnly]
+        public static void SignalMemoryTracking(ulong address, ulong size, byte write)
         {
-            GetMemoryManager().SignalMemoryTracking(address, size, write);
+            GetMemoryManager().SignalMemoryTracking(address, size, write == 1);
         }
 
+        [UnmanagedCallersOnly]
         public static void ThrowInvalidMemoryAccess(ulong address)
         {
             throw new InvalidAccessException(address);
         }
 
+        [UnmanagedCallersOnly]
         public static ulong GetFunctionAddress(ulong address)
         {
             TranslatedFunction function = Context.Translator.GetOrTranslate(address, GetContext().ExecutionMode);
@@ -164,12 +187,14 @@ namespace ARMeilleure.Instructions
             return (ulong)function.FuncPointer.ToInt64();
         }
 
+        [UnmanagedCallersOnly]
         public static void InvalidateCacheLine(ulong address)
         {
             Context.Translator.InvalidateJitCacheRegion(address, InstEmit.DczSizeInBytes);
         }
 
-        public static bool CheckSynchronization()
+        [UnmanagedCallersOnly]
+        public static byte CheckSynchronization()
         {
             Statistics.PauseTimer();
 
@@ -179,7 +204,7 @@ namespace ARMeilleure.Instructions
 
             Statistics.ResumeTimer();
 
-            return context.Running;
+            return (byte)(context.Running ? 1 : 0);
         }
 
         public static ExecutionContext GetContext()
diff --git a/src/ARMeilleure/Instructions/SoftFallback.cs b/src/ARMeilleure/Instructions/SoftFallback.cs
index c4fe677bf..f34175b94 100644
--- a/src/ARMeilleure/Instructions/SoftFallback.cs
+++ b/src/ARMeilleure/Instructions/SoftFallback.cs
@@ -1,11 +1,13 @@
 using ARMeilleure.State;
 using System;
+using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Instructions
 {
     static class SoftFallback
     {
         #region "ShrImm64"
+        [UnmanagedCallersOnly]
         public static long SignedShrImm64(long value, long roundConst, int shift)
         {
             if (roundConst == 0L)
@@ -48,6 +50,7 @@ namespace ARMeilleure.Instructions
             }
         }
 
+        [UnmanagedCallersOnly]
         public static ulong UnsignedShrImm64(ulong value, long roundConst, int shift)
         {
             if (roundConst == 0L)
@@ -92,6 +95,7 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Saturation"
+        [UnmanagedCallersOnly]
         public static int SatF32ToS32(float value)
         {
             if (float.IsNaN(value))
@@ -103,6 +107,7 @@ namespace ARMeilleure.Instructions
                    value <= int.MinValue ? int.MinValue : (int)value;
         }
 
+        [UnmanagedCallersOnly]
         public static long SatF32ToS64(float value)
         {
             if (float.IsNaN(value))
@@ -114,6 +119,7 @@ namespace ARMeilleure.Instructions
                    value <= long.MinValue ? long.MinValue : (long)value;
         }
 
+        [UnmanagedCallersOnly]
         public static uint SatF32ToU32(float value)
         {
             if (float.IsNaN(value))
@@ -125,6 +131,7 @@ namespace ARMeilleure.Instructions
                    value <= uint.MinValue ? uint.MinValue : (uint)value;
         }
 
+        [UnmanagedCallersOnly]
         public static ulong SatF32ToU64(float value)
         {
             if (float.IsNaN(value))
@@ -136,6 +143,7 @@ namespace ARMeilleure.Instructions
                    value <= ulong.MinValue ? ulong.MinValue : (ulong)value;
         }
 
+        [UnmanagedCallersOnly]
         public static int SatF64ToS32(double value)
         {
             if (double.IsNaN(value))
@@ -147,6 +155,7 @@ namespace ARMeilleure.Instructions
                    value <= int.MinValue ? int.MinValue : (int)value;
         }
 
+        [UnmanagedCallersOnly]
         public static long SatF64ToS64(double value)
         {
             if (double.IsNaN(value))
@@ -158,6 +167,7 @@ namespace ARMeilleure.Instructions
                    value <= long.MinValue ? long.MinValue : (long)value;
         }
 
+        [UnmanagedCallersOnly]
         public static uint SatF64ToU32(double value)
         {
             if (double.IsNaN(value))
@@ -169,6 +179,7 @@ namespace ARMeilleure.Instructions
                    value <= uint.MinValue ? uint.MinValue : (uint)value;
         }
 
+        [UnmanagedCallersOnly]
         public static ulong SatF64ToU64(double value)
         {
             if (double.IsNaN(value))
@@ -182,6 +193,7 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Count"
+        [UnmanagedCallersOnly]
         public static ulong CountLeadingSigns(ulong value, int size) // size is 8, 16, 32 or 64 (SIMD&FP or Base Inst.).
         {
             value ^= value >> 1;
@@ -201,6 +213,7 @@ namespace ARMeilleure.Instructions
 
         private static ReadOnlySpan<byte> ClzNibbleTbl => new byte[] { 4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
 
+        [UnmanagedCallersOnly]
         public static ulong CountLeadingZeros(ulong value, int size) // size is 8, 16, 32 or 64 (SIMD&FP or Base Inst.).
         {
             if (value == 0ul)
@@ -224,41 +237,49 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Table"
+        [UnmanagedCallersOnly]
         public static V128 Tbl1(V128 vector, int bytes, V128 tb0)
         {
             return TblOrTbx(default, vector, bytes, tb0);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Tbl2(V128 vector, int bytes, V128 tb0, V128 tb1)
         {
             return TblOrTbx(default, vector, bytes, tb0, tb1);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Tbl3(V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2)
         {
             return TblOrTbx(default, vector, bytes, tb0, tb1, tb2);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Tbl4(V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2, V128 tb3)
         {
             return TblOrTbx(default, vector, bytes, tb0, tb1, tb2, tb3);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Tbx1(V128 dest, V128 vector, int bytes, V128 tb0)
         {
             return TblOrTbx(dest, vector, bytes, tb0);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Tbx2(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1)
         {
             return TblOrTbx(dest, vector, bytes, tb0, tb1);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Tbx3(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2)
         {
             return TblOrTbx(dest, vector, bytes, tb0, tb1, tb2);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Tbx4(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2, V128 tb3)
         {
             return TblOrTbx(dest, vector, bytes, tb0, tb1, tb2, tb3);
@@ -300,14 +321,22 @@ namespace ARMeilleure.Instructions
         private const uint Crc32RevPoly = 0xedb88320;
         private const uint Crc32cRevPoly = 0x82f63b78;
 
+        [UnmanagedCallersOnly]
         public static uint Crc32b(uint crc, byte value) => Crc32(crc, Crc32RevPoly, value);
+        [UnmanagedCallersOnly]
         public static uint Crc32h(uint crc, ushort value) => Crc32h(crc, Crc32RevPoly, value);
+        [UnmanagedCallersOnly]
         public static uint Crc32w(uint crc, uint value) => Crc32w(crc, Crc32RevPoly, value);
+        [UnmanagedCallersOnly]
         public static uint Crc32x(uint crc, ulong value) => Crc32x(crc, Crc32RevPoly, value);
 
+        [UnmanagedCallersOnly]
         public static uint Crc32cb(uint crc, byte value) => Crc32(crc, Crc32cRevPoly, value);
+        [UnmanagedCallersOnly]
         public static uint Crc32ch(uint crc, ushort value) => Crc32h(crc, Crc32cRevPoly, value);
+        [UnmanagedCallersOnly]
         public static uint Crc32cw(uint crc, uint value) => Crc32w(crc, Crc32cRevPoly, value);
+        [UnmanagedCallersOnly]
         public static uint Crc32cx(uint crc, ulong value) => Crc32x(crc, Crc32cRevPoly, value);
 
         private static uint Crc32h(uint crc, uint poly, ushort val)
@@ -358,21 +387,25 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Aes"
+        [UnmanagedCallersOnly]
         public static V128 Decrypt(V128 value, V128 roundKey)
         {
             return CryptoHelper.AesInvSubBytes(CryptoHelper.AesInvShiftRows(value ^ roundKey));
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Encrypt(V128 value, V128 roundKey)
         {
             return CryptoHelper.AesSubBytes(CryptoHelper.AesShiftRows(value ^ roundKey));
         }
 
+        [UnmanagedCallersOnly]
         public static V128 InverseMixColumns(V128 value)
         {
             return CryptoHelper.AesInvMixColumns(value);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 MixColumns(V128 value)
         {
             return CryptoHelper.AesMixColumns(value);
@@ -380,6 +413,7 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Sha1"
+        [UnmanagedCallersOnly]
         public static V128 HashChoose(V128 hash_abcd, uint hash_e, V128 wk)
         {
             for (int e = 0; e <= 3; e++)
@@ -400,11 +434,13 @@ namespace ARMeilleure.Instructions
             return hash_abcd;
         }
 
+        [UnmanagedCallersOnly]
         public static uint FixedRotate(uint hash_e)
         {
             return hash_e.Rol(30);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 HashMajority(V128 hash_abcd, uint hash_e, V128 wk)
         {
             for (int e = 0; e <= 3; e++)
@@ -425,6 +461,7 @@ namespace ARMeilleure.Instructions
             return hash_abcd;
         }
 
+        [UnmanagedCallersOnly]
         public static V128 HashParity(V128 hash_abcd, uint hash_e, V128 wk)
         {
             for (int e = 0; e <= 3; e++)
@@ -445,6 +482,7 @@ namespace ARMeilleure.Instructions
             return hash_abcd;
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Sha1SchedulePart1(V128 w0_3, V128 w4_7, V128 w8_11)
         {
             ulong t2 = w4_7.Extract<ulong>(0);
@@ -455,6 +493,7 @@ namespace ARMeilleure.Instructions
             return result ^ (w0_3 ^ w8_11);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Sha1SchedulePart2(V128 tw0_3, V128 w12_15)
         {
             V128 t = tw0_3 ^ (w12_15 >> 32);
@@ -499,16 +538,19 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Sha256"
+        [UnmanagedCallersOnly]
         public static V128 HashLower(V128 hash_abcd, V128 hash_efgh, V128 wk)
         {
             return Sha256Hash(hash_abcd, hash_efgh, wk, part1: true);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 HashUpper(V128 hash_abcd, V128 hash_efgh, V128 wk)
         {
             return Sha256Hash(hash_abcd, hash_efgh, wk, part1: false);
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Sha256SchedulePart1(V128 w0_3, V128 w4_7)
         {
             V128 result = new();
@@ -527,6 +569,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static V128 Sha256SchedulePart2(V128 w0_3, V128 w8_11, V128 w12_15)
         {
             V128 result = new();
@@ -628,6 +671,7 @@ namespace ARMeilleure.Instructions
         }
         #endregion
 
+        [UnmanagedCallersOnly]
         public static V128 PolynomialMult64_128(ulong op1, ulong op2)
         {
             V128 result = V128.Zero;
diff --git a/src/ARMeilleure/Instructions/SoftFloat.cs b/src/ARMeilleure/Instructions/SoftFloat.cs
index a67349e6e..a50160cca 100644
--- a/src/ARMeilleure/Instructions/SoftFloat.cs
+++ b/src/ARMeilleure/Instructions/SoftFloat.cs
@@ -1,6 +1,7 @@
 using ARMeilleure.State;
 using System;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Instructions
 {
@@ -312,6 +313,7 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat16_32
     {
+        [UnmanagedCallersOnly]
         public static float FPConvert(ushort valueBits)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -487,6 +489,7 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat16_64
     {
+        [UnmanagedCallersOnly]
         public static double FPConvert(ushort valueBits)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -662,6 +665,7 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat32_16
     {
+        [UnmanagedCallersOnly]
         public static ushort FPConvert(float value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -781,12 +785,19 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat32
     {
+        [UnmanagedCallersOnly]
         public static float FPAdd(float value1, float value2)
         {
-            return FPAddFpscr(value1, value2, false);
+            return FPAddFpscrImpl(value1, value2, false);
         }
 
-        public static float FPAddFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPAddFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPAddFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPAddFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -837,7 +848,8 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
-        public static int FPCompare(float value1, float value2, bool signalNaNs)
+        [UnmanagedCallersOnly]
+        public static int FPCompare(float value1, float value2, byte signalNaNs)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = context.Fpcr;
@@ -851,7 +863,7 @@ namespace ARMeilleure.Instructions
             {
                 result = 0b0011;
 
-                if (type1 == FPType.SNaN || type2 == FPType.SNaN || signalNaNs)
+                if (type1 == FPType.SNaN || type2 == FPType.SNaN || signalNaNs == 1)
                 {
                     SoftFloat.FPProcessException(FPException.InvalidOp, context, fpcr);
                 }
@@ -875,12 +887,13 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPCompareEQ(float value1, float value2)
         {
-            return FPCompareEQFpscr(value1, value2, false);
+            return FPCompareEQFpscrImpl(value1, value2, false);
         }
 
-        public static float FPCompareEQFpscr(float value1, float value2, bool standardFpscr)
+        private static float FPCompareEQFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -907,12 +920,25 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
-        public static float FPCompareGE(float value1, float value2)
+        [UnmanagedCallersOnly]
+        public static float FPCompareEQFpscr(float value1, float value2, byte standardFpscr)
         {
-            return FPCompareGEFpscr(value1, value2, false);
+            return FPCompareEQFpscrImpl(value1, value2, standardFpscr == 1);
         }
 
-        public static float FPCompareGEFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPCompareGE(float value1, float value2)
+        {
+            return FPCompareGEFpscrImpl(value1, value2, false);
+        }
+
+        [UnmanagedCallersOnly]
+        public static float FPCompareGEFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPCompareGEFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPCompareGEFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -936,12 +962,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPCompareGT(float value1, float value2)
         {
-            return FPCompareGTFpscr(value1, value2, false);
+            return FPCompareGTFpscrImpl(value1, value2, false);
         }
 
-        public static float FPCompareGTFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPCompareGTFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPCompareGTFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPCompareGTFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -965,26 +998,31 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPCompareLE(float value1, float value2)
         {
-            return FPCompareGE(value2, value1);
+            return FPCompareGEFpscrImpl(value2, value1, false);
         }
 
+        [UnmanagedCallersOnly]
         public static float FPCompareLT(float value1, float value2)
         {
-            return FPCompareGT(value2, value1);
+            return FPCompareGTFpscrImpl(value2, value1, false);
         }
 
-        public static float FPCompareLEFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPCompareLEFpscr(float value1, float value2, byte standardFpscr)
         {
-            return FPCompareGEFpscr(value2, value1, standardFpscr);
+            return FPCompareGEFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
-        public static float FPCompareLTFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPCompareLTFpscr(float value1, float value2, byte standardFpscr)
         {
-            return FPCompareGTFpscr(value2, value1, standardFpscr);
+            return FPCompareGEFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
+        [UnmanagedCallersOnly]
         public static float FPDiv(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1037,12 +1075,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPMax(float value1, float value2)
         {
-            return FPMaxFpscr(value1, value2, false);
+            return FPMaxFpscrImpl(value1, value2, false);
         }
 
-        public static float FPMaxFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPMaxFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPMaxFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPMaxFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1103,12 +1148,13 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPMaxNum(float value1, float value2)
         {
-            return FPMaxNumFpscr(value1, value2, false);
+            return FPMaxNumFpscrImpl(value1, value2, false);
         }
 
-        public static float FPMaxNumFpscr(float value1, float value2, bool standardFpscr)
+        private static float FPMaxNumFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1125,15 +1171,28 @@ namespace ARMeilleure.Instructions
                 value2 = FPInfinity(true);
             }
 
-            return FPMaxFpscr(value1, value2, standardFpscr);
+            return FPMaxFpscrImpl(value1, value2, standardFpscr);
         }
 
+        [UnmanagedCallersOnly]
+        public static float FPMaxNumFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPMaxNumFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        [UnmanagedCallersOnly]
         public static float FPMin(float value1, float value2)
         {
-            return FPMinFpscr(value1, value2, false);
+            return FPMinFpscrImpl(value1, value2, false);
         }
 
-        public static float FPMinFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPMinFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPMinFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPMinFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1194,12 +1253,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPMinNum(float value1, float value2)
         {
-            return FPMinNumFpscr(value1, value2, false);
+            return FPMinNumFpscrImpl(value1, value2, false);
         }
 
-        public static float FPMinNumFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPMinNumFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPMinNumFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPMinNumFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1216,15 +1282,22 @@ namespace ARMeilleure.Instructions
                 value2 = FPInfinity(false);
             }
 
-            return FPMinFpscr(value1, value2, standardFpscr);
+            return FPMinFpscrImpl(value1, value2, standardFpscr);
         }
 
+        [UnmanagedCallersOnly]
         public static float FPMul(float value1, float value2)
         {
-            return FPMulFpscr(value1, value2, false);
+            return FPMulFpscrImpl(value1, value2, false);
         }
 
-        public static float FPMulFpscr(float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPMulFpscr(float value1, float value2, byte standardFpscr)
+        {
+            return FPMulFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPMulFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1271,12 +1344,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPMulAdd(float valueA, float value1, float value2)
         {
-            return FPMulAddFpscr(valueA, value1, value2, false);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
-        public static float FPMulAddFpscr(float valueA, float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPMulAddFpscr(float valueA, float value1, float value2, byte standardFpscr)
+        {
+            return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
+        }
+
+        private static float FPMulAddFpscrImpl(float valueA, float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1342,20 +1422,23 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPMulSub(float valueA, float value1, float value2)
         {
             value1 = value1.FPNeg();
 
-            return FPMulAdd(valueA, value1, value2);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
-        public static float FPMulSubFpscr(float valueA, float value1, float value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPMulSubFpscr(float valueA, float value1, float value2, byte standardFpscr)
         {
             value1 = value1.FPNeg();
 
-            return FPMulAddFpscr(valueA, value1, value2, standardFpscr);
+            return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
         }
 
+        [UnmanagedCallersOnly]
         public static float FPMulX(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1401,27 +1484,36 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPNegMulAdd(float valueA, float value1, float value2)
         {
             valueA = valueA.FPNeg();
             value1 = value1.FPNeg();
 
-            return FPMulAdd(valueA, value1, value2);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+        [UnmanagedCallersOnly]
         public static float FPNegMulSub(float valueA, float value1, float value2)
         {
             valueA = valueA.FPNeg();
 
-            return FPMulAdd(valueA, value1, value2);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+        [UnmanagedCallersOnly]
         public static float FPRecipEstimate(float value)
         {
-            return FPRecipEstimateFpscr(value, false);
+            return FPRecipEstimateFpscrImpl(value, false);
         }
 
-        public static float FPRecipEstimateFpscr(float value, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPRecipEstimateFpscr(float value, byte standardFpscr)
+        {
+            return FPRecipEstimateFpscrImpl(value, standardFpscr == 1);
+        }
+
+        private static float FPRecipEstimateFpscrImpl(float value, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1508,6 +1600,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPRecipStep(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1533,15 +1626,16 @@ namespace ARMeilleure.Instructions
                 }
                 else
                 {
-                    product = FPMulFpscr(value1, value2, true);
+                    product = FPMulFpscrImpl(value1, value2, true);
                 }
 
-                result = FPSubFpscr(FPTwo(false), product, true);
+                result = FPSubFpscrImpl(FPTwo(false), product, true);
             }
 
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPRecipStepFused(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1585,6 +1679,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPRecpX(float value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1610,12 +1705,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPRSqrtEstimate(float value)
         {
-            return FPRSqrtEstimateFpscr(value, false);
+            return FPRSqrtEstimateFpscrImpl(value, false);
         }
 
-        public static float FPRSqrtEstimateFpscr(float value, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static float FPRSqrtEstimateFpscr(float value, byte standardFpscr)
+        {
+            return FPRSqrtEstimateFpscrImpl(value, standardFpscr == 1);
+        }
+
+        private static float FPRSqrtEstimateFpscrImpl(float value, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -1729,6 +1831,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPRSqrtStep(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1754,7 +1857,7 @@ namespace ARMeilleure.Instructions
                 }
                 else
                 {
-                    product = FPMulFpscr(value1, value2, true);
+                    product = FPMulFpscrImpl(value1, value2, true);
                 }
 
                 result = FPHalvedSub(FPThree(false), product, context, fpcr);
@@ -1763,6 +1866,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPRSqrtStepFused(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1806,6 +1910,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPSqrt(float value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1848,12 +1953,13 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static float FPSub(float value1, float value2)
         {
-            return FPSubFpscr(value1, value2, false);
+            return FPSubFpscrImpl(value1, value2, false);
         }
 
-        public static float FPSubFpscr(float value1, float value2, bool standardFpscr)
+        private static float FPSubFpscrImpl(float value1, float value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2094,6 +2200,7 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat64_16
     {
+        [UnmanagedCallersOnly]
         public static ushort FPConvert(double value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -2213,12 +2320,19 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat64
     {
+        [UnmanagedCallersOnly]
         public static double FPAdd(double value1, double value2)
         {
-            return FPAddFpscr(value1, value2, false);
+            return FPAddFpscrImpl(value1, value2, false);
         }
 
-        public static double FPAddFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPAddFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPAddFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPAddFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2269,7 +2383,8 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
-        public static int FPCompare(double value1, double value2, bool signalNaNs)
+        [UnmanagedCallersOnly]
+        public static int FPCompare(double value1, double value2, byte signalNaNs)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = context.Fpcr;
@@ -2283,7 +2398,7 @@ namespace ARMeilleure.Instructions
             {
                 result = 0b0011;
 
-                if (type1 == FPType.SNaN || type2 == FPType.SNaN || signalNaNs)
+                if (type1 == FPType.SNaN || type2 == FPType.SNaN || signalNaNs == 1)
                 {
                     SoftFloat.FPProcessException(FPException.InvalidOp, context, fpcr);
                 }
@@ -2307,12 +2422,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPCompareEQ(double value1, double value2)
         {
-            return FPCompareEQFpscr(value1, value2, false);
+            return FPCompareEQFpscrImpl(value1, value2, false);
         }
 
-        public static double FPCompareEQFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPCompareEQFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPCompareEQFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPCompareEQFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2339,12 +2461,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPCompareGE(double value1, double value2)
         {
-            return FPCompareGEFpscr(value1, value2, false);
+            return FPCompareGEFpscrImpl(value1, value2, false);
         }
 
-        public static double FPCompareGEFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPCompareGEFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPCompareGEFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPCompareGEFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2368,12 +2497,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPCompareGT(double value1, double value2)
         {
-            return FPCompareGTFpscr(value1, value2, false);
+            return FPCompareGTFpscrImpl(value1, value2, false);
         }
 
-        public static double FPCompareGTFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPCompareGTFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPCompareGTFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPCompareGTFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2397,26 +2533,31 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPCompareLE(double value1, double value2)
         {
-            return FPCompareGE(value2, value1);
+            return FPCompareGEFpscrImpl(value2, value1, false);
         }
 
+        [UnmanagedCallersOnly]
         public static double FPCompareLT(double value1, double value2)
         {
-            return FPCompareGT(value2, value1);
+            return FPCompareGTFpscrImpl(value2, value1, false);
         }
 
-        public static double FPCompareLEFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPCompareLEFpscr(double value1, double value2, byte standardFpscr)
         {
-            return FPCompareGEFpscr(value2, value1, standardFpscr);
+            return FPCompareGEFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
-        public static double FPCompareLTFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPCompareLTFpscr(double value1, double value2, byte standardFpscr)
         {
-            return FPCompareGTFpscr(value2, value1, standardFpscr);
+            return FPCompareGTFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
+        [UnmanagedCallersOnly]
         public static double FPDiv(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -2469,12 +2610,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMax(double value1, double value2)
         {
-            return FPMaxFpscr(value1, value2, false);
+            return FPMaxFpscrImpl(value1, value2, false);
         }
 
-        public static double FPMaxFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPMaxFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPMaxFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPMaxFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2535,12 +2683,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMaxNum(double value1, double value2)
         {
-            return FPMaxNumFpscr(value1, value2, false);
+            return FPMaxNumFpscrImpl(value1, value2, false);
         }
 
-        public static double FPMaxNumFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPMaxNumFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPMaxNumFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPMaxNumFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2557,15 +2712,22 @@ namespace ARMeilleure.Instructions
                 value2 = FPInfinity(true);
             }
 
-            return FPMaxFpscr(value1, value2, standardFpscr);
+            return FPMaxFpscrImpl(value1, value2, standardFpscr);
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMin(double value1, double value2)
         {
-            return FPMinFpscr(value1, value2, false);
+            return FPMinFpscrImpl(value1, value2, false);
         }
 
-        public static double FPMinFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPMinFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPMinFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPMinFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2626,12 +2788,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMinNum(double value1, double value2)
         {
-            return FPMinNumFpscr(value1, value2, false);
+            return FPMinNumFpscrImpl(value1, value2, false);
         }
 
-        public static double FPMinNumFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPMinNumFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPMinNumFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPMinNumFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2648,15 +2817,22 @@ namespace ARMeilleure.Instructions
                 value2 = FPInfinity(false);
             }
 
-            return FPMinFpscr(value1, value2, standardFpscr);
+            return FPMinFpscrImpl(value1, value2, standardFpscr);
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMul(double value1, double value2)
         {
-            return FPMulFpscr(value1, value2, false);
+            return FPMulFpscrImpl(value1, value2, false);
         }
 
-        public static double FPMulFpscr(double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPMulFpscr(double value1, double value2, byte standardFpscr)
+        {
+            return FPMulFpscrImpl(value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPMulFpscrImpl(double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2703,12 +2879,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMulAdd(double valueA, double value1, double value2)
         {
-            return FPMulAddFpscr(valueA, value1, value2, false);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
-        public static double FPMulAddFpscr(double valueA, double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPMulAddFpscr(double valueA, double value1, double value2, byte standardFpscr)
+        {
+            return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
+        }
+
+        private static double FPMulAddFpscrImpl(double valueA, double value1, double value2, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2774,20 +2957,23 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMulSub(double valueA, double value1, double value2)
         {
             value1 = value1.FPNeg();
 
-            return FPMulAdd(valueA, value1, value2);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
-        public static double FPMulSubFpscr(double valueA, double value1, double value2, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPMulSubFpscr(double valueA, double value1, double value2, byte standardFpscr)
         {
             value1 = value1.FPNeg();
 
-            return FPMulAddFpscr(valueA, value1, value2, standardFpscr);
+            return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
         }
 
+        [UnmanagedCallersOnly]
         public static double FPMulX(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -2833,27 +3019,36 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPNegMulAdd(double valueA, double value1, double value2)
         {
             valueA = valueA.FPNeg();
             value1 = value1.FPNeg();
 
-            return FPMulAdd(valueA, value1, value2);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+        [UnmanagedCallersOnly]
         public static double FPNegMulSub(double valueA, double value1, double value2)
         {
             valueA = valueA.FPNeg();
 
-            return FPMulAdd(valueA, value1, value2);
+            return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+        [UnmanagedCallersOnly]
         public static double FPRecipEstimate(double value)
         {
-            return FPRecipEstimateFpscr(value, false);
+            return FPRecipEstimateFpscrImpl(value, false);
         }
 
-        public static double FPRecipEstimateFpscr(double value, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPRecipEstimateFpscr(double value, byte standardFpscr)
+        {
+            return FPRecipEstimateFpscrImpl(value, standardFpscr == 1);
+        }
+
+        private static double FPRecipEstimateFpscrImpl(double value, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -2940,6 +3135,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPRecipStep(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -2965,7 +3161,7 @@ namespace ARMeilleure.Instructions
                 }
                 else
                 {
-                    product = FPMulFpscr(value1, value2, true);
+                    product = FPMulFpscrImpl(value1, value2, true);
                 }
 
                 result = FPSubFpscr(FPTwo(false), product, true);
@@ -2974,6 +3170,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPRecipStepFused(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3017,6 +3214,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPRecpX(double value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3042,12 +3240,19 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPRSqrtEstimate(double value)
         {
-            return FPRSqrtEstimateFpscr(value, false);
+            return FPRSqrtEstimateFpscrImpl(value, false);
         }
 
-        public static double FPRSqrtEstimateFpscr(double value, bool standardFpscr)
+        [UnmanagedCallersOnly]
+        public static double FPRSqrtEstimateFpscr(double value, byte standardFpscr)
+        {
+            return FPRSqrtEstimateFpscrImpl(value, standardFpscr == 1);
+        }
+
+        private static double FPRSqrtEstimateFpscrImpl(double value, bool standardFpscr)
         {
             ExecutionContext context = NativeInterface.GetContext();
             FPCR fpcr = standardFpscr ? context.StandardFpcrValue : context.Fpcr;
@@ -3161,6 +3366,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPRSqrtStep(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3186,7 +3392,7 @@ namespace ARMeilleure.Instructions
                 }
                 else
                 {
-                    product = FPMulFpscr(value1, value2, true);
+                    product = FPMulFpscrImpl(value1, value2, true);
                 }
 
                 result = FPHalvedSub(FPThree(false), product, context, fpcr);
@@ -3195,6 +3401,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPRSqrtStepFused(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3238,6 +3445,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPSqrt(double value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3280,6 +3488,7 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+        [UnmanagedCallersOnly]
         public static double FPSub(double value1, double value2)
         {
             return FPSubFpscr(value1, value2, false);
diff --git a/src/ARMeilleure/Translation/DelegateInfo.cs b/src/ARMeilleure/Translation/DelegateInfo.cs
index 706625437..e4e097a04 100644
--- a/src/ARMeilleure/Translation/DelegateInfo.cs
+++ b/src/ARMeilleure/Translation/DelegateInfo.cs
@@ -4,15 +4,10 @@ namespace ARMeilleure.Translation
 {
     class DelegateInfo
     {
-#pragma warning disable IDE0052 // Remove unread private member
-        private readonly Delegate _dlg; // Ensure that this delegate will not be garbage collected.
-#pragma warning restore IDE0052
-
         public IntPtr FuncPtr { get; }
 
-        public DelegateInfo(Delegate dlg, IntPtr funcPtr)
+        public DelegateInfo(IntPtr funcPtr)
         {
-            _dlg = dlg;
             FuncPtr = funcPtr;
         }
     }
diff --git a/src/ARMeilleure/Translation/Delegates.cs b/src/ARMeilleure/Translation/Delegates.cs
index 66412b8e6..9877c57b1 100644
--- a/src/ARMeilleure/Translation/Delegates.cs
+++ b/src/ARMeilleure/Translation/Delegates.cs
@@ -1,9 +1,7 @@
 using ARMeilleure.Instructions;
-using ARMeilleure.State;
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Translation
 {
@@ -35,20 +33,6 @@ namespace ARMeilleure.Translation
             return _delegates.Values[index].FuncPtr; // O(1).
         }
 
-        public static IntPtr GetDelegateFuncPtr(MethodInfo info)
-        {
-            ArgumentNullException.ThrowIfNull(info);
-
-            string key = GetKey(info);
-
-            if (!_delegates.TryGetValue(key, out DelegateInfo dlgInfo)) // O(log(n)).
-            {
-                throw new KeyNotFoundException($"({nameof(key)} = {key})");
-            }
-
-            return dlgInfo.FuncPtr;
-        }
-
         public static int GetDelegateIndex(MethodInfo info)
         {
             ArgumentNullException.ThrowIfNull(info);
@@ -65,11 +49,11 @@ namespace ARMeilleure.Translation
             return index;
         }
 
-        private static void SetDelegateInfo(Delegate dlg, IntPtr funcPtr)
+        private static void SetDelegateInfo(MethodInfo method)
         {
-            string key = GetKey(dlg.Method);
+            string key = GetKey(method);
 
-            _delegates.Add(key, new DelegateInfo(dlg, funcPtr)); // ArgumentException (key).
+            _delegates.Add(key, new DelegateInfo(method.MethodHandle.GetFunctionPointer())); // ArgumentException (key).
         }
 
         private static string GetKey(MethodInfo info)
@@ -79,532 +63,183 @@ namespace ARMeilleure.Translation
 
         private static readonly SortedList<string, DelegateInfo> _delegates;
 
-        static Delegates()
+        unsafe static Delegates()
         {
             _delegates = new SortedList<string, DelegateInfo>();
 
-            var dlgMathAbs = new MathAbs(Math.Abs);
-            var dlgMathCeiling = new MathCeiling(Math.Ceiling);
-            var dlgMathFloor = new MathFloor(Math.Floor);
-            var dlgMathRound = new MathRound(Math.Round);
-            var dlgMathTruncate = new MathTruncate(Math.Truncate);
+            SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Abs)));
+            SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Ceiling)));
+            SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Floor)));
+            SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Round)));
+            SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Truncate)));
 
-            var dlgMathFAbs = new MathFAbs(MathF.Abs);
-            var dlgMathFCeiling = new MathFCeiling(MathF.Ceiling);
-            var dlgMathFFloor = new MathFFloor(MathF.Floor);
-            var dlgMathFRound = new MathFRound(MathF.Round);
-            var dlgMathFTruncate = new MathFTruncate(MathF.Truncate);
+            SetDelegateInfo(typeof(MathHelperF).GetMethod(nameof(MathHelperF.Abs)));
+            SetDelegateInfo(typeof(MathHelperF).GetMethod(nameof(MathHelperF.Ceiling)));
+            SetDelegateInfo(typeof(MathHelperF).GetMethod(nameof(MathHelperF.Floor)));
+            SetDelegateInfo(typeof(MathHelperF).GetMethod(nameof(MathHelperF.Round)));
+            SetDelegateInfo(typeof(MathHelperF).GetMethod(nameof(MathHelperF.Truncate)));
 
-            var dlgNativeInterfaceBreak = new NativeInterfaceBreak(NativeInterface.Break);
-            var dlgNativeInterfaceCheckSynchronization = new NativeInterfaceCheckSynchronization(NativeInterface.CheckSynchronization);
-            var dlgNativeInterfaceEnqueueForRejit = new NativeInterfaceEnqueueForRejit(NativeInterface.EnqueueForRejit);
-            var dlgNativeInterfaceGetCntfrqEl0 = new NativeInterfaceGetCntfrqEl0(NativeInterface.GetCntfrqEl0);
-            var dlgNativeInterfaceGetCntpctEl0 = new NativeInterfaceGetCntpctEl0(NativeInterface.GetCntpctEl0);
-            var dlgNativeInterfaceGetCntvctEl0 = new NativeInterfaceGetCntvctEl0(NativeInterface.GetCntvctEl0);
-            var dlgNativeInterfaceGetCtrEl0 = new NativeInterfaceGetCtrEl0(NativeInterface.GetCtrEl0);
-            var dlgNativeInterfaceGetDczidEl0 = new NativeInterfaceGetDczidEl0(NativeInterface.GetDczidEl0);
-            var dlgNativeInterfaceGetFunctionAddress = new NativeInterfaceGetFunctionAddress(NativeInterface.GetFunctionAddress);
-            var dlgNativeInterfaceInvalidateCacheLine = new NativeInterfaceInvalidateCacheLine(NativeInterface.InvalidateCacheLine);
-            var dlgNativeInterfaceReadByte = new NativeInterfaceReadByte(NativeInterface.ReadByte);
-            var dlgNativeInterfaceReadUInt16 = new NativeInterfaceReadUInt16(NativeInterface.ReadUInt16);
-            var dlgNativeInterfaceReadUInt32 = new NativeInterfaceReadUInt32(NativeInterface.ReadUInt32);
-            var dlgNativeInterfaceReadUInt64 = new NativeInterfaceReadUInt64(NativeInterface.ReadUInt64);
-            var dlgNativeInterfaceReadVector128 = new NativeInterfaceReadVector128(NativeInterface.ReadVector128);
-            var dlgNativeInterfaceSignalMemoryTracking = new NativeInterfaceSignalMemoryTracking(NativeInterface.SignalMemoryTracking);
-            var dlgNativeInterfaceSupervisorCall = new NativeInterfaceSupervisorCall(NativeInterface.SupervisorCall);
-            var dlgNativeInterfaceThrowInvalidMemoryAccess = new NativeInterfaceThrowInvalidMemoryAccess(NativeInterface.ThrowInvalidMemoryAccess);
-            var dlgNativeInterfaceUndefined = new NativeInterfaceUndefined(NativeInterface.Undefined);
-            var dlgNativeInterfaceWriteByte = new NativeInterfaceWriteByte(NativeInterface.WriteByte);
-            var dlgNativeInterfaceWriteUInt16 = new NativeInterfaceWriteUInt16(NativeInterface.WriteUInt16);
-            var dlgNativeInterfaceWriteUInt32 = new NativeInterfaceWriteUInt32(NativeInterface.WriteUInt32);
-            var dlgNativeInterfaceWriteUInt64 = new NativeInterfaceWriteUInt64(NativeInterface.WriteUInt64);
-            var dlgNativeInterfaceWriteVector128 = new NativeInterfaceWriteVector128(NativeInterface.WriteVector128);
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.Break)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.CheckSynchronization)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.EnqueueForRejit)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntfrqEl0)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntpctEl0)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntvctEl0)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCtrEl0)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetDczidEl0)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.InvalidateCacheLine)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadByte)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt16)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt32)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt64)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadVector128)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SignalMemoryTracking)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SupervisorCall)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ThrowInvalidMemoryAccess)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.Undefined)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteByte)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt16)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt32)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt64)));
+            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteVector128)));
 
-            var dlgSoftFallbackCountLeadingSigns = new SoftFallbackCountLeadingSigns(SoftFallback.CountLeadingSigns);
-            var dlgSoftFallbackCountLeadingZeros = new SoftFallbackCountLeadingZeros(SoftFallback.CountLeadingZeros);
-            var dlgSoftFallbackCrc32b = new SoftFallbackCrc32b(SoftFallback.Crc32b);
-            var dlgSoftFallbackCrc32cb = new SoftFallbackCrc32cb(SoftFallback.Crc32cb);
-            var dlgSoftFallbackCrc32ch = new SoftFallbackCrc32ch(SoftFallback.Crc32ch);
-            var dlgSoftFallbackCrc32cw = new SoftFallbackCrc32cw(SoftFallback.Crc32cw);
-            var dlgSoftFallbackCrc32cx = new SoftFallbackCrc32cx(SoftFallback.Crc32cx);
-            var dlgSoftFallbackCrc32h = new SoftFallbackCrc32h(SoftFallback.Crc32h);
-            var dlgSoftFallbackCrc32w = new SoftFallbackCrc32w(SoftFallback.Crc32w);
-            var dlgSoftFallbackCrc32x = new SoftFallbackCrc32x(SoftFallback.Crc32x);
-            var dlgSoftFallbackDecrypt = new SoftFallbackDecrypt(SoftFallback.Decrypt);
-            var dlgSoftFallbackEncrypt = new SoftFallbackEncrypt(SoftFallback.Encrypt);
-            var dlgSoftFallbackFixedRotate = new SoftFallbackFixedRotate(SoftFallback.FixedRotate);
-            var dlgSoftFallbackHashChoose = new SoftFallbackHashChoose(SoftFallback.HashChoose);
-            var dlgSoftFallbackHashLower = new SoftFallbackHashLower(SoftFallback.HashLower);
-            var dlgSoftFallbackHashMajority = new SoftFallbackHashMajority(SoftFallback.HashMajority);
-            var dlgSoftFallbackHashParity = new SoftFallbackHashParity(SoftFallback.HashParity);
-            var dlgSoftFallbackHashUpper = new SoftFallbackHashUpper(SoftFallback.HashUpper);
-            var dlgSoftFallbackInverseMixColumns = new SoftFallbackInverseMixColumns(SoftFallback.InverseMixColumns);
-            var dlgSoftFallbackMixColumns = new SoftFallbackMixColumns(SoftFallback.MixColumns);
-            var dlgSoftFallbackPolynomialMult64_128 = new SoftFallbackPolynomialMult64_128(SoftFallback.PolynomialMult64_128);
-            var dlgSoftFallbackSatF32ToS32 = new SoftFallbackSatF32ToS32(SoftFallback.SatF32ToS32);
-            var dlgSoftFallbackSatF32ToS64 = new SoftFallbackSatF32ToS64(SoftFallback.SatF32ToS64);
-            var dlgSoftFallbackSatF32ToU32 = new SoftFallbackSatF32ToU32(SoftFallback.SatF32ToU32);
-            var dlgSoftFallbackSatF32ToU64 = new SoftFallbackSatF32ToU64(SoftFallback.SatF32ToU64);
-            var dlgSoftFallbackSatF64ToS32 = new SoftFallbackSatF64ToS32(SoftFallback.SatF64ToS32);
-            var dlgSoftFallbackSatF64ToS64 = new SoftFallbackSatF64ToS64(SoftFallback.SatF64ToS64);
-            var dlgSoftFallbackSatF64ToU32 = new SoftFallbackSatF64ToU32(SoftFallback.SatF64ToU32);
-            var dlgSoftFallbackSatF64ToU64 = new SoftFallbackSatF64ToU64(SoftFallback.SatF64ToU64);
-            var dlgSoftFallbackSha1SchedulePart1 = new SoftFallbackSha1SchedulePart1(SoftFallback.Sha1SchedulePart1);
-            var dlgSoftFallbackSha1SchedulePart2 = new SoftFallbackSha1SchedulePart2(SoftFallback.Sha1SchedulePart2);
-            var dlgSoftFallbackSha256SchedulePart1 = new SoftFallbackSha256SchedulePart1(SoftFallback.Sha256SchedulePart1);
-            var dlgSoftFallbackSha256SchedulePart2 = new SoftFallbackSha256SchedulePart2(SoftFallback.Sha256SchedulePart2);
-            var dlgSoftFallbackSignedShrImm64 = new SoftFallbackSignedShrImm64(SoftFallback.SignedShrImm64);
-            var dlgSoftFallbackTbl1 = new SoftFallbackTbl1(SoftFallback.Tbl1);
-            var dlgSoftFallbackTbl2 = new SoftFallbackTbl2(SoftFallback.Tbl2);
-            var dlgSoftFallbackTbl3 = new SoftFallbackTbl3(SoftFallback.Tbl3);
-            var dlgSoftFallbackTbl4 = new SoftFallbackTbl4(SoftFallback.Tbl4);
-            var dlgSoftFallbackTbx1 = new SoftFallbackTbx1(SoftFallback.Tbx1);
-            var dlgSoftFallbackTbx2 = new SoftFallbackTbx2(SoftFallback.Tbx2);
-            var dlgSoftFallbackTbx3 = new SoftFallbackTbx3(SoftFallback.Tbx3);
-            var dlgSoftFallbackTbx4 = new SoftFallbackTbx4(SoftFallback.Tbx4);
-            var dlgSoftFallbackUnsignedShrImm64 = new SoftFallbackUnsignedShrImm64(SoftFallback.UnsignedShrImm64);
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.CountLeadingSigns)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.CountLeadingZeros)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32b)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cb)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32ch)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cw)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cx)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32h)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32w)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32x)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Decrypt)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Encrypt)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.FixedRotate)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashChoose)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashLower)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashMajority)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashParity)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashUpper)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.InverseMixColumns)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.MixColumns)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.PolynomialMult64_128)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToS32)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToS64)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToU32)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToU64)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToS32)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToS64)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToU32)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToU64)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha1SchedulePart1)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha1SchedulePart2)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha256SchedulePart1)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha256SchedulePart2)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SignedShrImm64)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl1)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl2)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl3)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl4)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx1)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx2)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx3)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx4)));
+            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.UnsignedShrImm64)));
 
-            var dlgSoftFloat16_32FPConvert = new SoftFloat16_32FPConvert(SoftFloat16_32.FPConvert);
-            var dlgSoftFloat16_64FPConvert = new SoftFloat16_64FPConvert(SoftFloat16_64.FPConvert);
+            SetDelegateInfo(typeof(SoftFloat16_32).GetMethod(nameof(SoftFloat16_32.FPConvert)));
+            SetDelegateInfo(typeof(SoftFloat16_64).GetMethod(nameof(SoftFloat16_64.FPConvert)));
 
-            var dlgSoftFloat32FPAdd = new SoftFloat32FPAdd(SoftFloat32.FPAdd);
-            var dlgSoftFloat32FPAddFpscr = new SoftFloat32FPAddFpscr(SoftFloat32.FPAddFpscr); // A32 only.
-            var dlgSoftFloat32FPCompare = new SoftFloat32FPCompare(SoftFloat32.FPCompare);
-            var dlgSoftFloat32FPCompareEQ = new SoftFloat32FPCompareEQ(SoftFloat32.FPCompareEQ);
-            var dlgSoftFloat32FPCompareEQFpscr = new SoftFloat32FPCompareEQFpscr(SoftFloat32.FPCompareEQFpscr); // A32 only.
-            var dlgSoftFloat32FPCompareGE = new SoftFloat32FPCompareGE(SoftFloat32.FPCompareGE);
-            var dlgSoftFloat32FPCompareGEFpscr = new SoftFloat32FPCompareGEFpscr(SoftFloat32.FPCompareGEFpscr); // A32 only.
-            var dlgSoftFloat32FPCompareGT = new SoftFloat32FPCompareGT(SoftFloat32.FPCompareGT);
-            var dlgSoftFloat32FPCompareGTFpscr = new SoftFloat32FPCompareGTFpscr(SoftFloat32.FPCompareGTFpscr); // A32 only.
-            var dlgSoftFloat32FPCompareLE = new SoftFloat32FPCompareLE(SoftFloat32.FPCompareLE);
-            var dlgSoftFloat32FPCompareLEFpscr = new SoftFloat32FPCompareLEFpscr(SoftFloat32.FPCompareLEFpscr); // A32 only.
-            var dlgSoftFloat32FPCompareLT = new SoftFloat32FPCompareLT(SoftFloat32.FPCompareLT);
-            var dlgSoftFloat32FPCompareLTFpscr = new SoftFloat32FPCompareLTFpscr(SoftFloat32.FPCompareLTFpscr); // A32 only.
-            var dlgSoftFloat32FPDiv = new SoftFloat32FPDiv(SoftFloat32.FPDiv);
-            var dlgSoftFloat32FPMax = new SoftFloat32FPMax(SoftFloat32.FPMax);
-            var dlgSoftFloat32FPMaxFpscr = new SoftFloat32FPMaxFpscr(SoftFloat32.FPMaxFpscr); // A32 only.
-            var dlgSoftFloat32FPMaxNum = new SoftFloat32FPMaxNum(SoftFloat32.FPMaxNum);
-            var dlgSoftFloat32FPMaxNumFpscr = new SoftFloat32FPMaxNumFpscr(SoftFloat32.FPMaxNumFpscr); // A32 only.
-            var dlgSoftFloat32FPMin = new SoftFloat32FPMin(SoftFloat32.FPMin);
-            var dlgSoftFloat32FPMinFpscr = new SoftFloat32FPMinFpscr(SoftFloat32.FPMinFpscr); // A32 only.
-            var dlgSoftFloat32FPMinNum = new SoftFloat32FPMinNum(SoftFloat32.FPMinNum);
-            var dlgSoftFloat32FPMinNumFpscr = new SoftFloat32FPMinNumFpscr(SoftFloat32.FPMinNumFpscr); // A32 only.
-            var dlgSoftFloat32FPMul = new SoftFloat32FPMul(SoftFloat32.FPMul);
-            var dlgSoftFloat32FPMulFpscr = new SoftFloat32FPMulFpscr(SoftFloat32.FPMulFpscr); // A32 only.
-            var dlgSoftFloat32FPMulAdd = new SoftFloat32FPMulAdd(SoftFloat32.FPMulAdd);
-            var dlgSoftFloat32FPMulAddFpscr = new SoftFloat32FPMulAddFpscr(SoftFloat32.FPMulAddFpscr); // A32 only.
-            var dlgSoftFloat32FPMulSub = new SoftFloat32FPMulSub(SoftFloat32.FPMulSub);
-            var dlgSoftFloat32FPMulSubFpscr = new SoftFloat32FPMulSubFpscr(SoftFloat32.FPMulSubFpscr); // A32 only.
-            var dlgSoftFloat32FPMulX = new SoftFloat32FPMulX(SoftFloat32.FPMulX);
-            var dlgSoftFloat32FPNegMulAdd = new SoftFloat32FPNegMulAdd(SoftFloat32.FPNegMulAdd);
-            var dlgSoftFloat32FPNegMulSub = new SoftFloat32FPNegMulSub(SoftFloat32.FPNegMulSub);
-            var dlgSoftFloat32FPRecipEstimate = new SoftFloat32FPRecipEstimate(SoftFloat32.FPRecipEstimate);
-            var dlgSoftFloat32FPRecipEstimateFpscr = new SoftFloat32FPRecipEstimateFpscr(SoftFloat32.FPRecipEstimateFpscr); // A32 only.
-            var dlgSoftFloat32FPRecipStep = new SoftFloat32FPRecipStep(SoftFloat32.FPRecipStep); // A32 only.
-            var dlgSoftFloat32FPRecipStepFused = new SoftFloat32FPRecipStepFused(SoftFloat32.FPRecipStepFused);
-            var dlgSoftFloat32FPRecpX = new SoftFloat32FPRecpX(SoftFloat32.FPRecpX);
-            var dlgSoftFloat32FPRSqrtEstimate = new SoftFloat32FPRSqrtEstimate(SoftFloat32.FPRSqrtEstimate);
-            var dlgSoftFloat32FPRSqrtEstimateFpscr = new SoftFloat32FPRSqrtEstimateFpscr(SoftFloat32.FPRSqrtEstimateFpscr); // A32 only.
-            var dlgSoftFloat32FPRSqrtStep = new SoftFloat32FPRSqrtStep(SoftFloat32.FPRSqrtStep); // A32 only.
-            var dlgSoftFloat32FPRSqrtStepFused = new SoftFloat32FPRSqrtStepFused(SoftFloat32.FPRSqrtStepFused);
-            var dlgSoftFloat32FPSqrt = new SoftFloat32FPSqrt(SoftFloat32.FPSqrt);
-            var dlgSoftFloat32FPSub = new SoftFloat32FPSub(SoftFloat32.FPSub);
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAdd)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAddFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompare)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQ)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGE)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGEFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGT)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGTFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLE)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLEFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLT)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLTFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPDiv)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMax)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNum)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNumFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMin)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNum)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNumFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMul)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAdd)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAddFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSub)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSubFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulX)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulAdd)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulSub)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimate)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimateFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStep))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStepFused)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecpX)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimate)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimateFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStep))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStepFused)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSqrt)));
+            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSub)));
 
-            var dlgSoftFloat32_16FPConvert = new SoftFloat32_16FPConvert(SoftFloat32_16.FPConvert);
+            SetDelegateInfo(typeof(SoftFloat32_16).GetMethod(nameof(SoftFloat32_16.FPConvert)));
 
-            var dlgSoftFloat64FPAdd = new SoftFloat64FPAdd(SoftFloat64.FPAdd);
-            var dlgSoftFloat64FPAddFpscr = new SoftFloat64FPAddFpscr(SoftFloat64.FPAddFpscr); // A32 only.
-            var dlgSoftFloat64FPCompare = new SoftFloat64FPCompare(SoftFloat64.FPCompare);
-            var dlgSoftFloat64FPCompareEQ = new SoftFloat64FPCompareEQ(SoftFloat64.FPCompareEQ);
-            var dlgSoftFloat64FPCompareEQFpscr = new SoftFloat64FPCompareEQFpscr(SoftFloat64.FPCompareEQFpscr); // A32 only.
-            var dlgSoftFloat64FPCompareGE = new SoftFloat64FPCompareGE(SoftFloat64.FPCompareGE);
-            var dlgSoftFloat64FPCompareGEFpscr = new SoftFloat64FPCompareGEFpscr(SoftFloat64.FPCompareGEFpscr); // A32 only.
-            var dlgSoftFloat64FPCompareGT = new SoftFloat64FPCompareGT(SoftFloat64.FPCompareGT);
-            var dlgSoftFloat64FPCompareGTFpscr = new SoftFloat64FPCompareGTFpscr(SoftFloat64.FPCompareGTFpscr); // A32 only.
-            var dlgSoftFloat64FPCompareLE = new SoftFloat64FPCompareLE(SoftFloat64.FPCompareLE);
-            var dlgSoftFloat64FPCompareLEFpscr = new SoftFloat64FPCompareLEFpscr(SoftFloat64.FPCompareLEFpscr); // A32 only.
-            var dlgSoftFloat64FPCompareLT = new SoftFloat64FPCompareLT(SoftFloat64.FPCompareLT);
-            var dlgSoftFloat64FPCompareLTFpscr = new SoftFloat64FPCompareLTFpscr(SoftFloat64.FPCompareLTFpscr); // A32 only.
-            var dlgSoftFloat64FPDiv = new SoftFloat64FPDiv(SoftFloat64.FPDiv);
-            var dlgSoftFloat64FPMax = new SoftFloat64FPMax(SoftFloat64.FPMax);
-            var dlgSoftFloat64FPMaxFpscr = new SoftFloat64FPMaxFpscr(SoftFloat64.FPMaxFpscr); // A32 only.
-            var dlgSoftFloat64FPMaxNum = new SoftFloat64FPMaxNum(SoftFloat64.FPMaxNum);
-            var dlgSoftFloat64FPMaxNumFpscr = new SoftFloat64FPMaxNumFpscr(SoftFloat64.FPMaxNumFpscr); // A32 only.
-            var dlgSoftFloat64FPMin = new SoftFloat64FPMin(SoftFloat64.FPMin);
-            var dlgSoftFloat64FPMinFpscr = new SoftFloat64FPMinFpscr(SoftFloat64.FPMinFpscr); // A32 only.
-            var dlgSoftFloat64FPMinNum = new SoftFloat64FPMinNum(SoftFloat64.FPMinNum);
-            var dlgSoftFloat64FPMinNumFpscr = new SoftFloat64FPMinNumFpscr(SoftFloat64.FPMinNumFpscr); // A32 only.
-            var dlgSoftFloat64FPMul = new SoftFloat64FPMul(SoftFloat64.FPMul);
-            var dlgSoftFloat64FPMulFpscr = new SoftFloat64FPMulFpscr(SoftFloat64.FPMulFpscr); // A32 only.
-            var dlgSoftFloat64FPMulAdd = new SoftFloat64FPMulAdd(SoftFloat64.FPMulAdd);
-            var dlgSoftFloat64FPMulAddFpscr = new SoftFloat64FPMulAddFpscr(SoftFloat64.FPMulAddFpscr); // A32 only.
-            var dlgSoftFloat64FPMulSub = new SoftFloat64FPMulSub(SoftFloat64.FPMulSub);
-            var dlgSoftFloat64FPMulSubFpscr = new SoftFloat64FPMulSubFpscr(SoftFloat64.FPMulSubFpscr); // A32 only.
-            var dlgSoftFloat64FPMulX = new SoftFloat64FPMulX(SoftFloat64.FPMulX);
-            var dlgSoftFloat64FPNegMulAdd = new SoftFloat64FPNegMulAdd(SoftFloat64.FPNegMulAdd);
-            var dlgSoftFloat64FPNegMulSub = new SoftFloat64FPNegMulSub(SoftFloat64.FPNegMulSub);
-            var dlgSoftFloat64FPRecipEstimate = new SoftFloat64FPRecipEstimate(SoftFloat64.FPRecipEstimate);
-            var dlgSoftFloat64FPRecipEstimateFpscr = new SoftFloat64FPRecipEstimateFpscr(SoftFloat64.FPRecipEstimateFpscr); // A32 only.
-            var dlgSoftFloat64FPRecipStep = new SoftFloat64FPRecipStep(SoftFloat64.FPRecipStep); // A32 only.
-            var dlgSoftFloat64FPRecipStepFused = new SoftFloat64FPRecipStepFused(SoftFloat64.FPRecipStepFused);
-            var dlgSoftFloat64FPRecpX = new SoftFloat64FPRecpX(SoftFloat64.FPRecpX);
-            var dlgSoftFloat64FPRSqrtEstimate = new SoftFloat64FPRSqrtEstimate(SoftFloat64.FPRSqrtEstimate);
-            var dlgSoftFloat64FPRSqrtEstimateFpscr = new SoftFloat64FPRSqrtEstimateFpscr(SoftFloat64.FPRSqrtEstimateFpscr); // A32 only.
-            var dlgSoftFloat64FPRSqrtStep = new SoftFloat64FPRSqrtStep(SoftFloat64.FPRSqrtStep); // A32 only.
-            var dlgSoftFloat64FPRSqrtStepFused = new SoftFloat64FPRSqrtStepFused(SoftFloat64.FPRSqrtStepFused);
-            var dlgSoftFloat64FPSqrt = new SoftFloat64FPSqrt(SoftFloat64.FPSqrt);
-            var dlgSoftFloat64FPSub = new SoftFloat64FPSub(SoftFloat64.FPSub);
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAdd)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAddFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompare)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQ)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGE)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGEFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGT)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGTFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLE)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLEFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLT)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLTFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPDiv)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMax)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNum)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNumFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMin)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNum)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNumFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMul)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAdd)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAddFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSub)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSubFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulX)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulAdd)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulSub)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimate)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimateFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStep))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStepFused)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecpX)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimate)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimateFpscr))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStep))); // A32 only.
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStepFused)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSqrt)));
+            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSub)));
 
-            var dlgSoftFloat64_16FPConvert = new SoftFloat64_16FPConvert(SoftFloat64_16.FPConvert);
-
-            SetDelegateInfo(dlgMathAbs, Marshal.GetFunctionPointerForDelegate<MathAbs>(dlgMathAbs));
-            SetDelegateInfo(dlgMathCeiling, Marshal.GetFunctionPointerForDelegate<MathCeiling>(dlgMathCeiling));
-            SetDelegateInfo(dlgMathFloor, Marshal.GetFunctionPointerForDelegate<MathFloor>(dlgMathFloor));
-            SetDelegateInfo(dlgMathRound, Marshal.GetFunctionPointerForDelegate<MathRound>(dlgMathRound));
-            SetDelegateInfo(dlgMathTruncate, Marshal.GetFunctionPointerForDelegate<MathTruncate>(dlgMathTruncate));
-
-            SetDelegateInfo(dlgMathFAbs, Marshal.GetFunctionPointerForDelegate<MathFAbs>(dlgMathFAbs));
-            SetDelegateInfo(dlgMathFCeiling, Marshal.GetFunctionPointerForDelegate<MathFCeiling>(dlgMathFCeiling));
-            SetDelegateInfo(dlgMathFFloor, Marshal.GetFunctionPointerForDelegate<MathFFloor>(dlgMathFFloor));
-            SetDelegateInfo(dlgMathFRound, Marshal.GetFunctionPointerForDelegate<MathFRound>(dlgMathFRound));
-            SetDelegateInfo(dlgMathFTruncate, Marshal.GetFunctionPointerForDelegate<MathFTruncate>(dlgMathFTruncate));
-
-            SetDelegateInfo(dlgNativeInterfaceBreak, Marshal.GetFunctionPointerForDelegate<NativeInterfaceBreak>(dlgNativeInterfaceBreak));
-            SetDelegateInfo(dlgNativeInterfaceCheckSynchronization, Marshal.GetFunctionPointerForDelegate<NativeInterfaceCheckSynchronization>(dlgNativeInterfaceCheckSynchronization));
-            SetDelegateInfo(dlgNativeInterfaceEnqueueForRejit, Marshal.GetFunctionPointerForDelegate<NativeInterfaceEnqueueForRejit>(dlgNativeInterfaceEnqueueForRejit));
-            SetDelegateInfo(dlgNativeInterfaceGetCntfrqEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCntfrqEl0>(dlgNativeInterfaceGetCntfrqEl0));
-            SetDelegateInfo(dlgNativeInterfaceGetCntpctEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCntpctEl0>(dlgNativeInterfaceGetCntpctEl0));
-            SetDelegateInfo(dlgNativeInterfaceGetCntvctEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCntvctEl0>(dlgNativeInterfaceGetCntvctEl0));
-            SetDelegateInfo(dlgNativeInterfaceGetCtrEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCtrEl0>(dlgNativeInterfaceGetCtrEl0));
-            SetDelegateInfo(dlgNativeInterfaceGetDczidEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetDczidEl0>(dlgNativeInterfaceGetDczidEl0));
-            SetDelegateInfo(dlgNativeInterfaceGetFunctionAddress, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetFunctionAddress>(dlgNativeInterfaceGetFunctionAddress));
-            SetDelegateInfo(dlgNativeInterfaceInvalidateCacheLine, Marshal.GetFunctionPointerForDelegate<NativeInterfaceInvalidateCacheLine>(dlgNativeInterfaceInvalidateCacheLine));
-            SetDelegateInfo(dlgNativeInterfaceReadByte, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadByte>(dlgNativeInterfaceReadByte));
-            SetDelegateInfo(dlgNativeInterfaceReadUInt16, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadUInt16>(dlgNativeInterfaceReadUInt16));
-            SetDelegateInfo(dlgNativeInterfaceReadUInt32, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadUInt32>(dlgNativeInterfaceReadUInt32));
-            SetDelegateInfo(dlgNativeInterfaceReadUInt64, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadUInt64>(dlgNativeInterfaceReadUInt64));
-            SetDelegateInfo(dlgNativeInterfaceReadVector128, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadVector128>(dlgNativeInterfaceReadVector128));
-            SetDelegateInfo(dlgNativeInterfaceSignalMemoryTracking, Marshal.GetFunctionPointerForDelegate<NativeInterfaceSignalMemoryTracking>(dlgNativeInterfaceSignalMemoryTracking));
-            SetDelegateInfo(dlgNativeInterfaceSupervisorCall, Marshal.GetFunctionPointerForDelegate<NativeInterfaceSupervisorCall>(dlgNativeInterfaceSupervisorCall));
-            SetDelegateInfo(dlgNativeInterfaceThrowInvalidMemoryAccess, Marshal.GetFunctionPointerForDelegate<NativeInterfaceThrowInvalidMemoryAccess>(dlgNativeInterfaceThrowInvalidMemoryAccess));
-            SetDelegateInfo(dlgNativeInterfaceUndefined, Marshal.GetFunctionPointerForDelegate<NativeInterfaceUndefined>(dlgNativeInterfaceUndefined));
-            SetDelegateInfo(dlgNativeInterfaceWriteByte, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteByte>(dlgNativeInterfaceWriteByte));
-            SetDelegateInfo(dlgNativeInterfaceWriteUInt16, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteUInt16>(dlgNativeInterfaceWriteUInt16));
-            SetDelegateInfo(dlgNativeInterfaceWriteUInt32, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteUInt32>(dlgNativeInterfaceWriteUInt32));
-            SetDelegateInfo(dlgNativeInterfaceWriteUInt64, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteUInt64>(dlgNativeInterfaceWriteUInt64));
-            SetDelegateInfo(dlgNativeInterfaceWriteVector128, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteVector128>(dlgNativeInterfaceWriteVector128));
-
-            SetDelegateInfo(dlgSoftFallbackCountLeadingSigns, Marshal.GetFunctionPointerForDelegate<SoftFallbackCountLeadingSigns>(dlgSoftFallbackCountLeadingSigns));
-            SetDelegateInfo(dlgSoftFallbackCountLeadingZeros, Marshal.GetFunctionPointerForDelegate<SoftFallbackCountLeadingZeros>(dlgSoftFallbackCountLeadingZeros));
-            SetDelegateInfo(dlgSoftFallbackCrc32b, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32b>(dlgSoftFallbackCrc32b));
-            SetDelegateInfo(dlgSoftFallbackCrc32cb, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32cb>(dlgSoftFallbackCrc32cb));
-            SetDelegateInfo(dlgSoftFallbackCrc32ch, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32ch>(dlgSoftFallbackCrc32ch));
-            SetDelegateInfo(dlgSoftFallbackCrc32cw, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32cw>(dlgSoftFallbackCrc32cw));
-            SetDelegateInfo(dlgSoftFallbackCrc32cx, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32cx>(dlgSoftFallbackCrc32cx));
-            SetDelegateInfo(dlgSoftFallbackCrc32h, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32h>(dlgSoftFallbackCrc32h));
-            SetDelegateInfo(dlgSoftFallbackCrc32w, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32w>(dlgSoftFallbackCrc32w));
-            SetDelegateInfo(dlgSoftFallbackCrc32x, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32x>(dlgSoftFallbackCrc32x));
-            SetDelegateInfo(dlgSoftFallbackDecrypt, Marshal.GetFunctionPointerForDelegate<SoftFallbackDecrypt>(dlgSoftFallbackDecrypt));
-            SetDelegateInfo(dlgSoftFallbackEncrypt, Marshal.GetFunctionPointerForDelegate<SoftFallbackEncrypt>(dlgSoftFallbackEncrypt));
-            SetDelegateInfo(dlgSoftFallbackFixedRotate, Marshal.GetFunctionPointerForDelegate<SoftFallbackFixedRotate>(dlgSoftFallbackFixedRotate));
-            SetDelegateInfo(dlgSoftFallbackHashChoose, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashChoose>(dlgSoftFallbackHashChoose));
-            SetDelegateInfo(dlgSoftFallbackHashLower, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashLower>(dlgSoftFallbackHashLower));
-            SetDelegateInfo(dlgSoftFallbackHashMajority, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashMajority>(dlgSoftFallbackHashMajority));
-            SetDelegateInfo(dlgSoftFallbackHashParity, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashParity>(dlgSoftFallbackHashParity));
-            SetDelegateInfo(dlgSoftFallbackHashUpper, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashUpper>(dlgSoftFallbackHashUpper));
-            SetDelegateInfo(dlgSoftFallbackInverseMixColumns, Marshal.GetFunctionPointerForDelegate<SoftFallbackInverseMixColumns>(dlgSoftFallbackInverseMixColumns));
-            SetDelegateInfo(dlgSoftFallbackMixColumns, Marshal.GetFunctionPointerForDelegate<SoftFallbackMixColumns>(dlgSoftFallbackMixColumns));
-            SetDelegateInfo(dlgSoftFallbackPolynomialMult64_128, Marshal.GetFunctionPointerForDelegate<SoftFallbackPolynomialMult64_128>(dlgSoftFallbackPolynomialMult64_128));
-            SetDelegateInfo(dlgSoftFallbackSatF32ToS32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToS32>(dlgSoftFallbackSatF32ToS32));
-            SetDelegateInfo(dlgSoftFallbackSatF32ToS64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToS64>(dlgSoftFallbackSatF32ToS64));
-            SetDelegateInfo(dlgSoftFallbackSatF32ToU32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToU32>(dlgSoftFallbackSatF32ToU32));
-            SetDelegateInfo(dlgSoftFallbackSatF32ToU64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToU64>(dlgSoftFallbackSatF32ToU64));
-            SetDelegateInfo(dlgSoftFallbackSatF64ToS32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToS32>(dlgSoftFallbackSatF64ToS32));
-            SetDelegateInfo(dlgSoftFallbackSatF64ToS64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToS64>(dlgSoftFallbackSatF64ToS64));
-            SetDelegateInfo(dlgSoftFallbackSatF64ToU32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToU32>(dlgSoftFallbackSatF64ToU32));
-            SetDelegateInfo(dlgSoftFallbackSatF64ToU64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToU64>(dlgSoftFallbackSatF64ToU64));
-            SetDelegateInfo(dlgSoftFallbackSha1SchedulePart1, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha1SchedulePart1>(dlgSoftFallbackSha1SchedulePart1));
-            SetDelegateInfo(dlgSoftFallbackSha1SchedulePart2, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha1SchedulePart2>(dlgSoftFallbackSha1SchedulePart2));
-            SetDelegateInfo(dlgSoftFallbackSha256SchedulePart1, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha256SchedulePart1>(dlgSoftFallbackSha256SchedulePart1));
-            SetDelegateInfo(dlgSoftFallbackSha256SchedulePart2, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha256SchedulePart2>(dlgSoftFallbackSha256SchedulePart2));
-            SetDelegateInfo(dlgSoftFallbackSignedShrImm64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSignedShrImm64>(dlgSoftFallbackSignedShrImm64));
-            SetDelegateInfo(dlgSoftFallbackTbl1, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl1>(dlgSoftFallbackTbl1));
-            SetDelegateInfo(dlgSoftFallbackTbl2, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl2>(dlgSoftFallbackTbl2));
-            SetDelegateInfo(dlgSoftFallbackTbl3, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl3>(dlgSoftFallbackTbl3));
-            SetDelegateInfo(dlgSoftFallbackTbl4, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl4>(dlgSoftFallbackTbl4));
-            SetDelegateInfo(dlgSoftFallbackTbx1, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx1>(dlgSoftFallbackTbx1));
-            SetDelegateInfo(dlgSoftFallbackTbx2, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx2>(dlgSoftFallbackTbx2));
-            SetDelegateInfo(dlgSoftFallbackTbx3, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx3>(dlgSoftFallbackTbx3));
-            SetDelegateInfo(dlgSoftFallbackTbx4, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx4>(dlgSoftFallbackTbx4));
-            SetDelegateInfo(dlgSoftFallbackUnsignedShrImm64, Marshal.GetFunctionPointerForDelegate<SoftFallbackUnsignedShrImm64>(dlgSoftFallbackUnsignedShrImm64));
-
-            SetDelegateInfo(dlgSoftFloat16_32FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat16_32FPConvert>(dlgSoftFloat16_32FPConvert));
-            SetDelegateInfo(dlgSoftFloat16_64FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat16_64FPConvert>(dlgSoftFloat16_64FPConvert));
-
-            SetDelegateInfo(dlgSoftFloat32FPAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPAdd>(dlgSoftFloat32FPAdd));
-            SetDelegateInfo(dlgSoftFloat32FPAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPAddFpscr>(dlgSoftFloat32FPAddFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPCompare, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompare>(dlgSoftFloat32FPCompare));
-            SetDelegateInfo(dlgSoftFloat32FPCompareEQ, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareEQ>(dlgSoftFloat32FPCompareEQ));
-            SetDelegateInfo(dlgSoftFloat32FPCompareEQFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareEQFpscr>(dlgSoftFloat32FPCompareEQFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPCompareGE, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGE>(dlgSoftFloat32FPCompareGE));
-            SetDelegateInfo(dlgSoftFloat32FPCompareGEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGEFpscr>(dlgSoftFloat32FPCompareGEFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPCompareGT, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGT>(dlgSoftFloat32FPCompareGT));
-            SetDelegateInfo(dlgSoftFloat32FPCompareGTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGTFpscr>(dlgSoftFloat32FPCompareGTFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPCompareLE, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLE>(dlgSoftFloat32FPCompareLE));
-            SetDelegateInfo(dlgSoftFloat32FPCompareLEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLEFpscr>(dlgSoftFloat32FPCompareLEFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPCompareLT, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLT>(dlgSoftFloat32FPCompareLT));
-            SetDelegateInfo(dlgSoftFloat32FPCompareLTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLTFpscr>(dlgSoftFloat32FPCompareLTFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPDiv, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPDiv>(dlgSoftFloat32FPDiv));
-            SetDelegateInfo(dlgSoftFloat32FPMax, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMax>(dlgSoftFloat32FPMax));
-            SetDelegateInfo(dlgSoftFloat32FPMaxFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMaxFpscr>(dlgSoftFloat32FPMaxFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPMaxNum, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMaxNum>(dlgSoftFloat32FPMaxNum));
-            SetDelegateInfo(dlgSoftFloat32FPMaxNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMaxNumFpscr>(dlgSoftFloat32FPMaxNumFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPMin, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMin>(dlgSoftFloat32FPMin));
-            SetDelegateInfo(dlgSoftFloat32FPMinFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMinFpscr>(dlgSoftFloat32FPMinFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPMinNum, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMinNum>(dlgSoftFloat32FPMinNum));
-            SetDelegateInfo(dlgSoftFloat32FPMinNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMinNumFpscr>(dlgSoftFloat32FPMinNumFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPMul, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMul>(dlgSoftFloat32FPMul));
-            SetDelegateInfo(dlgSoftFloat32FPMulFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulFpscr>(dlgSoftFloat32FPMulFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulAdd>(dlgSoftFloat32FPMulAdd));
-            SetDelegateInfo(dlgSoftFloat32FPMulAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulAddFpscr>(dlgSoftFloat32FPMulAddFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulSub>(dlgSoftFloat32FPMulSub));
-            SetDelegateInfo(dlgSoftFloat32FPMulSubFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulSubFpscr>(dlgSoftFloat32FPMulSubFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPMulX, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulX>(dlgSoftFloat32FPMulX));
-            SetDelegateInfo(dlgSoftFloat32FPNegMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPNegMulAdd>(dlgSoftFloat32FPNegMulAdd));
-            SetDelegateInfo(dlgSoftFloat32FPNegMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPNegMulSub>(dlgSoftFloat32FPNegMulSub));
-            SetDelegateInfo(dlgSoftFloat32FPRecipEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipEstimate>(dlgSoftFloat32FPRecipEstimate));
-            SetDelegateInfo(dlgSoftFloat32FPRecipEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipEstimateFpscr>(dlgSoftFloat32FPRecipEstimateFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPRecipStep, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipStep>(dlgSoftFloat32FPRecipStep)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPRecipStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipStepFused>(dlgSoftFloat32FPRecipStepFused));
-            SetDelegateInfo(dlgSoftFloat32FPRecpX, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecpX>(dlgSoftFloat32FPRecpX));
-            SetDelegateInfo(dlgSoftFloat32FPRSqrtEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtEstimate>(dlgSoftFloat32FPRSqrtEstimate));
-            SetDelegateInfo(dlgSoftFloat32FPRSqrtEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtEstimateFpscr>(dlgSoftFloat32FPRSqrtEstimateFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPRSqrtStep, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtStep>(dlgSoftFloat32FPRSqrtStep)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat32FPRSqrtStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtStepFused>(dlgSoftFloat32FPRSqrtStepFused));
-            SetDelegateInfo(dlgSoftFloat32FPSqrt, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPSqrt>(dlgSoftFloat32FPSqrt));
-            SetDelegateInfo(dlgSoftFloat32FPSub, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPSub>(dlgSoftFloat32FPSub));
-
-            SetDelegateInfo(dlgSoftFloat32_16FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat32_16FPConvert>(dlgSoftFloat32_16FPConvert));
-
-            SetDelegateInfo(dlgSoftFloat64FPAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPAdd>(dlgSoftFloat64FPAdd));
-            SetDelegateInfo(dlgSoftFloat64FPAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPAddFpscr>(dlgSoftFloat64FPAddFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPCompare, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompare>(dlgSoftFloat64FPCompare));
-            SetDelegateInfo(dlgSoftFloat64FPCompareEQ, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareEQ>(dlgSoftFloat64FPCompareEQ));
-            SetDelegateInfo(dlgSoftFloat64FPCompareEQFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareEQFpscr>(dlgSoftFloat64FPCompareEQFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPCompareGE, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGE>(dlgSoftFloat64FPCompareGE));
-            SetDelegateInfo(dlgSoftFloat64FPCompareGEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGEFpscr>(dlgSoftFloat64FPCompareGEFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPCompareGT, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGT>(dlgSoftFloat64FPCompareGT));
-            SetDelegateInfo(dlgSoftFloat64FPCompareGTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGTFpscr>(dlgSoftFloat64FPCompareGTFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPCompareLE, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLE>(dlgSoftFloat64FPCompareLE));
-            SetDelegateInfo(dlgSoftFloat64FPCompareLEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLEFpscr>(dlgSoftFloat64FPCompareLEFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPCompareLT, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLT>(dlgSoftFloat64FPCompareLT));
-            SetDelegateInfo(dlgSoftFloat64FPCompareLTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLTFpscr>(dlgSoftFloat64FPCompareLTFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPDiv, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPDiv>(dlgSoftFloat64FPDiv));
-            SetDelegateInfo(dlgSoftFloat64FPMax, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMax>(dlgSoftFloat64FPMax));
-            SetDelegateInfo(dlgSoftFloat64FPMaxFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMaxFpscr>(dlgSoftFloat64FPMaxFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPMaxNum, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMaxNum>(dlgSoftFloat64FPMaxNum));
-            SetDelegateInfo(dlgSoftFloat64FPMaxNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMaxNumFpscr>(dlgSoftFloat64FPMaxNumFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPMin, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMin>(dlgSoftFloat64FPMin));
-            SetDelegateInfo(dlgSoftFloat64FPMinFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMinFpscr>(dlgSoftFloat64FPMinFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPMinNum, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMinNum>(dlgSoftFloat64FPMinNum));
-            SetDelegateInfo(dlgSoftFloat64FPMinNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMinNumFpscr>(dlgSoftFloat64FPMinNumFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPMul, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMul>(dlgSoftFloat64FPMul));
-            SetDelegateInfo(dlgSoftFloat64FPMulFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulFpscr>(dlgSoftFloat64FPMulFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulAdd>(dlgSoftFloat64FPMulAdd));
-            SetDelegateInfo(dlgSoftFloat64FPMulAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulAddFpscr>(dlgSoftFloat64FPMulAddFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulSub>(dlgSoftFloat64FPMulSub));
-            SetDelegateInfo(dlgSoftFloat64FPMulSubFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulSubFpscr>(dlgSoftFloat64FPMulSubFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPMulX, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulX>(dlgSoftFloat64FPMulX));
-            SetDelegateInfo(dlgSoftFloat64FPNegMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPNegMulAdd>(dlgSoftFloat64FPNegMulAdd));
-            SetDelegateInfo(dlgSoftFloat64FPNegMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPNegMulSub>(dlgSoftFloat64FPNegMulSub));
-            SetDelegateInfo(dlgSoftFloat64FPRecipEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipEstimate>(dlgSoftFloat64FPRecipEstimate));
-            SetDelegateInfo(dlgSoftFloat64FPRecipEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipEstimateFpscr>(dlgSoftFloat64FPRecipEstimateFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPRecipStep, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipStep>(dlgSoftFloat64FPRecipStep)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPRecipStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipStepFused>(dlgSoftFloat64FPRecipStepFused));
-            SetDelegateInfo(dlgSoftFloat64FPRecpX, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecpX>(dlgSoftFloat64FPRecpX));
-            SetDelegateInfo(dlgSoftFloat64FPRSqrtEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtEstimate>(dlgSoftFloat64FPRSqrtEstimate));
-            SetDelegateInfo(dlgSoftFloat64FPRSqrtEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtEstimateFpscr>(dlgSoftFloat64FPRSqrtEstimateFpscr)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPRSqrtStep, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtStep>(dlgSoftFloat64FPRSqrtStep)); // A32 only.
-            SetDelegateInfo(dlgSoftFloat64FPRSqrtStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtStepFused>(dlgSoftFloat64FPRSqrtStepFused));
-            SetDelegateInfo(dlgSoftFloat64FPSqrt, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPSqrt>(dlgSoftFloat64FPSqrt));
-            SetDelegateInfo(dlgSoftFloat64FPSub, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPSub>(dlgSoftFloat64FPSub));
-
-            SetDelegateInfo(dlgSoftFloat64_16FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat64_16FPConvert>(dlgSoftFloat64_16FPConvert));
+            SetDelegateInfo(typeof(SoftFloat64_16).GetMethod(nameof(SoftFloat64_16.FPConvert)));
         }
-
-        private delegate double MathAbs(double value);
-        private delegate double MathCeiling(double a);
-        private delegate double MathFloor(double d);
-        private delegate double MathRound(double value, MidpointRounding mode);
-        private delegate double MathTruncate(double d);
-
-        private delegate float MathFAbs(float x);
-        private delegate float MathFCeiling(float x);
-        private delegate float MathFFloor(float x);
-        private delegate float MathFRound(float x, MidpointRounding mode);
-        private delegate float MathFTruncate(float x);
-
-        private delegate void NativeInterfaceBreak(ulong address, int imm);
-        private delegate bool NativeInterfaceCheckSynchronization();
-        private delegate void NativeInterfaceEnqueueForRejit(ulong address);
-        private delegate ulong NativeInterfaceGetCntfrqEl0();
-        private delegate ulong NativeInterfaceGetCntpctEl0();
-        private delegate ulong NativeInterfaceGetCntvctEl0();
-        private delegate ulong NativeInterfaceGetCtrEl0();
-        private delegate ulong NativeInterfaceGetDczidEl0();
-        private delegate ulong NativeInterfaceGetFunctionAddress(ulong address);
-        private delegate void NativeInterfaceInvalidateCacheLine(ulong address);
-        private delegate byte NativeInterfaceReadByte(ulong address);
-        private delegate ushort NativeInterfaceReadUInt16(ulong address);
-        private delegate uint NativeInterfaceReadUInt32(ulong address);
-        private delegate ulong NativeInterfaceReadUInt64(ulong address);
-        private delegate V128 NativeInterfaceReadVector128(ulong address);
-        private delegate void NativeInterfaceSignalMemoryTracking(ulong address, ulong size, bool write);
-        private delegate void NativeInterfaceSupervisorCall(ulong address, int imm);
-        private delegate void NativeInterfaceThrowInvalidMemoryAccess(ulong address);
-        private delegate void NativeInterfaceUndefined(ulong address, int opCode);
-        private delegate void NativeInterfaceWriteByte(ulong address, byte value);
-        private delegate void NativeInterfaceWriteUInt16(ulong address, ushort value);
-        private delegate void NativeInterfaceWriteUInt32(ulong address, uint value);
-        private delegate void NativeInterfaceWriteUInt64(ulong address, ulong value);
-        private delegate void NativeInterfaceWriteVector128(ulong address, V128 value);
-
-        private delegate ulong SoftFallbackCountLeadingSigns(ulong value, int size);
-        private delegate ulong SoftFallbackCountLeadingZeros(ulong value, int size);
-        private delegate uint SoftFallbackCrc32b(uint crc, byte value);
-        private delegate uint SoftFallbackCrc32cb(uint crc, byte value);
-        private delegate uint SoftFallbackCrc32ch(uint crc, ushort value);
-        private delegate uint SoftFallbackCrc32cw(uint crc, uint value);
-        private delegate uint SoftFallbackCrc32cx(uint crc, ulong value);
-        private delegate uint SoftFallbackCrc32h(uint crc, ushort value);
-        private delegate uint SoftFallbackCrc32w(uint crc, uint value);
-        private delegate uint SoftFallbackCrc32x(uint crc, ulong value);
-        private delegate V128 SoftFallbackDecrypt(V128 value, V128 roundKey);
-        private delegate V128 SoftFallbackEncrypt(V128 value, V128 roundKey);
-        private delegate uint SoftFallbackFixedRotate(uint hash_e);
-        private delegate V128 SoftFallbackHashChoose(V128 hash_abcd, uint hash_e, V128 wk);
-        private delegate V128 SoftFallbackHashLower(V128 hash_abcd, V128 hash_efgh, V128 wk);
-        private delegate V128 SoftFallbackHashMajority(V128 hash_abcd, uint hash_e, V128 wk);
-        private delegate V128 SoftFallbackHashParity(V128 hash_abcd, uint hash_e, V128 wk);
-        private delegate V128 SoftFallbackHashUpper(V128 hash_abcd, V128 hash_efgh, V128 wk);
-        private delegate V128 SoftFallbackInverseMixColumns(V128 value);
-        private delegate V128 SoftFallbackMixColumns(V128 value);
-        private delegate V128 SoftFallbackPolynomialMult64_128(ulong op1, ulong op2);
-        private delegate int SoftFallbackSatF32ToS32(float value);
-        private delegate long SoftFallbackSatF32ToS64(float value);
-        private delegate uint SoftFallbackSatF32ToU32(float value);
-        private delegate ulong SoftFallbackSatF32ToU64(float value);
-        private delegate int SoftFallbackSatF64ToS32(double value);
-        private delegate long SoftFallbackSatF64ToS64(double value);
-        private delegate uint SoftFallbackSatF64ToU32(double value);
-        private delegate ulong SoftFallbackSatF64ToU64(double value);
-        private delegate V128 SoftFallbackSha1SchedulePart1(V128 w0_3, V128 w4_7, V128 w8_11);
-        private delegate V128 SoftFallbackSha1SchedulePart2(V128 tw0_3, V128 w12_15);
-        private delegate V128 SoftFallbackSha256SchedulePart1(V128 w0_3, V128 w4_7);
-        private delegate V128 SoftFallbackSha256SchedulePart2(V128 w0_3, V128 w8_11, V128 w12_15);
-        private delegate long SoftFallbackSignedShrImm64(long value, long roundConst, int shift);
-        private delegate V128 SoftFallbackTbl1(V128 vector, int bytes, V128 tb0);
-        private delegate V128 SoftFallbackTbl2(V128 vector, int bytes, V128 tb0, V128 tb1);
-        private delegate V128 SoftFallbackTbl3(V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2);
-        private delegate V128 SoftFallbackTbl4(V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2, V128 tb3);
-        private delegate V128 SoftFallbackTbx1(V128 dest, V128 vector, int bytes, V128 tb0);
-        private delegate V128 SoftFallbackTbx2(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1);
-        private delegate V128 SoftFallbackTbx3(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2);
-        private delegate V128 SoftFallbackTbx4(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2, V128 tb3);
-        private delegate ulong SoftFallbackUnsignedShrImm64(ulong value, long roundConst, int shift);
-
-        private delegate float SoftFloat16_32FPConvert(ushort valueBits);
-
-        private delegate double SoftFloat16_64FPConvert(ushort valueBits);
-
-        private delegate float SoftFloat32FPAdd(float value1, float value2);
-        private delegate float SoftFloat32FPAddFpscr(float value1, float value2, bool standardFpscr);
-        private delegate int SoftFloat32FPCompare(float value1, float value2, bool signalNaNs);
-        private delegate float SoftFloat32FPCompareEQ(float value1, float value2);
-        private delegate float SoftFloat32FPCompareEQFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPCompareGE(float value1, float value2);
-        private delegate float SoftFloat32FPCompareGEFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPCompareGT(float value1, float value2);
-        private delegate float SoftFloat32FPCompareGTFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPCompareLE(float value1, float value2);
-        private delegate float SoftFloat32FPCompareLEFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPCompareLT(float value1, float value2);
-        private delegate float SoftFloat32FPCompareLTFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPDiv(float value1, float value2);
-        private delegate float SoftFloat32FPMax(float value1, float value2);
-        private delegate float SoftFloat32FPMaxFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPMaxNum(float value1, float value2);
-        private delegate float SoftFloat32FPMaxNumFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPMin(float value1, float value2);
-        private delegate float SoftFloat32FPMinFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPMinNum(float value1, float value2);
-        private delegate float SoftFloat32FPMinNumFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPMul(float value1, float value2);
-        private delegate float SoftFloat32FPMulFpscr(float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPMulAdd(float valueA, float value1, float value2);
-        private delegate float SoftFloat32FPMulAddFpscr(float valueA, float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPMulSub(float valueA, float value1, float value2);
-        private delegate float SoftFloat32FPMulSubFpscr(float valueA, float value1, float value2, bool standardFpscr);
-        private delegate float SoftFloat32FPMulX(float value1, float value2);
-        private delegate float SoftFloat32FPNegMulAdd(float valueA, float value1, float value2);
-        private delegate float SoftFloat32FPNegMulSub(float valueA, float value1, float value2);
-        private delegate float SoftFloat32FPRecipEstimate(float value);
-        private delegate float SoftFloat32FPRecipEstimateFpscr(float value, bool standardFpscr);
-        private delegate float SoftFloat32FPRecipStep(float value1, float value2);
-        private delegate float SoftFloat32FPRecipStepFused(float value1, float value2);
-        private delegate float SoftFloat32FPRecpX(float value);
-        private delegate float SoftFloat32FPRSqrtEstimate(float value);
-        private delegate float SoftFloat32FPRSqrtEstimateFpscr(float value, bool standardFpscr);
-        private delegate float SoftFloat32FPRSqrtStep(float value1, float value2);
-        private delegate float SoftFloat32FPRSqrtStepFused(float value1, float value2);
-        private delegate float SoftFloat32FPSqrt(float value);
-        private delegate float SoftFloat32FPSub(float value1, float value2);
-
-        private delegate ushort SoftFloat32_16FPConvert(float value);
-
-        private delegate double SoftFloat64FPAdd(double value1, double value2);
-        private delegate double SoftFloat64FPAddFpscr(double value1, double value2, bool standardFpscr);
-        private delegate int SoftFloat64FPCompare(double value1, double value2, bool signalNaNs);
-        private delegate double SoftFloat64FPCompareEQ(double value1, double value2);
-        private delegate double SoftFloat64FPCompareEQFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPCompareGE(double value1, double value2);
-        private delegate double SoftFloat64FPCompareGEFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPCompareGT(double value1, double value2);
-        private delegate double SoftFloat64FPCompareGTFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPCompareLE(double value1, double value2);
-        private delegate double SoftFloat64FPCompareLEFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPCompareLT(double value1, double value2);
-        private delegate double SoftFloat64FPCompareLTFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPDiv(double value1, double value2);
-        private delegate double SoftFloat64FPMax(double value1, double value2);
-        private delegate double SoftFloat64FPMaxFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPMaxNum(double value1, double value2);
-        private delegate double SoftFloat64FPMaxNumFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPMin(double value1, double value2);
-        private delegate double SoftFloat64FPMinFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPMinNum(double value1, double value2);
-        private delegate double SoftFloat64FPMinNumFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPMul(double value1, double value2);
-        private delegate double SoftFloat64FPMulFpscr(double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPMulAdd(double valueA, double value1, double value2);
-        private delegate double SoftFloat64FPMulAddFpscr(double valueA, double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPMulSub(double valueA, double value1, double value2);
-        private delegate double SoftFloat64FPMulSubFpscr(double valueA, double value1, double value2, bool standardFpscr);
-        private delegate double SoftFloat64FPMulX(double value1, double value2);
-        private delegate double SoftFloat64FPNegMulAdd(double valueA, double value1, double value2);
-        private delegate double SoftFloat64FPNegMulSub(double valueA, double value1, double value2);
-        private delegate double SoftFloat64FPRecipEstimate(double value);
-        private delegate double SoftFloat64FPRecipEstimateFpscr(double value, bool standardFpscr);
-        private delegate double SoftFloat64FPRecipStep(double value1, double value2);
-        private delegate double SoftFloat64FPRecipStepFused(double value1, double value2);
-        private delegate double SoftFloat64FPRecpX(double value);
-        private delegate double SoftFloat64FPRSqrtEstimate(double value);
-        private delegate double SoftFloat64FPRSqrtEstimateFpscr(double value, bool standardFpscr);
-        private delegate double SoftFloat64FPRSqrtStep(double value1, double value2);
-        private delegate double SoftFloat64FPRSqrtStepFused(double value1, double value2);
-        private delegate double SoftFloat64FPSqrt(double value);
-        private delegate double SoftFloat64FPSub(double value1, double value2);
-
-        private delegate ushort SoftFloat64_16FPConvert(double value);
     }
 }
diff --git a/src/ARMeilleure/Translation/EmitterContext.cs b/src/ARMeilleure/Translation/EmitterContext.cs
index 88bfe1335..0dc906a75 100644
--- a/src/ARMeilleure/Translation/EmitterContext.cs
+++ b/src/ARMeilleure/Translation/EmitterContext.cs
@@ -97,7 +97,7 @@ namespace ARMeilleure.Translation
 
         public virtual Operand Call(MethodInfo info, params Operand[] callArgs)
         {
-            IntPtr funcPtr = Delegates.GetDelegateFuncPtr(info);
+            IntPtr funcPtr = info.MethodHandle.GetFunctionPointer();
 
             OperandType returnType = GetOperandType(info.ReturnType);
 
diff --git a/src/ARMeilleure/Translation/PTC/Ptc.cs b/src/ARMeilleure/Translation/PTC/Ptc.cs
index c2eed7a55..18d27cc7b 100644
--- a/src/ARMeilleure/Translation/PTC/Ptc.cs
+++ b/src/ARMeilleure/Translation/PTC/Ptc.cs
@@ -29,7 +29,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 6950; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 6958; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";