Android: Remove unmanaged code

src/ARMeilleure/Instructions/MathHelper.cs

@@ -1,35 +1,59 @@
 using System;
+#if ANDROID
+using System.Runtime.CompilerServices;
+#else
 using System.Runtime.InteropServices;
+#endif
 
 namespace ARMeilleure.Instructions
 {
     static class MathHelper
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double Abs(double value)
         {
             return Math.Abs(value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double Ceiling(double value)
         {
             return Math.Ceiling(value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double Floor(double value)
         {
             return Math.Floor(value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double Round(double value, int mode)
         {
             return Math.Round(value, (MidpointRounding)mode);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double Truncate(double value)
         {
             return Math.Truncate(value);
@@ -38,31 +62,51 @@ namespace ARMeilleure.Instructions
 
     static class MathHelperF
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float Abs(float value)
         {
             return MathF.Abs(value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float Ceiling(float value)
         {
             return MathF.Ceiling(value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float Floor(float value)
         {
             return MathF.Floor(value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float Round(float value, int mode)
         {
             return MathF.Round(value, (MidpointRounding)mode);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float Truncate(float value)
         {
             return MathF.Truncate(value);

src/ARMeilleure/Instructions/NativeInterface.cs

@@ -2,7 +2,11 @@ using ARMeilleure.Memory;
 using ARMeilleure.State;
 using ARMeilleure.Translation;
 using System;
+#if ANDROID
+using System.Runtime.CompilerServices;
+#else
 using System.Runtime.InteropServices;
+#endif
 
 namespace ARMeilleure.Instructions
 {
@@ -35,7 +39,11 @@ namespace ARMeilleure.Instructions
             Context = null;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void Break(ulong address, int imm)
         {
             Statistics.PauseTimer();
@@ -45,7 +53,11 @@ namespace ARMeilleure.Instructions
             Statistics.ResumeTimer();
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void SupervisorCall(ulong address, int imm)
         {
             Statistics.PauseTimer();
@@ -55,7 +67,11 @@ namespace ARMeilleure.Instructions
             Statistics.ResumeTimer();
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void Undefined(ulong address, int opCode)
         {
             Statistics.PauseTimer();
@@ -66,31 +82,51 @@ namespace ARMeilleure.Instructions
         }
 
         #region "System registers"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong GetCtrEl0()
         {
             return GetContext().CtrEl0;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong GetDczidEl0()
         {
             return GetContext().DczidEl0;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong GetCntfrqEl0()
         {
             return GetContext().CntfrqEl0;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong GetCntpctEl0()
         {
             return GetContext().CntpctEl0;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong GetCntvctEl0()
         {
             return GetContext().CntvctEl0;
@@ -98,31 +134,51 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Read"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static byte ReadByte(ulong address)
         {
             return GetMemoryManager().ReadGuest<byte>(address);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ushort ReadUInt16(ulong address)
         {
             return GetMemoryManager().ReadGuest<ushort>(address);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint ReadUInt32(ulong address)
         {
             return GetMemoryManager().ReadGuest<uint>(address);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong ReadUInt64(ulong address)
         {
             return GetMemoryManager().ReadGuest<ulong>(address);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 ReadVector128(ulong address)
         {
             return GetMemoryManager().ReadGuest<V128>(address);
@@ -130,56 +186,92 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Write"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void WriteByte(ulong address, byte value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void WriteUInt16(ulong address, ushort value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void WriteUInt32(ulong address, uint value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void WriteUInt64(ulong address, ulong value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void WriteVector128(ulong address, V128 value)
         {
             GetMemoryManager().WriteGuest(address, value);
         }
         #endregion
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void EnqueueForRejit(ulong address)
         {
             Context.Translator.EnqueueForRejit(address, GetContext().ExecutionMode);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void SignalMemoryTracking(ulong address, ulong size, byte write)
         {
             GetMemoryManager().SignalMemoryTracking(address, size, write == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void ThrowInvalidMemoryAccess(ulong address)
         {
             throw new InvalidAccessException(address);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong GetFunctionAddress(ulong address)
         {
             TranslatedFunction function = Context.Translator.GetOrTranslate(address, GetContext().ExecutionMode);
@@ -187,13 +279,21 @@ namespace ARMeilleure.Instructions
             return (ulong)function.FuncPointer.ToInt64();
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static void InvalidateCacheLine(ulong address)
         {
             Context.Translator.InvalidateJitCacheRegion(address, InstEmit.DczSizeInBytes);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static byte CheckSynchronization()
         {
             Statistics.PauseTimer();

src/ARMeilleure/Instructions/SoftFallback.cs

@@ -1,13 +1,21 @@
 using ARMeilleure.State;
 using System;
+#if ANDROID
+using System.Runtime.CompilerServices;
+#else
 using System.Runtime.InteropServices;
+#endif
 
 namespace ARMeilleure.Instructions
 {
     static class SoftFallback
     {
         #region "ShrImm64"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static long SignedShrImm64(long value, long roundConst, int shift)
         {
             if (roundConst == 0L)
@@ -50,7 +58,11 @@ namespace ARMeilleure.Instructions
             }
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong UnsignedShrImm64(ulong value, long roundConst, int shift)
         {
             if (roundConst == 0L)
@@ -95,7 +107,11 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Saturation"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static int SatF32ToS32(float value)
         {
             if (float.IsNaN(value))
@@ -107,7 +123,11 @@ namespace ARMeilleure.Instructions
                    value <= int.MinValue ? int.MinValue : (int)value;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static long SatF32ToS64(float value)
         {
             if (float.IsNaN(value))
@@ -119,7 +139,11 @@ namespace ARMeilleure.Instructions
                    value <= long.MinValue ? long.MinValue : (long)value;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint SatF32ToU32(float value)
         {
             if (float.IsNaN(value))
@@ -131,7 +155,11 @@ namespace ARMeilleure.Instructions
                    value <= uint.MinValue ? uint.MinValue : (uint)value;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong SatF32ToU64(float value)
         {
             if (float.IsNaN(value))
@@ -143,7 +171,11 @@ namespace ARMeilleure.Instructions
                    value <= ulong.MinValue ? ulong.MinValue : (ulong)value;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static int SatF64ToS32(double value)
         {
             if (double.IsNaN(value))
@@ -155,7 +187,11 @@ namespace ARMeilleure.Instructions
                    value <= int.MinValue ? int.MinValue : (int)value;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static long SatF64ToS64(double value)
         {
             if (double.IsNaN(value))
@@ -167,7 +203,11 @@ namespace ARMeilleure.Instructions
                    value <= long.MinValue ? long.MinValue : (long)value;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint SatF64ToU32(double value)
         {
             if (double.IsNaN(value))
@@ -179,7 +219,11 @@ namespace ARMeilleure.Instructions
                    value <= uint.MinValue ? uint.MinValue : (uint)value;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong SatF64ToU64(double value)
         {
             if (double.IsNaN(value))
@@ -193,7 +237,11 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Count"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong CountLeadingSigns(ulong value, int size) // size is 8, 16, 32 or 64 (SIMD&FP or Base Inst.).
         {
             value ^= value >> 1;
@@ -213,7 +261,11 @@ namespace ARMeilleure.Instructions
 
         private static ReadOnlySpan<byte> ClzNibbleTbl => [4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0];
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ulong CountLeadingZeros(ulong value, int size) // size is 8, 16, 32 or 64 (SIMD&FP or Base Inst.).
         {
             if (value == 0ul)
@@ -237,49 +289,81 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Table"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Tbl1(V128 vector, int bytes, V128 tb0)
         {
             return TblOrTbx(default, vector, bytes, tb0);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Tbl2(V128 vector, int bytes, V128 tb0, V128 tb1)
         {
             return TblOrTbx(default, vector, bytes, tb0, tb1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Tbl3(V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2)
         {
             return TblOrTbx(default, vector, bytes, tb0, tb1, tb2);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         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);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Tbx1(V128 dest, V128 vector, int bytes, V128 tb0)
         {
             return TblOrTbx(dest, vector, bytes, tb0);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Tbx2(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1)
         {
             return TblOrTbx(dest, vector, bytes, tb0, tb1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Tbx3(V128 dest, V128 vector, int bytes, V128 tb0, V128 tb1, V128 tb2)
         {
             return TblOrTbx(dest, vector, bytes, tb0, tb1, tb2);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         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);
@@ -321,22 +405,54 @@ namespace ARMeilleure.Instructions
         private const uint Crc32RevPoly = 0xedb88320;
         private const uint Crc32cRevPoly = 0x82f63b78;
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32b(uint crc, byte value) => Crc32(crc, Crc32RevPoly, value);
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32h(uint crc, ushort value) => Crc32h(crc, Crc32RevPoly, value);
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32w(uint crc, uint value) => Crc32w(crc, Crc32RevPoly, value);
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32x(uint crc, ulong value) => Crc32x(crc, Crc32RevPoly, value);
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32cb(uint crc, byte value) => Crc32(crc, Crc32cRevPoly, value);
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32ch(uint crc, ushort value) => Crc32h(crc, Crc32cRevPoly, value);
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32cw(uint crc, uint value) => Crc32w(crc, Crc32cRevPoly, value);
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint Crc32cx(uint crc, ulong value) => Crc32x(crc, Crc32cRevPoly, value);
 
         private static uint Crc32h(uint crc, uint poly, ushort val)
@@ -387,25 +503,41 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Aes"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Decrypt(V128 value, V128 roundKey)
         {
             return CryptoHelper.AesInvSubBytes(CryptoHelper.AesInvShiftRows(value ^ roundKey));
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Encrypt(V128 value, V128 roundKey)
         {
             return CryptoHelper.AesSubBytes(CryptoHelper.AesShiftRows(value ^ roundKey));
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 InverseMixColumns(V128 value)
         {
             return CryptoHelper.AesInvMixColumns(value);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 MixColumns(V128 value)
         {
             return CryptoHelper.AesMixColumns(value);
@@ -413,7 +545,11 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Sha1"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 HashChoose(V128 hash_abcd, uint hash_e, V128 wk)
         {
             for (int e = 0; e <= 3; e++)
@@ -434,13 +570,21 @@ namespace ARMeilleure.Instructions
             return hash_abcd;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static uint FixedRotate(uint hash_e)
         {
             return hash_e.Rol(30);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 HashMajority(V128 hash_abcd, uint hash_e, V128 wk)
         {
             for (int e = 0; e <= 3; e++)
@@ -461,7 +605,11 @@ namespace ARMeilleure.Instructions
             return hash_abcd;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 HashParity(V128 hash_abcd, uint hash_e, V128 wk)
         {
             for (int e = 0; e <= 3; e++)
@@ -482,7 +630,11 @@ namespace ARMeilleure.Instructions
             return hash_abcd;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Sha1SchedulePart1(V128 w0_3, V128 w4_7, V128 w8_11)
         {
             ulong t2 = w4_7.Extract<ulong>(0);
@@ -493,7 +645,11 @@ namespace ARMeilleure.Instructions
             return result ^ (w0_3 ^ w8_11);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Sha1SchedulePart2(V128 tw0_3, V128 w12_15)
         {
             V128 t = tw0_3 ^ (w12_15 >> 32);
@@ -538,19 +694,31 @@ namespace ARMeilleure.Instructions
         #endregion
 
         #region "Sha256"
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 HashLower(V128 hash_abcd, V128 hash_efgh, V128 wk)
         {
             return Sha256Hash(hash_abcd, hash_efgh, wk, part1: true);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 HashUpper(V128 hash_abcd, V128 hash_efgh, V128 wk)
         {
             return Sha256Hash(hash_abcd, hash_efgh, wk, part1: false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Sha256SchedulePart1(V128 w0_3, V128 w4_7)
         {
             V128 result = new();
@@ -569,7 +737,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 Sha256SchedulePart2(V128 w0_3, V128 w8_11, V128 w12_15)
         {
             V128 result = new();
@@ -671,7 +843,11 @@ namespace ARMeilleure.Instructions
         }
         #endregion
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static V128 PolynomialMult64_128(ulong op1, ulong op2)
         {
             V128 result = V128.Zero;

src/ARMeilleure/Instructions/SoftFloat.cs

@@ -1,7 +1,11 @@
 using ARMeilleure.State;
 using System;
 using System.Diagnostics;
+#if ANDROID
+using System.Runtime.CompilerServices;
+#else
 using System.Runtime.InteropServices;
+#endif
 
 namespace ARMeilleure.Instructions
 {
@@ -313,7 +317,11 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat16_32
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPConvert(ushort valueBits)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -489,7 +497,11 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat16_64
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPConvert(ushort valueBits)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -665,7 +677,11 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat32_16
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ushort FPConvert(float value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -785,13 +801,21 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat32
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPAdd(float value1, float value2)
         {
             return FPAddFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPAddFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPAddFpscrImpl(value1, value2, standardFpscr == 1);
@@ -848,7 +872,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static int FPCompare(float value1, float value2, byte signalNaNs)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -887,7 +915,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareEQ(float value1, float value2)
         {
             return FPCompareEQFpscrImpl(value1, value2, false);
@@ -920,19 +952,31 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareEQFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPCompareEQFpscrImpl(value1, value2, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareGE(float value1, float value2)
         {
             return FPCompareGEFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareGEFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPCompareGEFpscrImpl(value1, value2, standardFpscr == 1);
@@ -962,13 +1006,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareGT(float value1, float value2)
         {
             return FPCompareGTFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareGTFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPCompareGTFpscrImpl(value1, value2, standardFpscr == 1);
@@ -998,31 +1050,51 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareLE(float value1, float value2)
         {
             return FPCompareGEFpscrImpl(value2, value1, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareLT(float value1, float value2)
         {
             return FPCompareGTFpscrImpl(value2, value1, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareLEFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPCompareGEFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPCompareLTFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPCompareGEFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPDiv(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1075,13 +1147,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMax(float value1, float value2)
         {
             return FPMaxFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMaxFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPMaxFpscrImpl(value1, value2, standardFpscr == 1);
@@ -1148,7 +1228,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMaxNum(float value1, float value2)
         {
             return FPMaxNumFpscrImpl(value1, value2, false);
@@ -1174,19 +1258,31 @@ namespace ARMeilleure.Instructions
             return FPMaxFpscrImpl(value1, value2, standardFpscr);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMaxNumFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPMaxNumFpscrImpl(value1, value2, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMin(float value1, float value2)
         {
             return FPMinFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMinFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPMinFpscrImpl(value1, value2, standardFpscr == 1);
@@ -1253,13 +1349,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMinNum(float value1, float value2)
         {
             return FPMinNumFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMinNumFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPMinNumFpscrImpl(value1, value2, standardFpscr == 1);
@@ -1285,13 +1389,21 @@ namespace ARMeilleure.Instructions
             return FPMinFpscrImpl(value1, value2, standardFpscr);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMul(float value1, float value2)
         {
             return FPMulFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMulFpscr(float value1, float value2, byte standardFpscr)
         {
             return FPMulFpscrImpl(value1, value2, standardFpscr == 1);
@@ -1344,13 +1456,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMulAdd(float valueA, float value1, float value2)
         {
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMulAddFpscr(float valueA, float value1, float value2, byte standardFpscr)
         {
             return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
@@ -1422,7 +1542,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMulSub(float valueA, float value1, float value2)
         {
             value1 = value1.FPNeg();
@@ -1430,7 +1554,11 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMulSubFpscr(float valueA, float value1, float value2, byte standardFpscr)
         {
             value1 = value1.FPNeg();
@@ -1438,7 +1566,11 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPMulX(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1484,7 +1616,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPNegMulAdd(float valueA, float value1, float value2)
         {
             valueA = valueA.FPNeg();
@@ -1493,7 +1629,11 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPNegMulSub(float valueA, float value1, float value2)
         {
             valueA = valueA.FPNeg();
@@ -1501,13 +1641,21 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRecipEstimate(float value)
         {
             return FPRecipEstimateFpscrImpl(value, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRecipEstimateFpscr(float value, byte standardFpscr)
         {
             return FPRecipEstimateFpscrImpl(value, standardFpscr == 1);
@@ -1600,7 +1748,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRecipStep(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1635,7 +1787,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRecipStepFused(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1679,7 +1835,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRecpX(float value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1705,13 +1865,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRSqrtEstimate(float value)
         {
             return FPRSqrtEstimateFpscrImpl(value, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRSqrtEstimateFpscr(float value, byte standardFpscr)
         {
             return FPRSqrtEstimateFpscrImpl(value, standardFpscr == 1);
@@ -1831,7 +1999,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRSqrtStep(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1866,7 +2038,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPRSqrtStepFused(float value1, float value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1910,7 +2086,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPSqrt(float value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -1953,7 +2133,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static float FPSub(float value1, float value2)
         {
             return FPSubFpscrImpl(value1, value2, false);
@@ -2200,7 +2384,11 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat64_16
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static ushort FPConvert(double value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -2320,13 +2508,21 @@ namespace ARMeilleure.Instructions
 
     static class SoftFloat64
     {
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPAdd(double value1, double value2)
         {
             return FPAddFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPAddFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPAddFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2383,7 +2579,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static int FPCompare(double value1, double value2, byte signalNaNs)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -2422,13 +2622,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareEQ(double value1, double value2)
         {
             return FPCompareEQFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareEQFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPCompareEQFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2461,13 +2669,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareGE(double value1, double value2)
         {
             return FPCompareGEFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareGEFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPCompareGEFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2497,13 +2713,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareGT(double value1, double value2)
         {
             return FPCompareGTFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareGTFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPCompareGTFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2533,31 +2757,51 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareLE(double value1, double value2)
         {
             return FPCompareGEFpscrImpl(value2, value1, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareLT(double value1, double value2)
         {
             return FPCompareGTFpscrImpl(value2, value1, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareLEFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPCompareGEFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPCompareLTFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPCompareGTFpscrImpl(value2, value1, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPDiv(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -2610,13 +2854,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMax(double value1, double value2)
         {
             return FPMaxFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMaxFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPMaxFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2683,13 +2935,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMaxNum(double value1, double value2)
         {
             return FPMaxNumFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMaxNumFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPMaxNumFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2715,13 +2975,21 @@ namespace ARMeilleure.Instructions
             return FPMaxFpscrImpl(value1, value2, standardFpscr);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMin(double value1, double value2)
         {
             return FPMinFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMinFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPMinFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2788,13 +3056,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMinNum(double value1, double value2)
         {
             return FPMinNumFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMinNumFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPMinNumFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2820,13 +3096,21 @@ namespace ARMeilleure.Instructions
             return FPMinFpscrImpl(value1, value2, standardFpscr);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMul(double value1, double value2)
         {
             return FPMulFpscrImpl(value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMulFpscr(double value1, double value2, byte standardFpscr)
         {
             return FPMulFpscrImpl(value1, value2, standardFpscr == 1);
@@ -2879,13 +3163,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMulAdd(double valueA, double value1, double value2)
         {
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMulAddFpscr(double valueA, double value1, double value2, byte standardFpscr)
         {
             return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
@@ -2957,7 +3249,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMulSub(double valueA, double value1, double value2)
         {
             value1 = value1.FPNeg();
@@ -2965,7 +3261,11 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMulSubFpscr(double valueA, double value1, double value2, byte standardFpscr)
         {
             value1 = value1.FPNeg();
@@ -2973,7 +3273,11 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, standardFpscr == 1);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPMulX(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3019,7 +3323,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPNegMulAdd(double valueA, double value1, double value2)
         {
             valueA = valueA.FPNeg();
@@ -3028,7 +3336,11 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPNegMulSub(double valueA, double value1, double value2)
         {
             valueA = valueA.FPNeg();
@@ -3036,13 +3348,21 @@ namespace ARMeilleure.Instructions
             return FPMulAddFpscrImpl(valueA, value1, value2, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRecipEstimate(double value)
         {
             return FPRecipEstimateFpscrImpl(value, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRecipEstimateFpscr(double value, byte standardFpscr)
         {
             return FPRecipEstimateFpscrImpl(value, standardFpscr == 1);
@@ -3135,7 +3455,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRecipStep(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3170,7 +3494,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRecipStepFused(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3214,7 +3542,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRecpX(double value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3240,13 +3572,21 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRSqrtEstimate(double value)
         {
             return FPRSqrtEstimateFpscrImpl(value, false);
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRSqrtEstimateFpscr(double value, byte standardFpscr)
         {
             return FPRSqrtEstimateFpscrImpl(value, standardFpscr == 1);
@@ -3366,7 +3706,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRSqrtStep(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3401,7 +3745,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPRSqrtStepFused(double value1, double value2)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3445,7 +3793,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPSqrt(double value)
         {
             ExecutionContext context = NativeInterface.GetContext();
@@ -3488,7 +3840,11 @@ namespace ARMeilleure.Instructions
             return result;
         }
 
+#if ANDROID
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#else
         [UnmanagedCallersOnly]
+#endif
         public static double FPSub(double value1, double value2)
         {
             return FPSubFpscr(value1, value2, false);