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 d2d87beff..357d88b5d 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), typeof(Vector128) } + : new Type[] { typeof(Vector128), typeof(Vector128) }; + + 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) } + : new Type[] { typeof(Vector128) }; + + 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 c5f16f86c..b34687e1c 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 6799a3a38..2bcda35f3 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 d1dfaced4..3e2b258a1 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 Sse41ScalarRound(Vector128 upper, Vector128 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 Sse41ScalarRoundF(Vector128 upper, Vector128 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 Sse41VectorRound(Vector128 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 Sse41VectorRoundF(Vector128 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 Tbl1_V64( diff --git a/Ryujinx.Tests/Cpu/CpuTestSimd.cs b/Ryujinx.Tests/Cpu/CpuTestSimd.cs index df23f2eff..25e47778c 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 v0 = MakeVectorE0E1(z, z); + Vector128 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 v0 = MakeVectorE1(z); + Vector128 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 v0 = MakeVectorE0E1(z, z); + Vector128 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 v0 = MakeVectorE0E1(z, z); + Vector128 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 v0 = MakeVectorE0E1(z, z); + Vector128 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 v0 = MakeVectorE1(z); + Vector128 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 v0 = MakeVectorE0E1(z, z); + Vector128 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 v0 = MakeVectorE0E1(z, z); + Vector128 v1 = MakeVectorE0E1(a, a); + + int fpcr = (int)rMode << (int)Fpcr.RMode; + + SingleOpcode(opcodes, v0: v0, v1: v1, fpcr: fpcr); + + CompareAgainstUnicorn(); + } + [Test, Pairwise, Description("NEG , ")] 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 63e0bda83..000000000 --- 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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(); - } - } -}