From 16de171c44b01c18206d6ff1137d3ab56eb0234a Mon Sep 17 00:00:00 2001
From: LDj3SNuD <35856442+LDj3SNuD@users.noreply.github.com>
Date: Fri, 26 Apr 2019 00:58:29 +0200
Subject: [PATCH] Sse optimized the Scalar & Vector fp-to-fp conversion
instructions (MNPZ & IX); added the related Tests (AMNPZ & IX). Small
refactoring of existing instructions. (#676)
* Nit.
* Update InstEmitSimdCvt.cs
* Update VectorHelper.cs
* Update InstEmitSimdArithmetic.cs
* Update CpuTestSimd.cs
* Superseded.
---
.../Instructions/InstEmitSimdArithmetic.cs | 298 +++++++--
ChocolArm64/Instructions/InstEmitSimdCvt.cs | 38 +-
.../Instructions/InstEmitSimdHelper.cs | 4 +-
ChocolArm64/Instructions/VectorHelper.cs | 160 ++++-
Ryujinx.Tests/Cpu/CpuTestSimd.cs | 220 +++++++
Ryujinx.Tests/Cpu/CpuTestSimdArithmetic.cs | 585 ------------------
6 files changed, 628 insertions(+), 677 deletions(-)
delete mode 100644 Ryujinx.Tests/Cpu/CpuTestSimdArithmetic.cs
diff --git a/ChocolArm64/Instructions/InstEmitSimdArithmetic.cs b/ChocolArm64/Instructions/InstEmitSimdArithmetic.cs
index d2d87beffe..357d88b5db 100644
--- a/ChocolArm64/Instructions/InstEmitSimdArithmetic.cs
+++ b/ChocolArm64/Instructions/InstEmitSimdArithmetic.cs
@@ -1382,13 +1382,10 @@ namespace ChocolArm64.Instructions
public static void Frinta_S(ILEmitterCtx context)
{
- OpCodeSimd64 op = (OpCodeSimd64)context.CurrOp;
-
- EmitVectorExtractF(context, op.Rn, 0, op.Size);
-
- EmitRoundMathCall(context, MidpointRounding.AwayFromZero);
-
- EmitScalarSetF(context, op.Rd, op.Size);
+ EmitScalarUnaryOpF(context, () =>
+ {
+ EmitRoundMathCall(context, MidpointRounding.AwayFromZero);
+ });
}
public static void Frinta_V(ILEmitterCtx context)
@@ -1403,23 +1400,40 @@ namespace ChocolArm64.Instructions
{
OpCodeSimd64 op = (OpCodeSimd64)context.CurrOp;
- EmitScalarUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
+ VectorHelper.EmitCall(context, nameof(VectorHelper.VectorSingleZero));
+ context.EmitLdvec(op.Rn);
+
context.EmitLdarg(TranslatedSub.StateArgIdx);
if (op.Size == 0)
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41ScalarRoundF));
}
- else if (op.Size == 1)
+ else /* if (op.Size == 1) */
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41ScalarRound));
}
- else
+
+ context.EmitStvec(op.Rd);
+ }
+ else
+ {
+ EmitScalarUnaryOpF(context, () =>
{
- throw new InvalidOperationException();
- }
- });
+ context.EmitLdarg(TranslatedSub.StateArgIdx);
+
+ if (op.Size == 0)
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ }
+ else /* if (op.Size == 1) */
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ }
+ });
+ }
}
public static void Frinti_V(ILEmitterCtx context)
@@ -1428,136 +1442,250 @@ namespace ChocolArm64.Instructions
int sizeF = op.Size & 1;
- EmitVectorUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
+ context.EmitLdvec(op.Rn);
+
context.EmitLdarg(TranslatedSub.StateArgIdx);
if (sizeF == 0)
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41VectorRoundF));
}
- else if (sizeF == 1)
+ else /* if (sizeF == 1) */
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41VectorRound));
}
- else
+
+ context.EmitStvec(op.Rd);
+
+ if (sizeF == 0 && op.RegisterSize == RegisterSize.Simd64)
{
- throw new InvalidOperationException();
+ EmitVectorZeroUpper(context, op.Rd);
}
- });
+ }
+ else
+ {
+ EmitVectorUnaryOpF(context, () =>
+ {
+ context.EmitLdarg(TranslatedSub.StateArgIdx);
+
+ if (sizeF == 0)
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ }
+ else /* if (sizeF == 1) */
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ }
+ });
+ }
}
public static void Frintm_S(ILEmitterCtx context)
{
- EmitScalarUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
- EmitUnaryMathCall(context, nameof(Math.Floor));
- });
+ EmitSse41Frint(context, RoundMode.TowardsMinusInfinity, scalar: true);
+ }
+ else
+ {
+ EmitScalarUnaryOpF(context, () =>
+ {
+ EmitUnaryMathCall(context, nameof(Math.Floor));
+ });
+ }
}
public static void Frintm_V(ILEmitterCtx context)
{
- EmitVectorUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
- EmitUnaryMathCall(context, nameof(Math.Floor));
- });
+ EmitSse41Frint(context, RoundMode.TowardsMinusInfinity, scalar: false);
+ }
+ else
+ {
+ EmitVectorUnaryOpF(context, () =>
+ {
+ EmitUnaryMathCall(context, nameof(Math.Floor));
+ });
+ }
}
public static void Frintn_S(ILEmitterCtx context)
{
- OpCodeSimd64 op = (OpCodeSimd64)context.CurrOp;
-
- EmitVectorExtractF(context, op.Rn, 0, op.Size);
-
- EmitRoundMathCall(context, MidpointRounding.ToEven);
-
- EmitScalarSetF(context, op.Rd, op.Size);
+ if (Optimizations.UseSse41)
+ {
+ EmitSse41Frint(context, RoundMode.ToNearest, scalar: true);
+ }
+ else
+ {
+ EmitScalarUnaryOpF(context, () =>
+ {
+ EmitRoundMathCall(context, MidpointRounding.ToEven);
+ });
+ }
}
public static void Frintn_V(ILEmitterCtx context)
{
- EmitVectorUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
- EmitRoundMathCall(context, MidpointRounding.ToEven);
- });
+ EmitSse41Frint(context, RoundMode.ToNearest, scalar: false);
+ }
+ else
+ {
+ EmitVectorUnaryOpF(context, () =>
+ {
+ EmitRoundMathCall(context, MidpointRounding.ToEven);
+ });
+ }
}
public static void Frintp_S(ILEmitterCtx context)
{
- EmitScalarUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
- EmitUnaryMathCall(context, nameof(Math.Ceiling));
- });
+ EmitSse41Frint(context, RoundMode.TowardsPlusInfinity, scalar: true);
+ }
+ else
+ {
+ EmitScalarUnaryOpF(context, () =>
+ {
+ EmitUnaryMathCall(context, nameof(Math.Ceiling));
+ });
+ }
}
public static void Frintp_V(ILEmitterCtx context)
{
- EmitVectorUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
- EmitUnaryMathCall(context, nameof(Math.Ceiling));
- });
+ EmitSse41Frint(context, RoundMode.TowardsPlusInfinity, scalar: false);
+ }
+ else
+ {
+ EmitVectorUnaryOpF(context, () =>
+ {
+ EmitUnaryMathCall(context, nameof(Math.Ceiling));
+ });
+ }
}
public static void Frintx_S(ILEmitterCtx context)
{
OpCodeSimd64 op = (OpCodeSimd64)context.CurrOp;
- EmitScalarUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
+ VectorHelper.EmitCall(context, nameof(VectorHelper.VectorSingleZero));
+ context.EmitLdvec(op.Rn);
+
context.EmitLdarg(TranslatedSub.StateArgIdx);
if (op.Size == 0)
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41ScalarRoundF));
}
- else if (op.Size == 1)
+ else /* if (op.Size == 1) */
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41ScalarRound));
}
- else
+
+ context.EmitStvec(op.Rd);
+ }
+ else
+ {
+ EmitScalarUnaryOpF(context, () =>
{
- throw new InvalidOperationException();
- }
- });
+ context.EmitLdarg(TranslatedSub.StateArgIdx);
+
+ if (op.Size == 0)
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ }
+ else /* if (op.Size == 1) */
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ }
+ });
+ }
}
public static void Frintx_V(ILEmitterCtx context)
{
OpCodeSimd64 op = (OpCodeSimd64)context.CurrOp;
- EmitVectorUnaryOpF(context, () =>
+ int sizeF = op.Size & 1;
+
+ if (Optimizations.UseSse41)
{
+ context.EmitLdvec(op.Rn);
+
context.EmitLdarg(TranslatedSub.StateArgIdx);
- if (op.Size == 0)
+ if (sizeF == 0)
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41VectorRoundF));
}
- else if (op.Size == 1)
+ else /* if (sizeF == 1) */
{
- VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Sse41VectorRound));
}
- else
+
+ context.EmitStvec(op.Rd);
+
+ if (sizeF == 0 && op.RegisterSize == RegisterSize.Simd64)
{
- throw new InvalidOperationException();
+ EmitVectorZeroUpper(context, op.Rd);
}
- });
+ }
+ else
+ {
+ EmitVectorUnaryOpF(context, () =>
+ {
+ context.EmitLdarg(TranslatedSub.StateArgIdx);
+
+ if (sizeF == 0)
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.RoundF));
+ }
+ else /* if (sizeF == 1) */
+ {
+ VectorHelper.EmitCall(context, nameof(VectorHelper.Round));
+ }
+ });
+ }
}
public static void Frintz_S(ILEmitterCtx context)
{
- EmitScalarUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
- EmitUnaryMathCall(context, nameof(Math.Truncate));
- });
+ EmitSse41Frint(context, RoundMode.TowardsZero, scalar: true);
+ }
+ else
+ {
+ EmitScalarUnaryOpF(context, () =>
+ {
+ EmitUnaryMathCall(context, nameof(Math.Truncate));
+ });
+ }
}
public static void Frintz_V(ILEmitterCtx context)
{
- EmitVectorUnaryOpF(context, () =>
+ if (Optimizations.UseSse41)
{
- EmitUnaryMathCall(context, nameof(Math.Truncate));
- });
+ EmitSse41Frint(context, RoundMode.TowardsZero, scalar: false);
+ }
+ else
+ {
+ EmitVectorUnaryOpF(context, () =>
+ {
+ EmitUnaryMathCall(context, nameof(Math.Truncate));
+ });
+ }
}
public static void Frsqrte_S(ILEmitterCtx context)
@@ -3542,6 +3670,44 @@ namespace ChocolArm64.Instructions
}
}
+ private static void EmitSse41Frint(ILEmitterCtx context, RoundMode roundMode, bool scalar)
+ {
+ OpCodeSimd64 op = (OpCodeSimd64)context.CurrOp;
+
+ if (scalar)
+ {
+ Type[] typesRnd = op.Size == 0
+ ? new Type[] { typeof(Vector128<float>), typeof(Vector128<float>) }
+ : new Type[] { typeof(Vector128<double>), typeof(Vector128<double>) };
+
+ VectorHelper.EmitCall(context, nameof(VectorHelper.VectorSingleZero));
+ context.EmitLdvec(op.Rn);
+
+ context.EmitCall(typeof(Sse41).GetMethod(GetScalarSse41NameRnd(roundMode), typesRnd));
+
+ context.EmitStvec(op.Rd);
+ }
+ else
+ {
+ int sizeF = op.Size & 1;
+
+ Type[] typesRnd = sizeF == 0
+ ? new Type[] { typeof(Vector128<float>) }
+ : new Type[] { typeof(Vector128<double>) };
+
+ context.EmitLdvec(op.Rn);
+
+ context.EmitCall(typeof(Sse41).GetMethod(GetVectorSse41NameRnd(roundMode), typesRnd));
+
+ context.EmitStvec(op.Rd);
+
+ if (sizeF == 0 && op.RegisterSize == RegisterSize.Simd64)
+ {
+ EmitVectorZeroUpper(context, op.Rd);
+ }
+ }
+ }
+
private static void EmitSse41Mul_AddSub(ILEmitterCtx context, string nameAddSub = null)
{
OpCodeSimdReg64 op = (OpCodeSimdReg64)context.CurrOp;
diff --git a/ChocolArm64/Instructions/InstEmitSimdCvt.cs b/ChocolArm64/Instructions/InstEmitSimdCvt.cs
index c5f16f86cb..b34687e1c3 100644
--- a/ChocolArm64/Instructions/InstEmitSimdCvt.cs
+++ b/ChocolArm64/Instructions/InstEmitSimdCvt.cs
@@ -898,7 +898,7 @@ namespace ChocolArm64.Instructions
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.Multiply), types));
}
- context.EmitCall(typeof(Sse41).GetMethod(GetSse41NameRnd(roundMode), typesRndCvt));
+ context.EmitCall(typeof(Sse41).GetMethod(GetVectorSse41NameRnd(roundMode), typesRndCvt));
context.EmitStvectmp();
context.EmitLdvectmp();
@@ -954,7 +954,7 @@ namespace ChocolArm64.Instructions
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.Multiply), types));
}
- context.EmitCall(typeof(Sse41).GetMethod(GetSse41NameRnd(roundMode), typesRndCvt));
+ context.EmitCall(typeof(Sse41).GetMethod(GetVectorSse41NameRnd(roundMode), typesRndCvt));
context.EmitStvectmp();
@@ -1032,7 +1032,7 @@ namespace ChocolArm64.Instructions
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.Multiply), types));
}
- context.EmitCall(typeof(Sse41).GetMethod(GetSse41NameRnd(roundMode), typesRndCvt));
+ context.EmitCall(typeof(Sse41).GetMethod(GetVectorSse41NameRnd(roundMode), typesRndCvt));
context.Emit(OpCodes.Dup);
@@ -1120,7 +1120,7 @@ namespace ChocolArm64.Instructions
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.Multiply), types));
}
- context.EmitCall(typeof(Sse41).GetMethod(GetSse41NameRnd(roundMode), typesRndCvt));
+ context.EmitCall(typeof(Sse41).GetMethod(GetVectorSse41NameRnd(roundMode), typesRndCvt));
context.Emit(OpCodes.Dup);
@@ -1305,23 +1305,39 @@ namespace ChocolArm64.Instructions
}
}
- private static string GetSse41NameRnd(RoundMode roundMode)
+ private static string GetScalarSse41NameRnd(RoundMode roundMode)
+ {
+ switch (roundMode)
+ {
+ case RoundMode.ToNearest:
+ return nameof(Sse41.RoundToNearestIntegerScalar); // even
+
+ case RoundMode.TowardsPlusInfinity:
+ return nameof(Sse41.RoundToPositiveInfinityScalar);
+
+ case RoundMode.TowardsMinusInfinity:
+ return nameof(Sse41.RoundToNegativeInfinityScalar);
+
+ default: /* case RoundMode.TowardsZero: */
+ return nameof(Sse41.RoundToZeroScalar);
+ }
+ }
+
+ private static string GetVectorSse41NameRnd(RoundMode roundMode)
{
switch (roundMode)
{
case RoundMode.ToNearest:
return nameof(Sse41.RoundToNearestInteger); // even
- case RoundMode.TowardsMinusInfinity:
- return nameof(Sse41.RoundToNegativeInfinity);
-
case RoundMode.TowardsPlusInfinity:
return nameof(Sse41.RoundToPositiveInfinity);
- case RoundMode.TowardsZero:
- return nameof(Sse41.RoundToZero);
+ case RoundMode.TowardsMinusInfinity:
+ return nameof(Sse41.RoundToNegativeInfinity);
- default: throw new ArgumentException(nameof(roundMode));
+ default: /* case RoundMode.TowardsZero: */
+ return nameof(Sse41.RoundToZero);
}
}
}
diff --git a/ChocolArm64/Instructions/InstEmitSimdHelper.cs b/ChocolArm64/Instructions/InstEmitSimdHelper.cs
index 6799a3a388..2bcda35f32 100644
--- a/ChocolArm64/Instructions/InstEmitSimdHelper.cs
+++ b/ChocolArm64/Instructions/InstEmitSimdHelper.cs
@@ -237,7 +237,9 @@ namespace ChocolArm64.Instructions
{
IOpCodeSimd64 op = (IOpCodeSimd64)context.CurrOp;
- Type type = (op.Size & 1) == 0
+ int sizeF = op.Size & 1;
+
+ Type type = sizeF == 0
? typeof(SoftFloat32)
: typeof(SoftFloat64);
diff --git a/ChocolArm64/Instructions/VectorHelper.cs b/ChocolArm64/Instructions/VectorHelper.cs
index d1dfaced41..3e2b258a15 100644
--- a/ChocolArm64/Instructions/VectorHelper.cs
+++ b/ChocolArm64/Instructions/VectorHelper.cs
@@ -93,30 +93,162 @@ namespace ChocolArm64.Instructions
value <= ulong.MinValue ? ulong.MinValue : (ulong)value;
}
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double Round(double value, CpuThreadState state)
{
- switch (state.FPRoundingMode())
- {
- case RoundMode.ToNearest: return Math.Round (value);
- case RoundMode.TowardsPlusInfinity: return Math.Ceiling (value);
- case RoundMode.TowardsMinusInfinity: return Math.Floor (value);
- case RoundMode.TowardsZero: return Math.Truncate(value);
- }
+ RoundMode roundMode = state.FPRoundingMode();
- throw new InvalidOperationException();
+ if (roundMode == RoundMode.ToNearest)
+ {
+ return Math.Round(value); // even
+ }
+ else if (roundMode == RoundMode.TowardsPlusInfinity)
+ {
+ return Math.Ceiling(value);
+ }
+ else if (roundMode == RoundMode.TowardsMinusInfinity)
+ {
+ return Math.Floor(value);
+ }
+ else /* if (roundMode == RoundMode.TowardsZero) */
+ {
+ return Math.Truncate(value);
+ }
}
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float RoundF(float value, CpuThreadState state)
{
- switch (state.FPRoundingMode())
+ RoundMode roundMode = state.FPRoundingMode();
+
+ if (roundMode == RoundMode.ToNearest)
{
- case RoundMode.ToNearest: return MathF.Round (value);
- case RoundMode.TowardsPlusInfinity: return MathF.Ceiling (value);
- case RoundMode.TowardsMinusInfinity: return MathF.Floor (value);
- case RoundMode.TowardsZero: return MathF.Truncate(value);
+ return MathF.Round(value); // even
+ }
+ else if (roundMode == RoundMode.TowardsPlusInfinity)
+ {
+ return MathF.Ceiling(value);
+ }
+ else if (roundMode == RoundMode.TowardsMinusInfinity)
+ {
+ return MathF.Floor(value);
+ }
+ else /* if (roundMode == RoundMode.TowardsZero) */
+ {
+ return MathF.Truncate(value);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static Vector128<double> Sse41ScalarRound(Vector128<double> upper, Vector128<double> value, CpuThreadState state)
+ {
+ if (!Sse41.IsSupported)
+ {
+ throw new PlatformNotSupportedException();
}
- throw new InvalidOperationException();
+ RoundMode roundMode = state.FPRoundingMode();
+
+ if (roundMode == RoundMode.ToNearest)
+ {
+ return Sse41.RoundToNearestIntegerScalar(upper, value); // even
+ }
+ else if (roundMode == RoundMode.TowardsPlusInfinity)
+ {
+ return Sse41.RoundToPositiveInfinityScalar(upper, value);
+ }
+ else if (roundMode == RoundMode.TowardsMinusInfinity)
+ {
+ return Sse41.RoundToNegativeInfinityScalar(upper, value);
+ }
+ else /* if (roundMode == RoundMode.TowardsZero) */
+ {
+ return Sse41.RoundToZeroScalar(upper, value);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static Vector128<float> Sse41ScalarRoundF(Vector128<float> upper, Vector128<float> value, CpuThreadState state)
+ {
+ if (!Sse41.IsSupported)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ RoundMode roundMode = state.FPRoundingMode();
+
+ if (roundMode == RoundMode.ToNearest)
+ {
+ return Sse41.RoundToNearestIntegerScalar(upper, value); // even
+ }
+ else if (roundMode == RoundMode.TowardsPlusInfinity)
+ {
+ return Sse41.RoundToPositiveInfinityScalar(upper, value);
+ }
+ else if (roundMode == RoundMode.TowardsMinusInfinity)
+ {
+ return Sse41.RoundToNegativeInfinityScalar(upper, value);
+ }
+ else /* if (roundMode == RoundMode.TowardsZero) */
+ {
+ return Sse41.RoundToZeroScalar(upper, value);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static Vector128<double> Sse41VectorRound(Vector128<double> value, CpuThreadState state)
+ {
+ if (!Sse41.IsSupported)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ RoundMode roundMode = state.FPRoundingMode();
+
+ if (roundMode == RoundMode.ToNearest)
+ {
+ return Sse41.RoundToNearestInteger(value); // even
+ }
+ else if (roundMode == RoundMode.TowardsPlusInfinity)
+ {
+ return Sse41.RoundToPositiveInfinity(value);
+ }
+ else if (roundMode == RoundMode.TowardsMinusInfinity)
+ {
+ return Sse41.RoundToNegativeInfinity(value);
+ }
+ else /* if (roundMode == RoundMode.TowardsZero) */
+ {
+ return Sse41.RoundToZero(value);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static Vector128<float> Sse41VectorRoundF(Vector128<float> value, CpuThreadState state)
+ {
+ if (!Sse41.IsSupported)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ RoundMode roundMode = state.FPRoundingMode();
+
+ if (roundMode == RoundMode.ToNearest)
+ {
+ return Sse41.RoundToNearestInteger(value); // even
+ }
+ else if (roundMode == RoundMode.TowardsPlusInfinity)
+ {
+ return Sse41.RoundToPositiveInfinity(value);
+ }
+ else if (roundMode == RoundMode.TowardsMinusInfinity)
+ {
+ return Sse41.RoundToNegativeInfinity(value);
+ }
+ else /* if (roundMode == RoundMode.TowardsZero) */
+ {
+ return Sse41.RoundToZero(value);
+ }
}
public static Vector128<float> Tbl1_V64(
diff --git a/Ryujinx.Tests/Cpu/CpuTestSimd.cs b/Ryujinx.Tests/Cpu/CpuTestSimd.cs
index df23f2eff8..25e47778cd 100644
--- a/Ryujinx.Tests/Cpu/CpuTestSimd.cs
+++ b/Ryujinx.Tests/Cpu/CpuTestSimd.cs
@@ -697,6 +697,90 @@ namespace Ryujinx.Tests.Cpu
};
}
+ private static uint[] _F_Rint_AMNPZ_S_S_()
+ {
+ return new uint[]
+ {
+ 0x1E264020u, // FRINTA S0, S1
+ 0x1E254020u, // FRINTM S0, S1
+ 0x1E244020u, // FRINTN S0, S1
+ 0x1E24C020u, // FRINTP S0, S1
+ 0x1E25C020u // FRINTZ S0, S1
+ };
+ }
+
+ private static uint[] _F_Rint_AMNPZ_S_D_()
+ {
+ return new uint[]
+ {
+ 0x1E664020u, // FRINTA D0, D1
+ 0x1E654020u, // FRINTM D0, D1
+ 0x1E644020u, // FRINTN D0, D1
+ 0x1E64C020u, // FRINTP D0, D1
+ 0x1E65C020u // FRINTZ D0, D1
+ };
+ }
+
+ private static uint[] _F_Rint_AMNPZ_V_2S_4S_()
+ {
+ return new uint[]
+ {
+ 0x2E218800u, // FRINTA V0.2S, V0.2S
+ 0x0E219800u, // FRINTM V0.2S, V0.2S
+ 0x0E218800u, // FRINTN V0.2S, V0.2S
+ 0x0EA18800u, // FRINTP V0.2S, V0.2S
+ 0x0EA19800u // FRINTZ V0.2S, V0.2S
+ };
+ }
+
+ private static uint[] _F_Rint_AMNPZ_V_2D_()
+ {
+ return new uint[]
+ {
+ 0x6E618800u, // FRINTA V0.2D, V0.2D
+ 0x4E619800u, // FRINTM V0.2D, V0.2D
+ 0x4E618800u, // FRINTN V0.2D, V0.2D
+ 0x4EE18800u, // FRINTP V0.2D, V0.2D
+ 0x4EE19800u // FRINTZ V0.2D, V0.2D
+ };
+ }
+
+ private static uint[] _F_Rint_IX_S_S_()
+ {
+ return new uint[]
+ {
+ 0x1E27C020u, // FRINTI S0, S1
+ 0x1E274020u // FRINTX S0, S1
+ };
+ }
+
+ private static uint[] _F_Rint_IX_S_D_()
+ {
+ return new uint[]
+ {
+ 0x1E67C020u, // FRINTI D0, D1
+ 0x1E674020u // FRINTX D0, D1
+ };
+ }
+
+ private static uint[] _F_Rint_IX_V_2S_4S_()
+ {
+ return new uint[]
+ {
+ 0x2EA19800u, // FRINTI V0.2S, V0.2S
+ 0x2E219800u // FRINTX V0.2S, V0.2S
+ };
+ }
+
+ private static uint[] _F_Rint_IX_V_2D_()
+ {
+ return new uint[]
+ {
+ 0x6EE19800u, // FRINTI V0.2D, V0.2D
+ 0x6E619800u // FRINTX V0.2D, V0.2D
+ };
+ }
+
private static uint[] _SU_Cvt_F_S_S_()
{
return new uint[]
@@ -1750,6 +1834,142 @@ namespace Ryujinx.Tests.Cpu
CompareAgainstUnicorn(fpsrMask: Fpsr.Ioc | Fpsr.Dzc | Fpsr.Ofc | Fpsr.Ufc | Fpsr.Ixc | Fpsr.Idc);
}
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_AMNPZ_S_S([ValueSource("_F_Rint_AMNPZ_S_S_")] uint opcodes,
+ [ValueSource("_1S_F_")] ulong a)
+ {
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ Vector128<float> v0 = MakeVectorE0E1(z, z);
+ Vector128<float> v1 = MakeVectorE0(a);
+
+ SingleOpcode(opcodes, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_AMNPZ_S_D([ValueSource("_F_Rint_AMNPZ_S_D_")] uint opcodes,
+ [ValueSource("_1D_F_")] ulong a)
+ {
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ Vector128<float> v0 = MakeVectorE1(z);
+ Vector128<float> v1 = MakeVectorE0(a);
+
+ SingleOpcode(opcodes, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_AMNPZ_V_2S_4S([ValueSource("_F_Rint_AMNPZ_V_2S_4S_")] uint opcodes,
+ [Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource("_2S_F_")] ulong z,
+ [ValueSource("_2S_F_")] ulong a,
+ [Values(0b0u, 0b1u)] uint q) // <2S, 4S>
+ {
+ opcodes |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcodes |= ((q & 1) << 30);
+
+ Vector128<float> v0 = MakeVectorE0E1(z, z);
+ Vector128<float> v1 = MakeVectorE0E1(a, a * q);
+
+ SingleOpcode(opcodes, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_AMNPZ_V_2D([ValueSource("_F_Rint_AMNPZ_V_2D_")] uint opcodes,
+ [Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource("_1D_F_")] ulong z,
+ [ValueSource("_1D_F_")] ulong a)
+ {
+ opcodes |= ((rn & 31) << 5) | ((rd & 31) << 0);
+
+ Vector128<float> v0 = MakeVectorE0E1(z, z);
+ Vector128<float> v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcodes, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_IX_S_S([ValueSource("_F_Rint_IX_S_S_")] uint opcodes,
+ [ValueSource("_1S_F_")] ulong a,
+ [Values] RMode rMode)
+ {
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ Vector128<float> v0 = MakeVectorE0E1(z, z);
+ Vector128<float> v1 = MakeVectorE0(a);
+
+ int fpcr = (int)rMode << (int)Fpcr.RMode;
+
+ SingleOpcode(opcodes, v0: v0, v1: v1, fpcr: fpcr);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_IX_S_D([ValueSource("_F_Rint_IX_S_D_")] uint opcodes,
+ [ValueSource("_1D_F_")] ulong a,
+ [Values] RMode rMode)
+ {
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ Vector128<float> v0 = MakeVectorE1(z);
+ Vector128<float> v1 = MakeVectorE0(a);
+
+ int fpcr = (int)rMode << (int)Fpcr.RMode;
+
+ SingleOpcode(opcodes, v0: v0, v1: v1, fpcr: fpcr);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_IX_V_2S_4S([ValueSource("_F_Rint_IX_V_2S_4S_")] uint opcodes,
+ [Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource("_2S_F_")] ulong z,
+ [ValueSource("_2S_F_")] ulong a,
+ [Values(0b0u, 0b1u)] uint q, // <2S, 4S>
+ [Values] RMode rMode)
+ {
+ opcodes |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcodes |= ((q & 1) << 30);
+
+ Vector128<float> v0 = MakeVectorE0E1(z, z);
+ Vector128<float> v1 = MakeVectorE0E1(a, a * q);
+
+ int fpcr = (int)rMode << (int)Fpcr.RMode;
+
+ SingleOpcode(opcodes, v0: v0, v1: v1, fpcr: fpcr);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise] [Explicit]
+ public void F_Rint_IX_V_2D([ValueSource("_F_Rint_IX_V_2D_")] uint opcodes,
+ [Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource("_1D_F_")] ulong z,
+ [ValueSource("_1D_F_")] ulong a,
+ [Values] RMode rMode)
+ {
+ opcodes |= ((rn & 31) << 5) | ((rd & 31) << 0);
+
+ Vector128<float> v0 = MakeVectorE0E1(z, z);
+ Vector128<float> v1 = MakeVectorE0E1(a, a);
+
+ int fpcr = (int)rMode << (int)Fpcr.RMode;
+
+ SingleOpcode(opcodes, v0: v0, v1: v1, fpcr: fpcr);
+
+ CompareAgainstUnicorn();
+ }
+
[Test, Pairwise, Description("NEG <V><d>, <V><n>")]
public void Neg_S_D([Values(0u)] uint rd,
[Values(1u, 0u)] uint rn,
diff --git a/Ryujinx.Tests/Cpu/CpuTestSimdArithmetic.cs b/Ryujinx.Tests/Cpu/CpuTestSimdArithmetic.cs
deleted file mode 100644
index 63e0bda83c..0000000000
--- a/Ryujinx.Tests/Cpu/CpuTestSimdArithmetic.cs
+++ /dev/null
@@ -1,585 +0,0 @@
-using ChocolArm64.State;
-
-using NUnit.Framework;
-
-using System.Runtime.Intrinsics;
-
-namespace Ryujinx.Tests.Cpu
-{
- public class CpuTestSimdArithmetic : CpuTest
- {
- [TestCase(0x3FE66666u, false, 0x40000000u)]
- [TestCase(0x3F99999Au, false, 0x3F800000u)]
- [TestCase(0x404CCCCDu, false, 0x40400000u)]
- [TestCase(0x40733333u, false, 0x40800000u)]
- [TestCase(0x3FC00000u, false, 0x40000000u)]
- [TestCase(0x40200000u, false, 0x40400000u)]
- [TestCase(0x00000000u, false, 0x00000000u)]
- [TestCase(0x80000000u, false, 0x80000000u)]
- [TestCase(0x7F800000u, false, 0x7F800000u)]
- [TestCase(0xFF800000u, false, 0xFF800000u)]
- [TestCase(0xFF800001u, false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, true, 0x7FC00000u, Ignore = "NaN test.")]
- public void Frinta_S(uint a, bool defaultNaN, uint result)
- {
- uint opcode = 0x1E264020; // FRINTA S0, S1
-
- Vector128<float> v1 = MakeVectorE0(a);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result));
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x6E618820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)] // FRINTA V0.2D, V1.2D
- [TestCase(0x6E618820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6E618820u, 0x3FF8000000000000ul, 0x3FF8000000000000ul, false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6E218820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x3F80000040000000ul, 0x3F80000040000000ul)] // FRINTA V0.4S, V1.4S
- [TestCase(0x6E218820u, 0x3FC000003FC00000ul, 0x3FC000003FC00000ul, false, 0x4000000040000000ul, 0x4000000040000000ul)]
- [TestCase(0x2E218820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x3F80000040000000ul, 0x0000000000000000ul)] // FRINTA V0.2S, V1.2S
- [TestCase(0x2E218820u, 0x3FC000003FC00000ul, 0x3FC000003FC00000ul, false, 0x4000000040000000ul, 0x0000000000000000ul)]
- [TestCase(0x2E218820u, 0x0000000080000000ul, 0x0000000000000000ul, false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2E218820u, 0x7F800000FF800000ul, 0x0000000000000000ul, false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2E218820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E218820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- public void Frinta_V(uint opcode, ulong a, ulong b, bool defaultNaN, ulong result0, ulong result1)
- {
- Vector128<float> v1 = MakeVectorE0E1(a, b);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.Multiple(() =>
- {
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result0));
- Assert.That(GetVectorE1(threadState.V0), Is.EqualTo(result1));
- });
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x3FE66666u, 'N', false, 0x40000000u)]
- [TestCase(0x3F99999Au, 'N', false, 0x3F800000u)]
- [TestCase(0x404CCCCDu, 'P', false, 0x40800000u)]
- [TestCase(0x40733333u, 'P', false, 0x40800000u)]
- [TestCase(0x404CCCCDu, 'M', false, 0x40400000u)]
- [TestCase(0x40733333u, 'M', false, 0x40400000u)]
- [TestCase(0x3F99999Au, 'Z', false, 0x3F800000u)]
- [TestCase(0x3FE66666u, 'Z', false, 0x3F800000u)]
- [TestCase(0x00000000u, 'N', false, 0x00000000u)]
- [TestCase(0x00000000u, 'P', false, 0x00000000u)]
- [TestCase(0x00000000u, 'M', false, 0x00000000u)]
- [TestCase(0x00000000u, 'Z', false, 0x00000000u)]
- [TestCase(0x80000000u, 'N', false, 0x80000000u)]
- [TestCase(0x80000000u, 'P', false, 0x80000000u)]
- [TestCase(0x80000000u, 'M', false, 0x80000000u)]
- [TestCase(0x80000000u, 'Z', false, 0x80000000u)]
- [TestCase(0x7F800000u, 'N', false, 0x7F800000u)]
- [TestCase(0x7F800000u, 'P', false, 0x7F800000u)]
- [TestCase(0x7F800000u, 'M', false, 0x7F800000u)]
- [TestCase(0x7F800000u, 'Z', false, 0x7F800000u)]
- [TestCase(0xFF800000u, 'N', false, 0xFF800000u)]
- [TestCase(0xFF800000u, 'P', false, 0xFF800000u)]
- [TestCase(0xFF800000u, 'M', false, 0xFF800000u)]
- [TestCase(0xFF800000u, 'Z', false, 0xFF800000u)]
- [TestCase(0xFF800001u, 'N', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'P', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'M', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'Z', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'N', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'P', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'M', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'Z', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'N', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'P', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'M', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'Z', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'N', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'P', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'M', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'Z', true, 0x7FC00000u, Ignore = "NaN test.")]
- public void Frinti_S(uint a, char roundMode, bool defaultNaN, uint result)
- {
- uint opcode = 0x1E27C020; // FRINTI S0, S1
-
- Vector128<float> v1 = MakeVectorE0(a);
-
- int fpcrTemp = 0x0;
-
- switch (roundMode)
- {
- case 'N': fpcrTemp = 0x0; break;
- case 'P': fpcrTemp = 0x400000; break;
- case 'M': fpcrTemp = 0x800000; break;
- case 'Z': fpcrTemp = 0xC00000; break;
- }
-
- if (defaultNaN)
- {
- fpcrTemp |= 1 << 25;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result));
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x6EE19820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'N', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)] // FRINTI V0.2D, V1.2D
- [TestCase(0x6EE19820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'N', false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6EE19820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'P', false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6EE19820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'P', false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6EE19820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'M', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6EE19820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'M', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6EE19820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'Z', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6EE19820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'Z', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'N', false, 0x3F80000040000000ul, 0x3F80000040000000ul)] // FRINTI V0.4S, V1.4S
- [TestCase(0x6EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'P', false, 0x4000000040000000ul, 0x4000000040000000ul)]
- [TestCase(0x6EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'M', false, 0x3F8000003F800000ul, 0x3F8000003F800000ul)]
- [TestCase(0x6EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'Z', false, 0x3F8000003F800000ul, 0x3F8000003F800000ul)]
- [TestCase(0x2EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'N', false, 0x3F80000040000000ul, 0x0000000000000000ul)] // FRINTI V0.2S, V1.2S
- [TestCase(0x2EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'P', false, 0x4000000040000000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'M', false, 0x3F8000003F800000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'Z', false, 0x3F8000003F800000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x0000000080000000ul, 0x0000000000000000ul, 'N', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x0000000080000000ul, 0x0000000000000000ul, 'P', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x0000000080000000ul, 0x0000000000000000ul, 'M', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x0000000080000000ul, 0x0000000000000000ul, 'Z', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'N', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'P', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'M', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'Z', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'N', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'P', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'M', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'Z', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'N', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'P', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'M', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'Z', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- public void Frinti_V(uint opcode, ulong a, ulong b, char roundMode, bool defaultNaN, ulong result0, ulong result1)
- {
- Vector128<float> v1 = MakeVectorE0E1(a, b);
-
- int fpcrTemp = 0x0;
-
- switch (roundMode)
- {
- case 'N': fpcrTemp = 0x0; break;
- case 'P': fpcrTemp = 0x400000; break;
- case 'M': fpcrTemp = 0x800000; break;
- case 'Z': fpcrTemp = 0xC00000; break;
- }
-
- if (defaultNaN)
- {
- fpcrTemp |= 1 << 25;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.Multiple(() =>
- {
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result0));
- Assert.That(GetVectorE1(threadState.V0), Is.EqualTo(result1));
- });
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x3FE66666u, false, 0x3F800000u)]
- [TestCase(0x3F99999Au, false, 0x3F800000u)]
- [TestCase(0x404CCCCDu, false, 0x40400000u)]
- [TestCase(0x40733333u, false, 0x40400000u)]
- [TestCase(0x3FC00000u, false, 0x3F800000u)]
- [TestCase(0x40200000u, false, 0x40000000u)]
- [TestCase(0x00000000u, false, 0x00000000u)]
- [TestCase(0x80000000u, false, 0x80000000u)]
- [TestCase(0x7F800000u, false, 0x7F800000u)]
- [TestCase(0xFF800000u, false, 0xFF800000u)]
- [TestCase(0xFF800001u, false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, true, 0x7FC00000u, Ignore = "NaN test.")]
- public void Frintm_S(uint a, bool defaultNaN, uint result)
- {
- uint opcode = 0x1E254020; // FRINTM S0, S1
-
- Vector128<float> v1 = MakeVectorE0(a);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result));
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x4E619820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)] // FRINTM V0.2D, V1.2D
- [TestCase(0x4E619820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x4E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x3F8000003F800000ul, 0x3F8000003F800000ul)] // FRINTM V0.4S, V1.4S
- [TestCase(0x0E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x3F8000003F800000ul, 0x0000000000000000ul)] // FRINTM V0.2S, V1.2S
- [TestCase(0x0E219820u, 0x0000000080000000ul, 0x0000000000000000ul, false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x0E219820u, 0x7F800000FF800000ul, 0x0000000000000000ul, false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x0E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x0E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- public void Frintm_V(uint opcode, ulong a, ulong b, bool defaultNaN, ulong result0, ulong result1)
- {
- Vector128<float> v1 = MakeVectorE0E1(a, b);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.Multiple(() =>
- {
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result0));
- Assert.That(GetVectorE1(threadState.V0), Is.EqualTo(result1));
- });
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x3FE66666u, false, 0x40000000u)]
- [TestCase(0x3F99999Au, false, 0x3F800000u)]
- [TestCase(0x404CCCCDu, false, 0x40400000u)]
- [TestCase(0x40733333u, false, 0x40800000u)]
- [TestCase(0x3FC00000u, false, 0x40000000u)]
- [TestCase(0x40200000u, false, 0x40000000u)]
- [TestCase(0x00000000u, false, 0x00000000u)]
- [TestCase(0x80000000u, false, 0x80000000u)]
- [TestCase(0x7F800000u, false, 0x7F800000u)]
- [TestCase(0xFF800000u, false, 0xFF800000u)]
- [TestCase(0xFF800001u, false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, true, 0x7FC00000u, Ignore = "NaN test.")]
- public void Frintn_S(uint a, bool defaultNaN, uint result)
- {
- uint opcode = 0x1E244020; // FRINTN S0, S1
-
- Vector128<float> v1 = MakeVectorE0(a);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result));
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x4E618820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)] // FRINTN V0.2D, V1.2D
- [TestCase(0x4E618820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x4E618820u, 0x3FF8000000000000ul, 0x3FF8000000000000ul, false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x4E218820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x3F80000040000000ul, 0x3F80000040000000ul)] // FRINTN V0.4S, V1.4S
- [TestCase(0x4E218820u, 0x3FC000003FC00000ul, 0x3FC000003FC00000ul, false, 0x4000000040000000ul, 0x4000000040000000ul)]
- [TestCase(0x0E218820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x3F80000040000000ul, 0x0000000000000000ul)] // FRINTN V0.2S, V1.2S
- [TestCase(0x0E218820u, 0x3FC000003FC00000ul, 0x3FC000003FC00000ul, false, 0x4000000040000000ul, 0x0000000000000000ul)]
- [TestCase(0x0E218820u, 0x0000000080000000ul, 0x0000000000000000ul, false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x0E218820u, 0x7F800000FF800000ul, 0x0000000000000000ul, false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x0E218820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x0E218820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- public void Frintn_V(uint opcode, ulong a, ulong b, bool defaultNaN, ulong result0, ulong result1)
- {
- Vector128<float> v1 = MakeVectorE0E1(a, b);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.Multiple(() =>
- {
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result0));
- Assert.That(GetVectorE1(threadState.V0), Is.EqualTo(result1));
- });
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x3FE66666u, false, 0x40000000u)]
- [TestCase(0x3F99999Au, false, 0x40000000u)]
- [TestCase(0x404CCCCDu, false, 0x40800000u)]
- [TestCase(0x40733333u, false, 0x40800000u)]
- [TestCase(0x3FC00000u, false, 0x40000000u)]
- [TestCase(0x40200000u, false, 0x40400000u)]
- [TestCase(0x00000000u, false, 0x00000000u)]
- [TestCase(0x80000000u, false, 0x80000000u)]
- [TestCase(0x7F800000u, false, 0x7F800000u)]
- [TestCase(0xFF800000u, false, 0xFF800000u)]
- [TestCase(0xFF800001u, false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, true, 0x7FC00000u, Ignore = "NaN test.")]
- public void Frintp_S(uint a, bool defaultNaN, uint result)
- {
- uint opcode = 0x1E24C020; // FRINTP S0, S1
-
- Vector128<float> v1 = MakeVectorE0(a);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result));
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x4EE18820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, false, 0x4000000000000000ul, 0x4000000000000000ul)] // FRINTP V0.2D, v1.2D
- [TestCase(0x4EE18820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x4EA18820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x4000000040000000ul, 0x4000000040000000ul)] // FRINTP V0.4S, v1.4S
- [TestCase(0x0EA18820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, false, 0x4000000040000000ul, 0x0000000000000000ul)] // FRINTP V0.2S, v1.2S
- [TestCase(0x0EA18820u, 0x0000000080000000ul, 0x0000000000000000ul, false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x0EA18820u, 0x7F800000FF800000ul, 0x0000000000000000ul, false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x0EA18820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x0EA18820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- public void Frintp_V(uint opcode, ulong a, ulong b, bool defaultNaN, ulong result0, ulong result1)
- {
- Vector128<float> v1 = MakeVectorE0E1(a, b);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.Multiple(() =>
- {
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result0));
- Assert.That(GetVectorE1(threadState.V0), Is.EqualTo(result1));
- });
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x3FE66666u, 'N', false, 0x40000000u)]
- [TestCase(0x3F99999Au, 'N', false, 0x3F800000u)]
- [TestCase(0x404CCCCDu, 'P', false, 0x40800000u)]
- [TestCase(0x40733333u, 'P', false, 0x40800000u)]
- [TestCase(0x404CCCCDu, 'M', false, 0x40400000u)]
- [TestCase(0x40733333u, 'M', false, 0x40400000u)]
- [TestCase(0x3F99999Au, 'Z', false, 0x3F800000u)]
- [TestCase(0x3FE66666u, 'Z', false, 0x3F800000u)]
- [TestCase(0x00000000u, 'N', false, 0x00000000u)]
- [TestCase(0x00000000u, 'P', false, 0x00000000u)]
- [TestCase(0x00000000u, 'M', false, 0x00000000u)]
- [TestCase(0x00000000u, 'Z', false, 0x00000000u)]
- [TestCase(0x80000000u, 'N', false, 0x80000000u)]
- [TestCase(0x80000000u, 'P', false, 0x80000000u)]
- [TestCase(0x80000000u, 'M', false, 0x80000000u)]
- [TestCase(0x80000000u, 'Z', false, 0x80000000u)]
- [TestCase(0x7F800000u, 'N', false, 0x7F800000u)]
- [TestCase(0x7F800000u, 'P', false, 0x7F800000u)]
- [TestCase(0x7F800000u, 'M', false, 0x7F800000u)]
- [TestCase(0x7F800000u, 'Z', false, 0x7F800000u)]
- [TestCase(0xFF800000u, 'N', false, 0xFF800000u)]
- [TestCase(0xFF800000u, 'P', false, 0xFF800000u)]
- [TestCase(0xFF800000u, 'M', false, 0xFF800000u)]
- [TestCase(0xFF800000u, 'Z', false, 0xFF800000u)]
- [TestCase(0xFF800001u, 'N', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'P', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'M', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'Z', false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'N', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'P', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'M', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, 'Z', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'N', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'P', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'M', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'Z', false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'N', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'P', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'M', true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, 'Z', true, 0x7FC00000u, Ignore = "NaN test.")]
- public void Frintx_S(uint a, char roundMode, bool defaultNaN, uint result)
- {
- uint opcode = 0x1E274020; // FRINTX S0, S1
-
- Vector128<float> v1 = MakeVectorE0(a);
-
- int fpcrTemp = 0x0;
-
- switch (roundMode)
- {
- case 'N': fpcrTemp = 0x0; break;
- case 'P': fpcrTemp = 0x400000; break;
- case 'M': fpcrTemp = 0x800000; break;
- case 'Z': fpcrTemp = 0xC00000; break;
- }
-
- if (defaultNaN)
- {
- fpcrTemp |= 1 << 25;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result));
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x6E619820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'N', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)] // FRINTX V0.2D, V1.2D
- [TestCase(0x6E619820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'N', false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6E619820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'P', false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6E619820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'P', false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x6E619820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'M', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6E619820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'M', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6E619820u, 0x3FF3333333333333ul, 0x3FF3333333333333ul, 'Z', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6E619820u, 0x3FFCCCCCCCCCCCCDul, 0x3FFCCCCCCCCCCCCDul, 'Z', false, 0x3FF0000000000000ul, 0x3FF0000000000000ul)]
- [TestCase(0x6E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'N', false, 0x3F80000040000000ul, 0x3F80000040000000ul)] // FRINTX V0.4S, V1.4S
- [TestCase(0x6E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'P', false, 0x4000000040000000ul, 0x4000000040000000ul)]
- [TestCase(0x6E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'M', false, 0x3F8000003F800000ul, 0x3F8000003F800000ul)]
- [TestCase(0x6E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'Z', false, 0x3F8000003F800000ul, 0x3F8000003F800000ul)]
- [TestCase(0x2E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'N', false, 0x3F80000040000000ul, 0x0000000000000000ul)] // FRINTX V0.2S, V1.2S
- [TestCase(0x2E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'P', false, 0x4000000040000000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'M', false, 0x3F8000003F800000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x3F99999A3FE66666ul, 0x3F99999A3FE66666ul, 'Z', false, 0x3F8000003F800000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x0000000080000000ul, 0x0000000000000000ul, 'N', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x0000000080000000ul, 0x0000000000000000ul, 'P', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x0000000080000000ul, 0x0000000000000000ul, 'M', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x0000000080000000ul, 0x0000000000000000ul, 'Z', false, 0x0000000080000000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'N', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'P', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'M', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0x7F800000FF800000ul, 0x0000000000000000ul, 'Z', false, 0x7F800000FF800000ul, 0x0000000000000000ul)]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'N', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'P', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'M', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'Z', false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'N', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'P', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'M', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x2E219820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, 'Z', true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- public void Frintx_V(uint opcode, ulong a, ulong b, char roundMode, bool defaultNaN, ulong result0, ulong result1)
- {
- Vector128<float> v1 = MakeVectorE0E1(a, b);
-
- int fpcrTemp = 0x0;
-
- switch (roundMode)
- {
- case 'N': fpcrTemp = 0x0; break;
- case 'P': fpcrTemp = 0x400000; break;
- case 'M': fpcrTemp = 0x800000; break;
- case 'Z': fpcrTemp = 0xC00000; break;
- }
-
- if (defaultNaN)
- {
- fpcrTemp |= 1 << 25;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.Multiple(() =>
- {
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result0));
- Assert.That(GetVectorE1(threadState.V0), Is.EqualTo(result1));
- });
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0xBFF33333u, false, 0xBF800000u)]
- [TestCase(0x40200000u, false, 0x40000000u)]
- [TestCase(0xFF800001u, false, 0xFFC00001u, Ignore = "NaN test.")]
- [TestCase(0xFF800001u, true, 0x7FC00000u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, false, 0x7FC00002u, Ignore = "NaN test.")]
- [TestCase(0x7FC00002u, true, 0x7FC00000u, Ignore = "NaN test.")]
- public void Frintz_S(uint a, bool defaultNaN, uint result)
- {
- uint opcode = 0x1E25C020; // FRINTZ S0, S1
-
- Vector128<float> v1 = MakeVectorE0(a);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result));
-
- CompareAgainstUnicorn();
- }
-
- [TestCase(0x4EE19820u, 0xBFF999999999999Aul, 0xBFF999999999999Aul, false, 0xBFF0000000000000ul, 0xBFF0000000000000ul)] // FRINTZ V0.2D, V1.2D
- [TestCase(0x4EE19820u, 0x4004000000000000ul, 0x4004000000000000ul, false, 0x4000000000000000ul, 0x4000000000000000ul)]
- [TestCase(0x0EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, false, 0xFFC000017FC00002ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- [TestCase(0x0EA19820u, 0xFF8000017FC00002ul, 0x0000000000000000ul, true, 0x7FC000007FC00000ul, 0x0000000000000000ul, Ignore = "NaN test.")]
- public void Frintz_V(uint opcode, ulong a, ulong b, bool defaultNaN, ulong result0, ulong result1)
- {
- Vector128<float> v1 = MakeVectorE0E1(a, b);
-
- int fpcrTemp = 0x0;
-
- if (defaultNaN)
- {
- fpcrTemp = 0x2000000;
- }
-
- CpuThreadState threadState = SingleOpcode(opcode, v1: v1, fpcr: fpcrTemp);
-
- Assert.Multiple(() =>
- {
- Assert.That(GetVectorE0(threadState.V0), Is.EqualTo(result0));
- Assert.That(GetVectorE1(threadState.V0), Is.EqualTo(result1));
- });
-
- CompareAgainstUnicorn();
- }
- }
-}