mirrors/kenji-nx
1
0
Fork 0
mirror of https://git.ryujinx.app/kenji-nx/ryujinx.git synced 2025-12-14 16:37:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Android: Remove unmanaged code

Browse source
This commit is contained in:
KeatonTheBot 2025-05-15 13:30:55 -05:00
parent fc0528876f
commit 846b5b6e8a
7 changed files with 1276 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

44
src/ARMeilleure/Instructions/MathHelper.cs
View file

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

100
src/ARMeilleure/Instructions/NativeInterface.cs
View file

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

176
src/ARMeilleure/Instructions/SoftFallback.cs
View file

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

356
src/ARMeilleure/Instructions/SoftFloat.cs
View file

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

2
src/ARMeilleure/Translation/DelegateInfo.cs
View file

@ -2,7 +2,7 @@ using System;
namespace ARMeilleure.Translation namespace ARMeilleure.Translation
{ {
class DelegateInfo public class DelegateInfo
{ {
public IntPtr FuncPtr { get; } public IntPtr FuncPtr { get; }

628
src/ARMeilleure/Translation/Delegates.cs
View file

@ -2,11 +2,358 @@ using ARMeilleure.Instructions;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection; using System.Reflection;
#if ANDROID
using ARMeilleure.State;
using System.Runtime.InteropServices;
#endif
namespace ARMeilleure.Translation namespace ARMeilleure.Translation
{ {
static class Delegates static class Delegates
{ {
#if ANDROID
// MathHelper delegates
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double MathHelperAbsDelegate(double value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double MathHelperCeilingDelegate(double value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double MathHelperFloorDelegate(double value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double MathHelperRoundDelegate(double value, int mode);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double MathHelperTruncateDelegate(double value);
// MathHelperF delegates
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float MathHelperFAbsDelegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float MathHelperFCeilingDelegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float MathHelperFFloorDelegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float MathHelperFRoundDelegate(float value, int mode);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float MathHelperFTruncateDelegate(float value);
// NativeInterface delegates
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceBreakDelegate(ulong address, int imm);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate byte NativeInterfaceCheckSynchronizationDelegate();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceEnqueueForRejitDelegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong NativeInterfaceGetCntfrqEl0Delegate();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong NativeInterfaceGetCntpctEl0Delegate();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong NativeInterfaceGetCntvctEl0Delegate();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong NativeInterfaceGetCtrEl0Delegate();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong NativeInterfaceGetDczidEl0Delegate();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong NativeInterfaceGetFunctionAddressDelegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceInvalidateCacheLineDelegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate byte NativeInterfaceReadByteDelegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ushort NativeInterfaceReadUInt16Delegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint NativeInterfaceReadUInt32Delegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong NativeInterfaceReadUInt64Delegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 NativeInterfaceReadVector128Delegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceSignalMemoryTrackingDelegate(ulong address, ulong size, byte write);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceSupervisorCallDelegate(ulong address, int imm);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceThrowInvalidMemoryAccessDelegate(ulong address);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceUndefinedDelegate(ulong address, int opCode);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceWriteByteDelegate(ulong address, byte value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceWriteUInt16Delegate(ulong address, ushort value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceWriteUInt32Delegate(ulong address, uint value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceWriteUInt64Delegate(ulong address, ulong value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void NativeInterfaceWriteVector128Delegate(ulong address, V128 value);
// SoftFallback delegates
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong SoftFallbackCountLeadingSignsDelegate(ulong value, int size);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong SoftFallbackCountLeadingZerosDelegate(ulong value, int size);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32bDelegate(uint crc, byte val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32cbDelegate(uint crc, byte val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32chDelegate(uint crc, ushort val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32cwDelegate(uint crc, uint val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32cxDelegate(uint crc, ulong val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32hDelegate(uint crc, ushort val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32wDelegate(uint crc, uint val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackCrc32xDelegate(uint crc, ulong val);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackDecryptDelegate(V128 value, V128 roundKey);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackEncryptDelegate(V128 value, V128 roundKey);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackFixedRotateDelegate(uint hash_e);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackHashChooseDelegate(V128 hash_abcd, uint hash_e, V128 wk);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackHashLowerDelegate(V128 hash_abcd, V128 hash_efgh, V128 wk);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackHashMajorityDelegate(V128 hash_abcd, uint hash_e, V128 wk);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackHashParityDelegate(V128 hash_abcd, uint hash_e, V128 wk);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackHashUpperDelegate(V128 hash_abcd, V128 hash_efgh, V128 wk);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackInverseMixColumnsDelegate(V128 value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackMixColumnsDelegate(V128 value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackPolynomialMult64_128Delegate(ulong op1, ulong op2);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int SoftFallbackSatF32ToS32Delegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate long SoftFallbackSatF32ToS64Delegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackSatF32ToU32Delegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong SoftFallbackSatF32ToU64Delegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int SoftFallbackSatF64ToS32Delegate(double value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate long SoftFallbackSatF64ToS64Delegate(double value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint SoftFallbackSatF64ToU32Delegate(double value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong SoftFallbackSatF64ToU64Delegate(double value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackSha1SchedulePart1Delegate(V128 w0_3, V128 w4_7, V128 w8_11);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackSha1SchedulePart2Delegate(V128 tw0_3, V128 w12_15);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackSha256SchedulePart1Delegate(V128 w0_3, V128 w4_7);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackSha256SchedulePart2Delegate(V128 w0_3, V128 w8_11, V128 w12_15);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate long SoftFallbackSignedShrImm64Delegate(long value, long roundConst, int shift);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbl1Delegate(V128 vector, int bytes, V128 table);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbl2Delegate(V128 vector, int bytes, V128 table0, V128 table1);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbl3Delegate(V128 vector, int bytes, V128 table0, V128 table1, V128 table2);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbl4Delegate(V128 vector, int bytes, V128 table0, V128 table1, V128 table2, V128 table3);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbx1Delegate(V128 dest, V128 vector, int bytes, V128 table);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbx2Delegate(V128 dest, V128 vector, int bytes, V128 table0, V128 table1);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbx3Delegate(V128 dest, V128 vector, int bytes, V128 table0, V128 table1, V128 table2);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate V128 SoftFallbackTbx4Delegate(V128 dest, V128 vector, int bytes, V128 table0, V128 table1, V128 table2, V128 table3);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ulong SoftFallbackUnsignedShrImm64Delegate(ulong value, long roundConst, int shift);
// SoftFloat delegates
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat16_32FPConvertDelegate(ushort value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat16_64FPConvertDelegate(ushort value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPAddDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPAddFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int SoftFloat32FPCompareDelegate(float a, float b, byte signalNaNs);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareEQDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareEQFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareGEDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareGEFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareGTDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareGTFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareLEDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareLEFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareLTDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPCompareLTFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPDivDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMaxDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMaxFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMaxNumDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMaxNumFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMinDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMinFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMinNumDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMinNumFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMulDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMulFpscrDelegate(float a, float b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMulAddDelegate(float a, float b, float c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMulAddFpscrDelegate(float a, float b, float c, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMulSubDelegate(float a, float b, float c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMulSubFpscrDelegate(float a, float b, float c, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPMulXDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPNegMulAddDelegate(float a, float b, float c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPNegMulSubDelegate(float a, float b, float c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRecipEstimateDelegate(float a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRecipEstimateFpscrDelegate(float a, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRecipStepDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRecipStepFusedDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRecpXDelegate(float a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRSqrtEstimateDelegate(float a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRSqrtEstimateFpscrDelegate(float a, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRSqrtStepDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPRSqrtStepFusedDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPSqrtDelegate(float a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate float SoftFloat32FPSubDelegate(float a, float b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ushort SoftFloat32_16FPConvertDelegate(float value);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPAddDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPAddFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int SoftFloat64FPCompareDelegate(double a, double b, byte signalNaNs);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareEQDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareEQFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareGEDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareGEFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareGTDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareGTFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareLEDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareLEFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareLTDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPCompareLTFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPDivDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMaxDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMaxFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMaxNumDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMaxNumFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMinDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMinFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMinNumDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMinNumFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMulDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMulFpscrDelegate(double a, double b, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMulAddDelegate(double a, double b, double c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMulAddFpscrDelegate(double a, double b, double c, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMulSubDelegate(double a, double b, double c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMulSubFpscrDelegate(double a, double b, double c, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPMulXDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPNegMulAddDelegate(double a, double b, double c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPNegMulSubDelegate(double a, double b, double c);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRecipEstimateDelegate(double a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRecipEstimateFpscrDelegate(double a, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRecipStepDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRecipStepFusedDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRecpXDelegate(double a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRSqrtEstimateDelegate(double a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRSqrtEstimateFpscrDelegate(double a, byte standardFpscr);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRSqrtStepDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPRSqrtStepFusedDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPSqrtDelegate(double a);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate double SoftFloat64FPSubDelegate(double a, double b);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate ushort SoftFloat64_16FPConvertDelegate(double value);
private static readonly Dictionary<string, Delegate> _androidDelegates;
#endif
public static bool TryGetDelegateFuncPtrByIndex(int index, out IntPtr funcPtr) public static bool TryGetDelegateFuncPtrByIndex(int index, out IntPtr funcPtr)
{ {
if (index >= 0 && index < _delegates.Count) if (index >= 0 && index < _delegates.Count)
@ -53,12 +400,37 @@ namespace ARMeilleure.Translation
{ {
string key = GetKey(method); string key = GetKey(method);
_delegates.Add(key, new DelegateInfo(method.MethodHandle.GetFunctionPointer())); // ArgumentException (key). #if ANDROID
if (_androidDelegates.TryGetValue(key, out Delegate del))
{
IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(del);
_delegates.Add(key, new DelegateInfo(funcPtr));
return;
}
#endif
try
{
_delegates.Add(key, new DelegateInfo(method.MethodHandle.GetFunctionPointer()));
}
catch (NotSupportedException) when (IsRunningOnAndroid())
{
throw new PlatformNotSupportedException($"Cannot obtain function pointer {key}: it must be registered.");
}
}
private static bool IsRunningOnAndroid()
{
#if ANDROID
return true;
#else
return false;
#endif
} }
private static string GetKey(MethodInfo info) private static string GetKey(MethodInfo info)
{ {
return $"{info.DeclaringType.Name}.{info.Name}"; return $"{info.DeclaringType?.Name}.{info.Name}";
} }
private static readonly SortedList<string, DelegateInfo> _delegates; private static readonly SortedList<string, DelegateInfo> _delegates;
@ -67,6 +439,190 @@ namespace ARMeilleure.Translation
{ {
_delegates = new SortedList<string, DelegateInfo>(); _delegates = new SortedList<string, DelegateInfo>();
#if ANDROID
_androidDelegates = new Dictionary<string, Delegate>
{
// MathHelper delegates
{ "MathHelper.Abs", new MathHelperAbsDelegate(Math.Abs) },
{ "MathHelper.Ceiling", new MathHelperCeilingDelegate(Math.Ceiling) },
{ "MathHelper.Floor", new MathHelperFloorDelegate(Math.Floor) },
{ "MathHelper.Round", new MathHelperRoundDelegate((value, mode) => Math.Round(value, (MidpointRounding)mode)) },
{ "MathHelper.Truncate", new MathHelperTruncateDelegate(Math.Truncate) },
// MathHelperF delegates
{ "MathHelperF.Abs", new MathHelperFAbsDelegate(MathF.Abs) },
{ "MathHelperF.Ceiling", new MathHelperFCeilingDelegate(MathF.Ceiling) },
{ "MathHelperF.Floor", new MathHelperFFloorDelegate(MathF.Floor) },
{ "MathHelperF.Round", new MathHelperFRoundDelegate((value, mode) => MathF.Round(value, (MidpointRounding)mode)) },
{ "MathHelperF.Truncate", new MathHelperFTruncateDelegate(MathF.Truncate) },
// NativeInterface delegates
{ "NativeInterface.Break", new NativeInterfaceBreakDelegate(NativeInterface.Break) },
{ "NativeInterface.CheckSynchronization", new NativeInterfaceCheckSynchronizationDelegate(NativeInterface.CheckSynchronization) },
{ "NativeInterface.EnqueueForRejit", new NativeInterfaceEnqueueForRejitDelegate(NativeInterface.EnqueueForRejit) },
{ "NativeInterface.GetCntfrqEl0", new NativeInterfaceGetCntfrqEl0Delegate(NativeInterface.GetCntfrqEl0) },
{ "NativeInterface.GetCntpctEl0", new NativeInterfaceGetCntpctEl0Delegate(NativeInterface.GetCntpctEl0) },
{ "NativeInterface.GetCntvctEl0", new NativeInterfaceGetCntvctEl0Delegate(NativeInterface.GetCntvctEl0) },
{ "NativeInterface.GetCtrEl0", new NativeInterfaceGetCtrEl0Delegate(NativeInterface.GetCtrEl0) },
{ "NativeInterface.GetDczidEl0", new NativeInterfaceGetDczidEl0Delegate(NativeInterface.GetDczidEl0) },
{ "NativeInterface.GetFunctionAddress", new NativeInterfaceGetFunctionAddressDelegate(NativeInterface.GetFunctionAddress) },
{ "NativeInterface.InvalidateCacheLine", new NativeInterfaceInvalidateCacheLineDelegate(NativeInterface.InvalidateCacheLine) },
{ "NativeInterface.ReadByte", new NativeInterfaceReadByteDelegate(NativeInterface.ReadByte) },
{ "NativeInterface.ReadUInt16", new NativeInterfaceReadUInt16Delegate(NativeInterface.ReadUInt16) },
{ "NativeInterface.ReadUInt32", new NativeInterfaceReadUInt32Delegate(NativeInterface.ReadUInt32) },
{ "NativeInterface.ReadUInt64", new NativeInterfaceReadUInt64Delegate(NativeInterface.ReadUInt64) },
{ "NativeInterface.ReadVector128", new NativeInterfaceReadVector128Delegate(NativeInterface.ReadVector128) },
{ "NativeInterface.SignalMemoryTracking", new NativeInterfaceSignalMemoryTrackingDelegate(NativeInterface.SignalMemoryTracking) },
{ "NativeInterface.SupervisorCall", new NativeInterfaceSupervisorCallDelegate(NativeInterface.SupervisorCall) },
{ "NativeInterface.ThrowInvalidMemoryAccess", new NativeInterfaceThrowInvalidMemoryAccessDelegate(NativeInterface.ThrowInvalidMemoryAccess) },
{ "NativeInterface.Undefined", new NativeInterfaceUndefinedDelegate(NativeInterface.Undefined) },
{ "NativeInterface.WriteByte", new NativeInterfaceWriteByteDelegate(NativeInterface.WriteByte) },
{ "NativeInterface.WriteUInt16", new NativeInterfaceWriteUInt16Delegate(NativeInterface.WriteUInt16) },
{ "NativeInterface.WriteUInt32", new NativeInterfaceWriteUInt32Delegate(NativeInterface.WriteUInt32) },
{ "NativeInterface.WriteUInt64", new NativeInterfaceWriteUInt64Delegate(NativeInterface.WriteUInt64) },
{ "NativeInterface.WriteVector128", new NativeInterfaceWriteVector128Delegate(NativeInterface.WriteVector128) },
// SoftFallback delegates
{ "SoftFallback.CountLeadingSigns", new SoftFallbackCountLeadingSignsDelegate(SoftFallback.CountLeadingSigns) },
{ "SoftFallback.CountLeadingZeros", new SoftFallbackCountLeadingZerosDelegate(SoftFallback.CountLeadingZeros) },
{ "SoftFallback.Crc32b", new SoftFallbackCrc32bDelegate(SoftFallback.Crc32b) },
{ "SoftFallback.Crc32cb", new SoftFallbackCrc32cbDelegate(SoftFallback.Crc32cb) },
{ "SoftFallback.Crc32ch", new SoftFallbackCrc32chDelegate(SoftFallback.Crc32ch) },
{ "SoftFallback.Crc32cw", new SoftFallbackCrc32cwDelegate(SoftFallback.Crc32cw) },
{ "SoftFallback.Crc32cx", new SoftFallbackCrc32cxDelegate(SoftFallback.Crc32cx) },
{ "SoftFallback.Crc32h", new SoftFallbackCrc32hDelegate(SoftFallback.Crc32h) },
{ "SoftFallback.Crc32w", new SoftFallbackCrc32wDelegate(SoftFallback.Crc32w) },
{ "SoftFallback.Crc32x", new SoftFallbackCrc32xDelegate(SoftFallback.Crc32x) },
{ "SoftFallback.Decrypt", new SoftFallbackDecryptDelegate(SoftFallback.Decrypt) },
{ "SoftFallback.Encrypt", new SoftFallbackEncryptDelegate(SoftFallback.Encrypt) },
{ "SoftFallback.FixedRotate", new SoftFallbackFixedRotateDelegate(SoftFallback.FixedRotate) },
{ "SoftFallback.HashChoose", new SoftFallbackHashChooseDelegate(SoftFallback.HashChoose) },
{ "SoftFallback.HashLower", new SoftFallbackHashLowerDelegate(SoftFallback.HashLower) },
{ "SoftFallback.HashMajority", new SoftFallbackHashMajorityDelegate(SoftFallback.HashMajority) },
{ "SoftFallback.HashParity", new SoftFallbackHashParityDelegate(SoftFallback.HashParity) },
{ "SoftFallback.HashUpper", new SoftFallbackHashUpperDelegate(SoftFallback.HashUpper) },
{ "SoftFallback.InverseMixColumns", new SoftFallbackInverseMixColumnsDelegate(SoftFallback.InverseMixColumns) },
{ "SoftFallback.MixColumns", new SoftFallbackMixColumnsDelegate(SoftFallback.MixColumns) },
{ "SoftFallback.PolynomialMult64_128", new SoftFallbackPolynomialMult64_128Delegate(SoftFallback.PolynomialMult64_128) },
{ "SoftFallback.SatF32ToS32", new SoftFallbackSatF32ToS32Delegate(SoftFallback.SatF32ToS32) },
{ "SoftFallback.SatF32ToS64", new SoftFallbackSatF32ToS64Delegate(SoftFallback.SatF32ToS64) },
{ "SoftFallback.SatF32ToU32", new SoftFallbackSatF32ToU32Delegate(SoftFallback.SatF32ToU32) },
{ "SoftFallback.SatF32ToU64", new SoftFallbackSatF32ToU64Delegate(SoftFallback.SatF32ToU64) },
{ "SoftFallback.SatF64ToS32", new SoftFallbackSatF64ToS32Delegate(SoftFallback.SatF64ToS32) },
{ "SoftFallback.SatF64ToS64", new SoftFallbackSatF64ToS64Delegate(SoftFallback.SatF64ToS64) },
{ "SoftFallback.SatF64ToU32", new SoftFallbackSatF64ToU32Delegate(SoftFallback.SatF64ToU32) },
{ "SoftFallback.SatF64ToU64", new SoftFallbackSatF64ToU64Delegate(SoftFallback.SatF64ToU64) },
{ "SoftFallback.Sha1SchedulePart1", new SoftFallbackSha1SchedulePart1Delegate(SoftFallback.Sha1SchedulePart1) },
{ "SoftFallback.Sha1SchedulePart2", new SoftFallbackSha1SchedulePart2Delegate(SoftFallback.Sha1SchedulePart2) },
{ "SoftFallback.Sha256SchedulePart1", new SoftFallbackSha256SchedulePart1Delegate(SoftFallback.Sha256SchedulePart1) },
{ "SoftFallback.Sha256SchedulePart2", new SoftFallbackSha256SchedulePart2Delegate(SoftFallback.Sha256SchedulePart2) },
{ "SoftFallback.SignedShrImm64", new SoftFallbackSignedShrImm64Delegate(SoftFallback.SignedShrImm64) },
{ "SoftFallback.Tbl1", new SoftFallbackTbl1Delegate(SoftFallback.Tbl1) },
{ "SoftFallback.Tbl2", new SoftFallbackTbl2Delegate(SoftFallback.Tbl2) },
{ "SoftFallback.Tbl3", new SoftFallbackTbl3Delegate(SoftFallback.Tbl3) },
{ "SoftFallback.Tbl4", new SoftFallbackTbl4Delegate(SoftFallback.Tbl4) },
{ "SoftFallback.Tbx1", new SoftFallbackTbx1Delegate(SoftFallback.Tbx1) },
{ "SoftFallback.Tbx2", new SoftFallbackTbx2Delegate(SoftFallback.Tbx2) },
{ "SoftFallback.Tbx3", new SoftFallbackTbx3Delegate(SoftFallback.Tbx3) },
{ "SoftFallback.Tbx4", new SoftFallbackTbx4Delegate(SoftFallback.Tbx4) },
{ "SoftFallback.UnsignedShrImm64", new SoftFallbackUnsignedShrImm64Delegate(SoftFallback.UnsignedShrImm64) },
// SoftFloat delegates
{ "SoftFloat16_32.FPConvert", new SoftFloat16_32FPConvertDelegate(SoftFloat16_32.FPConvert) },
{ "SoftFloat16_64.FPConvert", new SoftFloat16_64FPConvertDelegate(SoftFloat16_64.FPConvert) },
{ "SoftFloat32.FPAdd", new SoftFloat32FPAddDelegate(SoftFloat32.FPAdd) },
{ "SoftFloat32.FPAddFpscr", new SoftFloat32FPAddFpscrDelegate(SoftFloat32.FPAddFpscr) },
{ "SoftFloat32.FPCompare", new SoftFloat32FPCompareDelegate(SoftFloat32.FPCompare) },
{ "SoftFloat32.FPCompareEQ", new SoftFloat32FPCompareEQDelegate(SoftFloat32.FPCompareEQ) },
{ "SoftFloat32.FPCompareEQFpscr", new SoftFloat32FPCompareEQFpscrDelegate(SoftFloat32.FPCompareEQFpscr) },
{ "SoftFloat32.FPCompareGE", new SoftFloat32FPCompareGEDelegate(SoftFloat32.FPCompareGE) },
{ "SoftFloat32.FPCompareGEFpscr", new SoftFloat32FPCompareGEFpscrDelegate(SoftFloat32.FPCompareGEFpscr) },
{ "SoftFloat32.FPCompareGT", new SoftFloat32FPCompareGTDelegate(SoftFloat32.FPCompareGT) },
{ "SoftFloat32.FPCompareGTFpscr", new SoftFloat32FPCompareGTFpscrDelegate(SoftFloat32.FPCompareGTFpscr) },
{ "SoftFloat32.FPCompareLE", new SoftFloat32FPCompareLEDelegate(SoftFloat32.FPCompareLE) },
{ "SoftFloat32.FPCompareLEFpscr", new SoftFloat32FPCompareLEFpscrDelegate(SoftFloat32.FPCompareLEFpscr) },
{ "SoftFloat32.FPCompareLT", new SoftFloat32FPCompareLTDelegate(SoftFloat32.FPCompareLT) },
{ "SoftFloat32.FPCompareLTFpscr", new SoftFloat32FPCompareLTFpscrDelegate(SoftFloat32.FPCompareLTFpscr) },
{ "SoftFloat32.FPDiv", new SoftFloat32FPDivDelegate(SoftFloat32.FPDiv) },
{ "SoftFloat32.FPMax", new SoftFloat32FPMaxDelegate(SoftFloat32.FPMax) },
{ "SoftFloat32.FPMaxFpscr", new SoftFloat32FPMaxFpscrDelegate(SoftFloat32.FPMaxFpscr) },
{ "SoftFloat32.FPMaxNum", new SoftFloat32FPMaxNumDelegate(SoftFloat32.FPMaxNum) },
{ "SoftFloat32.FPMaxNumFpscr", new SoftFloat32FPMaxNumFpscrDelegate(SoftFloat32.FPMaxNumFpscr) },
{ "SoftFloat32.FPMin", new SoftFloat32FPMinDelegate(SoftFloat32.FPMin) },
{ "SoftFloat32.FPMinFpscr", new SoftFloat32FPMinFpscrDelegate(SoftFloat32.FPMinFpscr) },
{ "SoftFloat32.FPMinNum", new SoftFloat32FPMinNumDelegate(SoftFloat32.FPMinNum) },
{ "SoftFloat32.FPMinNumFpscr", new SoftFloat32FPMinNumFpscrDelegate(SoftFloat32.FPMinNumFpscr) },
{ "SoftFloat32.FPMul", new SoftFloat32FPMulDelegate(SoftFloat32.FPMul) },
{ "SoftFloat32.FPMulFpscr", new SoftFloat32FPMulFpscrDelegate(SoftFloat32.FPMulFpscr) },
{ "SoftFloat32.FPMulAdd", new SoftFloat32FPMulAddDelegate(SoftFloat32.FPMulAdd) },
{ "SoftFloat32.FPMulAddFpscr", new SoftFloat32FPMulAddFpscrDelegate(SoftFloat32.FPMulAddFpscr) },
{ "SoftFloat32.FPMulSub", new SoftFloat32FPMulSubDelegate(SoftFloat32.FPMulSub) },
{ "SoftFloat32.FPMulSubFpscr", new SoftFloat32FPMulSubFpscrDelegate(SoftFloat32.FPMulSubFpscr) },
{ "SoftFloat32.FPMulX", new SoftFloat32FPMulXDelegate(SoftFloat32.FPMulX) },
{ "SoftFloat32.FPNegMulAdd", new SoftFloat32FPNegMulAddDelegate(SoftFloat32.FPNegMulAdd) },
{ "SoftFloat32.FPNegMulSub", new SoftFloat32FPNegMulSubDelegate(SoftFloat32.FPNegMulSub) },
{ "SoftFloat32.FPRecipEstimate", new SoftFloat32FPRecipEstimateDelegate(SoftFloat32.FPRecipEstimate) },
{ "SoftFloat32.FPRecipEstimateFpscr", new SoftFloat32FPRecipEstimateFpscrDelegate(SoftFloat32.FPRecipEstimateFpscr) },
{ "SoftFloat32.FPRecipStep", new SoftFloat32FPRecipStepDelegate(SoftFloat32.FPRecipStep) },
{ "SoftFloat32.FPRecipStepFused", new SoftFloat32FPRecipStepFusedDelegate(SoftFloat32.FPRecipStepFused) },
{ "SoftFloat32.FPRecpX", new SoftFloat32FPRecpXDelegate(SoftFloat32.FPRecpX) },
{ "SoftFloat32.FPRSqrtEstimate", new SoftFloat32FPRSqrtEstimateDelegate(SoftFloat32.FPRSqrtEstimate) },
{ "SoftFloat32.FPRSqrtEstimateFpscr", new SoftFloat32FPRSqrtEstimateFpscrDelegate(SoftFloat32.FPRSqrtEstimateFpscr) },
{ "SoftFloat32.FPRSqrtStep", new SoftFloat32FPRSqrtStepDelegate(SoftFloat32.FPRSqrtStep) },
{ "SoftFloat32.FPRSqrtStepFused", new SoftFloat32FPRSqrtStepFusedDelegate(SoftFloat32.FPRSqrtStepFused) },
{ "SoftFloat32.FPSqrt", new SoftFloat32FPSqrtDelegate(SoftFloat32.FPSqrt) },
{ "SoftFloat32.FPSub", new SoftFloat32FPSubDelegate(SoftFloat32.FPSub) },
{ "SoftFloat32_16.FPConvert", new SoftFloat32_16FPConvertDelegate(SoftFloat32_16.FPConvert) },
{ "SoftFloat64.FPAdd", new SoftFloat64FPAddDelegate(SoftFloat64.FPAdd) },
{ "SoftFloat64.FPAddFpscr", new SoftFloat64FPAddFpscrDelegate(SoftFloat64.FPAddFpscr) },
{ "SoftFloat64.FPCompare", new SoftFloat64FPCompareDelegate(SoftFloat64.FPCompare) },
{ "SoftFloat64.FPCompareEQ", new SoftFloat64FPCompareEQDelegate(SoftFloat64.FPCompareEQ) },
{ "SoftFloat64.FPCompareEQFpscr", new SoftFloat64FPCompareEQFpscrDelegate(SoftFloat64.FPCompareEQFpscr) },
{ "SoftFloat64.FPCompareGE", new SoftFloat64FPCompareGEDelegate(SoftFloat64.FPCompareGE) },
{ "SoftFloat64.FPCompareGEFpscr", new SoftFloat64FPCompareGEFpscrDelegate(SoftFloat64.FPCompareGEFpscr) },
{ "SoftFloat64.FPCompareGT", new SoftFloat64FPCompareGTDelegate(SoftFloat64.FPCompareGT) },
{ "SoftFloat64.FPCompareGTFpscr", new SoftFloat64FPCompareGTFpscrDelegate(SoftFloat64.FPCompareGTFpscr) },
{ "SoftFloat64.FPCompareLE", new SoftFloat64FPCompareLEDelegate(SoftFloat64.FPCompareLE) },
{ "SoftFloat64.FPCompareLEFpscr", new SoftFloat64FPCompareLEFpscrDelegate(SoftFloat64.FPCompareLEFpscr) },
{ "SoftFloat64.FPCompareLT", new SoftFloat64FPCompareLTDelegate(SoftFloat64.FPCompareLT) },
{ "SoftFloat64.FPCompareLTFpscr", new SoftFloat64FPCompareLTFpscrDelegate(SoftFloat64.FPCompareLTFpscr) },
{ "SoftFloat64.FPDiv", new SoftFloat64FPDivDelegate(SoftFloat64.FPDiv) },
{ "SoftFloat64.FPMax", new SoftFloat64FPMaxDelegate(SoftFloat64.FPMax) },
{ "SoftFloat64.FPMaxFpscr", new SoftFloat64FPMaxFpscrDelegate(SoftFloat64.FPMaxFpscr) },
{ "SoftFloat64.FPMaxNum", new SoftFloat64FPMaxNumDelegate(SoftFloat64.FPMaxNum) },
{ "SoftFloat64.FPMaxNumFpscr", new SoftFloat64FPMaxNumFpscrDelegate(SoftFloat64.FPMaxNumFpscr) },
{ "SoftFloat64.FPMin", new SoftFloat64FPMinDelegate(SoftFloat64.FPMin) },
{ "SoftFloat64.FPMinFpscr", new SoftFloat64FPMinFpscrDelegate(SoftFloat64.FPMinFpscr) },
{ "SoftFloat64.FPMinNum", new SoftFloat64FPMinNumDelegate(SoftFloat64.FPMinNum) },
{ "SoftFloat64.FPMinNumFpscr", new SoftFloat64FPMinNumFpscrDelegate(SoftFloat64.FPMinNumFpscr) },
{ "SoftFloat64.FPMul", new SoftFloat64FPMulDelegate(SoftFloat64.FPMul) },
{ "SoftFloat64.FPMulFpscr", new SoftFloat64FPMulFpscrDelegate(SoftFloat64.FPMulFpscr) },
{ "SoftFloat64.FPMulAdd", new SoftFloat64FPMulAddDelegate(SoftFloat64.FPMulAdd) },
{ "SoftFloat64.FPMulAddFpscr", new SoftFloat64FPMulAddFpscrDelegate(SoftFloat64.FPMulAddFpscr) },
{ "SoftFloat64.FPMulSub", new SoftFloat64FPMulSubDelegate(SoftFloat64.FPMulSub) },
{ "SoftFloat64.FPMulSubFpscr", new SoftFloat64FPMulSubFpscrDelegate(SoftFloat64.FPMulSubFpscr) },
{ "SoftFloat64.FPMulX", new SoftFloat64FPMulXDelegate(SoftFloat64.FPMulX) },
{ "SoftFloat64.FPNegMulAdd", new SoftFloat64FPNegMulAddDelegate(SoftFloat64.FPNegMulAdd) },
{ "SoftFloat64.FPNegMulSub", new SoftFloat64FPNegMulSubDelegate(SoftFloat64.FPNegMulSub) },
{ "SoftFloat64.FPRecipEstimate", new SoftFloat64FPRecipEstimateDelegate(SoftFloat64.FPRecipEstimate) },
{ "SoftFloat64.FPRecipEstimateFpscr", new SoftFloat64FPRecipEstimateFpscrDelegate(SoftFloat64.FPRecipEstimateFpscr) },
{ "SoftFloat64.FPRecipStep", new SoftFloat64FPRecipStepDelegate(SoftFloat64.FPRecipStep) },
{ "SoftFloat64.FPRecipStepFused", new SoftFloat64FPRecipStepFusedDelegate(SoftFloat64.FPRecipStepFused) },
{ "SoftFloat64.FPRecpX", new SoftFloat64FPRecpXDelegate(SoftFloat64.FPRecpX) },
{ "SoftFloat64.FPRSqrtEstimate", new SoftFloat64FPRSqrtEstimateDelegate(SoftFloat64.FPRSqrtEstimate) },
{ "SoftFloat64.FPRSqrtEstimateFpscr", new SoftFloat64FPRSqrtEstimateFpscrDelegate(SoftFloat64.FPRSqrtEstimateFpscr) },
{ "SoftFloat64.FPRSqrtStep", new SoftFloat64FPRSqrtStepDelegate(SoftFloat64.FPRSqrtStep) },
{ "SoftFloat64.FPRSqrtStepFused", new SoftFloat64FPRSqrtStepFusedDelegate(SoftFloat64.FPRSqrtStepFused) },
{ "SoftFloat64.FPSqrt", new SoftFloat64FPSqrtDelegate(SoftFloat64.FPSqrt) },
{ "SoftFloat64.FPSub", new SoftFloat64FPSubDelegate(SoftFloat64.FPSub) },
{ "SoftFloat64_16.FPConvert", new SoftFloat64_16FPConvertDelegate(SoftFloat64_16.FPConvert) }
};
#endif
SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Abs))); SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Abs)));
SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Ceiling))); SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Ceiling)));
SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Floor))); SetDelegateInfo(typeof(MathHelper).GetMethod(nameof(MathHelper.Floor)));
@ -152,44 +708,44 @@ namespace ARMeilleure.Translation
SetDelegateInfo(typeof(SoftFloat16_64).GetMethod(nameof(SoftFloat16_64.FPConvert))); SetDelegateInfo(typeof(SoftFloat16_64).GetMethod(nameof(SoftFloat16_64.FPConvert)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAdd))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAdd)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAddFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAddFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompare))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompare)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQ))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQ)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGE))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGE)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGEFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGEFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGT))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGT)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGTFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGTFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLE))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLE)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLEFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLEFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLT))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLT)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLTFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLTFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPDiv))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPDiv)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMax))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMax)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNum))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNum)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNumFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNumFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMin))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMin)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNum))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNum)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNumFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNumFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMul))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMul)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAdd))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAdd)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAddFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAddFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSub))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSub)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSubFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSubFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulX))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulX)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulAdd))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulAdd)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulSub))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulSub)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimate))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimate)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimateFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimateFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStep))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStep)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStepFused))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStepFused)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecpX))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecpX)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimate))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimate)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimateFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimateFpscr)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStep))); // A32 only. SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStep)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStepFused))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStepFused)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSqrt))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSqrt)));
SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSub))); SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSub)));
@ -197,44 +753,44 @@ namespace ARMeilleure.Translation
SetDelegateInfo(typeof(SoftFloat32_16).GetMethod(nameof(SoftFloat32_16.FPConvert))); SetDelegateInfo(typeof(SoftFloat32_16).GetMethod(nameof(SoftFloat32_16.FPConvert)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAdd))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAdd)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAddFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAddFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompare))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompare)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQ))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQ)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGE))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGE)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGEFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGEFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGT))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGT)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGTFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGTFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLE))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLE)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLEFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLEFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLT))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLT)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLTFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLTFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPDiv))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPDiv)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMax))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMax)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNum))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNum)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNumFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNumFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMin))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMin)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNum))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNum)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNumFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNumFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMul))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMul)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAdd))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAdd)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAddFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAddFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSub))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSub)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSubFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSubFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulX))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulX)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulAdd))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulAdd)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulSub))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulSub)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimate))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimate)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimateFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimateFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStep))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStep)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStepFused))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStepFused)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecpX))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecpX)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimate))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimate)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimateFpscr))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimateFpscr)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStep))); // A32 only. SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStep)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStepFused))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStepFused)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSqrt))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSqrt)));
SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSub))); SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSub)));

7
src/ARMeilleure/Translation/EmitterContext.cs
View file

@ -97,7 +97,14 @@ namespace ARMeilleure.Translation
public virtual Operand Call(MethodInfo info, params Operand[] callArgs) public virtual Operand Call(MethodInfo info, params Operand[] callArgs)
{ {
#if ANDROID
// For Android, use the Delegates class to get the function pointer
int index = Delegates.GetDelegateIndex(info);
IntPtr funcPtr = Delegates.GetDelegateFuncPtrByIndex(index);
#else
// For other platforms, use direct method handle approach
IntPtr funcPtr = info.MethodHandle.GetFunctionPointer(); IntPtr funcPtr = info.MethodHandle.GetFunctionPointer();
#endif
OperandType returnType = GetOperandType(info.ReturnType); OperandType returnType = GetOperandType(info.ReturnType);