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), 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 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 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.Graphics/Shader/CodeGen/Glsl/OperandManager.cs b/Ryujinx.Graphics/Shader/CodeGen/Glsl/OperandManager.cs index debba42843..9aed8eb8c4 100644 --- a/Ryujinx.Graphics/Shader/CodeGen/Glsl/OperandManager.cs +++ b/Ryujinx.Graphics/Shader/CodeGen/Glsl/OperandManager.cs @@ -28,20 +28,28 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl private static Dictionary _builtInAttributes = new Dictionary() { - { AttributeConsts.Layer, new BuiltInAttribute("gl_Layer", VariableType.S32) }, - { AttributeConsts.PointSize, new BuiltInAttribute("gl_PointSize", VariableType.F32) }, - { AttributeConsts.PositionX, new BuiltInAttribute("gl_Position.x", VariableType.F32) }, - { AttributeConsts.PositionY, new BuiltInAttribute("gl_Position.y", VariableType.F32) }, - { AttributeConsts.PositionZ, new BuiltInAttribute("gl_Position.z", VariableType.F32) }, - { AttributeConsts.PositionW, new BuiltInAttribute("gl_Position.w", VariableType.F32) }, - { AttributeConsts.PointCoordX, new BuiltInAttribute("gl_PointCoord.x", VariableType.F32) }, - { AttributeConsts.PointCoordY, new BuiltInAttribute("gl_PointCoord.y", VariableType.F32) }, - { AttributeConsts.TessCoordX, new BuiltInAttribute("gl_TessCoord.x", VariableType.F32) }, - { AttributeConsts.TessCoordY, new BuiltInAttribute("gl_TessCoord.y", VariableType.F32) }, - { AttributeConsts.InstanceId, new BuiltInAttribute("instance", VariableType.S32) }, - { AttributeConsts.VertexId, new BuiltInAttribute("gl_VertexID", VariableType.S32) }, - { AttributeConsts.FrontFacing, new BuiltInAttribute("gl_FrontFacing", VariableType.Bool) }, - { AttributeConsts.FragmentOutputDepth, new BuiltInAttribute("gl_FragDepth", VariableType.F32) } + { AttributeConsts.Layer, new BuiltInAttribute("gl_Layer", VariableType.S32) }, + { AttributeConsts.PointSize, new BuiltInAttribute("gl_PointSize", VariableType.F32) }, + { AttributeConsts.PositionX, new BuiltInAttribute("gl_Position.x", VariableType.F32) }, + { AttributeConsts.PositionY, new BuiltInAttribute("gl_Position.y", VariableType.F32) }, + { AttributeConsts.PositionZ, new BuiltInAttribute("gl_Position.z", VariableType.F32) }, + { AttributeConsts.PositionW, new BuiltInAttribute("gl_Position.w", VariableType.F32) }, + { AttributeConsts.ClipDistance0, new BuiltInAttribute("gl_ClipDistance[0]", VariableType.F32) }, + { AttributeConsts.ClipDistance1, new BuiltInAttribute("gl_ClipDistance[1]", VariableType.F32) }, + { AttributeConsts.ClipDistance2, new BuiltInAttribute("gl_ClipDistance[2]", VariableType.F32) }, + { AttributeConsts.ClipDistance3, new BuiltInAttribute("gl_ClipDistance[3]", VariableType.F32) }, + { AttributeConsts.ClipDistance4, new BuiltInAttribute("gl_ClipDistance[4]", VariableType.F32) }, + { AttributeConsts.ClipDistance5, new BuiltInAttribute("gl_ClipDistance[5]", VariableType.F32) }, + { AttributeConsts.ClipDistance6, new BuiltInAttribute("gl_ClipDistance[6]", VariableType.F32) }, + { AttributeConsts.ClipDistance7, new BuiltInAttribute("gl_ClipDistance[7]", VariableType.F32) }, + { AttributeConsts.PointCoordX, new BuiltInAttribute("gl_PointCoord.x", VariableType.F32) }, + { AttributeConsts.PointCoordY, new BuiltInAttribute("gl_PointCoord.y", VariableType.F32) }, + { AttributeConsts.TessCoordX, new BuiltInAttribute("gl_TessCoord.x", VariableType.F32) }, + { AttributeConsts.TessCoordY, new BuiltInAttribute("gl_TessCoord.y", VariableType.F32) }, + { AttributeConsts.InstanceId, new BuiltInAttribute("instance", VariableType.S32) }, + { AttributeConsts.VertexId, new BuiltInAttribute("gl_VertexID", VariableType.S32) }, + { AttributeConsts.FrontFacing, new BuiltInAttribute("gl_FrontFacing", VariableType.Bool) }, + { AttributeConsts.FragmentOutputDepth, new BuiltInAttribute("gl_FragDepth", VariableType.F32) } }; private Dictionary _locals; @@ -172,7 +180,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl } } - return DefaultNames.UndefinedName; + //TODO: Warn about unknown built-in attribute. + + return isOutAttr ? "// bad_attr0x" + value.ToString("X") : "0.0"; } public static string GetUbName(GalShaderType shaderType, int slot) diff --git a/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs b/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs index ae3e361c72..0fd16ce8db 100644 --- a/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs +++ b/Ryujinx.Graphics/Shader/Translation/AttributeConsts.cs @@ -2,19 +2,27 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation { static class AttributeConsts { - public const int Layer = 0x064; - public const int PointSize = 0x06c; - public const int PositionX = 0x070; - public const int PositionY = 0x074; - public const int PositionZ = 0x078; - public const int PositionW = 0x07c; - public const int PointCoordX = 0x2e0; - public const int PointCoordY = 0x2e4; - public const int TessCoordX = 0x2f0; - public const int TessCoordY = 0x2f4; - public const int InstanceId = 0x2f8; - public const int VertexId = 0x2fc; - public const int FrontFacing = 0x3fc; + public const int Layer = 0x064; + public const int PointSize = 0x06c; + public const int PositionX = 0x070; + public const int PositionY = 0x074; + public const int PositionZ = 0x078; + public const int PositionW = 0x07c; + public const int ClipDistance0 = 0x2c0; + public const int ClipDistance1 = 0x2c4; + public const int ClipDistance2 = 0x2c8; + public const int ClipDistance3 = 0x2cc; + public const int ClipDistance4 = 0x2d0; + public const int ClipDistance5 = 0x2d4; + public const int ClipDistance6 = 0x2d8; + public const int ClipDistance7 = 0x2dc; + public const int PointCoordX = 0x2e0; + public const int PointCoordY = 0x2e4; + public const int TessCoordX = 0x2f0; + public const int TessCoordY = 0x2f4; + public const int InstanceId = 0x2f8; + public const int VertexId = 0x2fc; + public const int FrontFacing = 0x3fc; public const int UserAttributesCount = 32; public const int UserAttributeBase = 0x80; diff --git a/Ryujinx.HLE/HOS/Services/Aud/IAudioRendererManager.cs b/Ryujinx.HLE/HOS/Services/Aud/IAudioRendererManager.cs index fb1409f43d..18e9184cf0 100644 --- a/Ryujinx.HLE/HOS/Services/Aud/IAudioRendererManager.cs +++ b/Ryujinx.HLE/HOS/Services/Aud/IAudioRendererManager.cs @@ -16,7 +16,7 @@ namespace Ryujinx.HLE.HOS.Services.Aud ('V' << 16) | ('0' << 24); - private const int Rev = 4; + private const int Rev = 5; public const int RevMagic = Rev0Magic + (Rev << 24); @@ -58,8 +58,9 @@ namespace Ryujinx.HLE.HOS.Services.Aud if (revision <= Rev) { - bool isSplitterSupported = revision >= 3; - + bool isSplitterSupported = revision >= 3; + bool isVariadicCommandBufferSizeSupported = revision >= 5; + long size; size = IntUtils.AlignUp(Params.Unknown8 * 4, 64); @@ -99,7 +100,21 @@ namespace Ryujinx.HLE.HOS.Services.Aud (Params.PerformanceManagerCount + 1) + 0x13F) & ~0x3FL; } - size = (size + 0x1907D) & ~0xFFFL; + if (isVariadicCommandBufferSizeSupported) + { + size += Params.EffectCount * 0x840 + + Params.MixCount * 0x5A38 + + Params.SinkCount * 0x148 + + Params.SplitterDestinationDataCount * 0x540 + + Params.VoiceCount * (Params.SplitterCount * 0x68 + 0x2E0) + + ((Params.VoiceCount + Params.MixCount + Params.EffectCount + Params.SinkCount + 0x65) << 6) + 0x3F8 + 0x7E; + } + else + { + size += 0x1807E; + } + + size = size & ~0xFFFL; context.ResponseData.Write(size); diff --git a/Ryujinx.HLE/HOS/Services/Friend/IFriendService.cs b/Ryujinx.HLE/HOS/Services/Friend/IFriendService.cs index 54d85ea594..1a60a78ba5 100644 --- a/Ryujinx.HLE/HOS/Services/Friend/IFriendService.cs +++ b/Ryujinx.HLE/HOS/Services/Friend/IFriendService.cs @@ -17,6 +17,7 @@ namespace Ryujinx.HLE.HOS.Services.Friend _commands = new Dictionary { { 10101, GetFriendList }, + { 10600, DeclareOpenOnlinePlaySession }, { 10601, DeclareCloseOnlinePlaySession }, { 10610, UpdateUserPresence } }; @@ -61,6 +62,23 @@ namespace Ryujinx.HLE.HOS.Services.Friend return 0; } + // DeclareOpenOnlinePlaySession(nn::account::Uid) + public long DeclareOpenOnlinePlaySession(ServiceCtx context) + { + UInt128 uuid = new UInt128( + context.RequestData.ReadInt64(), + context.RequestData.ReadInt64()); + + if (context.Device.System.State.TryGetUser(uuid, out UserProfile profile)) + { + profile.OnlinePlayState = OpenCloseState.Open; + } + + Logger.PrintStub(LogClass.ServiceFriend, new { UserId = uuid.ToString(), profile.OnlinePlayState }); + + return 0; + } + // DeclareCloseOnlinePlaySession(nn::account::Uid) public long DeclareCloseOnlinePlaySession(ServiceCtx context) { diff --git a/Ryujinx.HLE/HOS/Services/Irs/IIrSensorServer.cs b/Ryujinx.HLE/HOS/Services/Irs/IIrSensorServer.cs index 500d5f1079..f0864c58dd 100644 --- a/Ryujinx.HLE/HOS/Services/Irs/IIrSensorServer.cs +++ b/Ryujinx.HLE/HOS/Services/Irs/IIrSensorServer.cs @@ -20,10 +20,11 @@ namespace Ryujinx.HLE.HOS.Services.Irs { _commands = new Dictionary { - { 302, ActivateIrsensor }, - { 303, DeactivateIrsensor }, - { 304, GetIrsensorSharedMemoryHandle }, - { 311, GetNpadIrCameraHandle } + { 302, ActivateIrsensor }, + { 303, DeactivateIrsensor }, + { 304, GetIrsensorSharedMemoryHandle }, + { 311, GetNpadIrCameraHandle }, + { 319, ActivateIrsensorWithFunctionLevel } }; _irsSharedMem = irsSharedMem; @@ -103,5 +104,16 @@ namespace Ryujinx.HLE.HOS.Services.Irs default: throw new ArgumentOutOfRangeException(nameof(npadId)); } } + + // ActivateIrsensorWithFunctionLevel(nn::applet::AppletResourceUserId, nn::irsensor::PackedFunctionLevel, pid) + public long ActivateIrsensorWithFunctionLevel(ServiceCtx context) + { + long appletResourceUserId = context.RequestData.ReadInt64(); + long packedFunctionLevel = context.RequestData.ReadInt64(); + + Logger.PrintStub(LogClass.ServiceIrs, new { appletResourceUserId, packedFunctionLevel }); + + return 0; + } } } \ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Services/Nv/INvDrvServices.cs b/Ryujinx.HLE/HOS/Services/Nv/INvDrvServices.cs index d93372e22b..600a966782 100644 --- a/Ryujinx.HLE/HOS/Services/Nv/INvDrvServices.cs +++ b/Ryujinx.HLE/HOS/Services/Nv/INvDrvServices.cs @@ -42,14 +42,15 @@ namespace Ryujinx.HLE.HOS.Services.Nv { _commands = new Dictionary() { - { 0, Open }, - { 1, Ioctl }, - { 2, Close }, - { 3, Initialize }, - { 4, QueryEvent }, - { 8, SetClientPid }, - { 11, Ioctl }, - { 13, FinishInitialize } + { 0, Open }, + { 1, Ioctl }, + { 2, Close }, + { 3, Initialize }, + { 4, QueryEvent }, + { 8, SetClientPid }, + { 9, DumpGraphicsMemoryInfo }, + { 11, Ioctl }, + { 13, FinishInitialize } }; _event = new KEvent(system); @@ -148,6 +149,13 @@ namespace Ryujinx.HLE.HOS.Services.Nv return 0; } + public long DumpGraphicsMemoryInfo(ServiceCtx context) + { + Logger.PrintStub(LogClass.ServiceNv); + + return 0; + } + public long FinishInitialize(ServiceCtx context) { Logger.PrintStub(LogClass.ServiceNv); diff --git a/Ryujinx.HLE/HOS/Services/Pctl/IParentalControlService.cs b/Ryujinx.HLE/HOS/Services/Pctl/IParentalControlService.cs index 0c539aa131..3e8ae81cf1 100644 --- a/Ryujinx.HLE/HOS/Services/Pctl/IParentalControlService.cs +++ b/Ryujinx.HLE/HOS/Services/Pctl/IParentalControlService.cs @@ -1,5 +1,6 @@ using Ryujinx.Common.Logging; using Ryujinx.HLE.HOS.Ipc; +using System; using System.Collections.Generic; namespace Ryujinx.HLE.HOS.Services.Pctl @@ -18,7 +19,8 @@ namespace Ryujinx.HLE.HOS.Services.Pctl { _commands = new Dictionary { - { 1, Initialize } + { 1, Initialize }, + { 1001, CheckFreeCommunicationPermission } }; _needInitialize = needInitialize; @@ -37,5 +39,12 @@ namespace Ryujinx.HLE.HOS.Services.Pctl return 0; } + + public long CheckFreeCommunicationPermission(ServiceCtx context) + { + Logger.PrintStub(LogClass.ServicePctl); + + return 0; + } } } \ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Services/Vi/IApplicationDisplayService.cs b/Ryujinx.HLE/HOS/Services/Vi/IApplicationDisplayService.cs index 48cf328806..686f85efae 100644 --- a/Ryujinx.HLE/HOS/Services/Vi/IApplicationDisplayService.cs +++ b/Ryujinx.HLE/HOS/Services/Vi/IApplicationDisplayService.cs @@ -61,7 +61,7 @@ namespace Ryujinx.HLE.HOS.Services.Vi public long GetManagerDisplayService(ServiceCtx context) { - MakeObject(context, new IManagerDisplayService()); + MakeObject(context, new IManagerDisplayService(this)); return 0; } diff --git a/Ryujinx.HLE/HOS/Services/Vi/IManagerDisplayService.cs b/Ryujinx.HLE/HOS/Services/Vi/IManagerDisplayService.cs index c655e26cc0..d717b78a65 100644 --- a/Ryujinx.HLE/HOS/Services/Vi/IManagerDisplayService.cs +++ b/Ryujinx.HLE/HOS/Services/Vi/IManagerDisplayService.cs @@ -10,14 +10,15 @@ namespace Ryujinx.HLE.HOS.Services.Vi public override IReadOnlyDictionary Commands => _commands; - public IManagerDisplayService() + public IManagerDisplayService(IApplicationDisplayService applicationDisplayService) { _commands = new Dictionary { - { 2010, CreateManagedLayer }, - { 2011, DestroyManagedLayer }, - { 6000, AddToLayerStack }, - { 6002, SetLayerVisibility } + { 2010, CreateManagedLayer }, + { 2011, DestroyManagedLayer }, + { 2012, applicationDisplayService.CreateStrayLayer }, + { 6000, AddToLayerStack }, + { 6002, SetLayerVisibility } }; } diff --git a/Ryujinx.HLE/Input/HidHotkeyButtons.cs b/Ryujinx.HLE/Input/HidHotkeyButtons.cs new file mode 100644 index 0000000000..7fa6ed6d0b --- /dev/null +++ b/Ryujinx.HLE/Input/HidHotkeyButtons.cs @@ -0,0 +1,10 @@ +using System; + +namespace Ryujinx.HLE.Input +{ + [Flags] + public enum HidHotkeyButtons + { + ToggleVSync = 1 << 0, + } +} 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 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 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 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(); - } - } -} diff --git a/Ryujinx/Config.jsonc b/Ryujinx/Config.jsonc index 151756f43c..376cf502af 100644 --- a/Ryujinx/Config.jsonc +++ b/Ryujinx/Config.jsonc @@ -84,6 +84,10 @@ "button_plus": "Plus", "button_r": "U", "button_zr": "O" + }, + + "hotkeys": { + "toggle_vsync": "Tab" } }, diff --git a/Ryujinx/Ui/GLScreen.cs b/Ryujinx/Ui/GLScreen.cs index e3d510ef81..c4fe65ab61 100644 --- a/Ryujinx/Ui/GLScreen.cs +++ b/Ryujinx/Ui/GLScreen.cs @@ -24,6 +24,8 @@ namespace Ryujinx private IGalRenderer _renderer; + private HidHotkeyButtons _prevHotkeyButtons = 0; + private KeyboardState? _keyboard = null; private MouseState? _mouse = null; @@ -139,6 +141,7 @@ namespace Ryujinx private new void UpdateFrame() { + HidHotkeyButtons currentHotkeyButtons = 0; HidControllerButtons currentButton = 0; HidJoystickPosition leftJoystick; HidJoystickPosition rightJoystick; @@ -159,10 +162,10 @@ namespace Ryujinx #endif // Normal Input - currentButton = Configuration.Instance.KeyboardControls.GetButtons(keyboard); - - (leftJoystickDx, leftJoystickDy) = Configuration.Instance.KeyboardControls.GetLeftStick(keyboard); + currentHotkeyButtons = Configuration.Instance.KeyboardControls.GetHotkeyButtons(keyboard); + currentButton = Configuration.Instance.KeyboardControls.GetButtons(keyboard); + (leftJoystickDx, leftJoystickDy) = Configuration.Instance.KeyboardControls.GetLeftStick(keyboard); (rightJoystickDx, rightJoystickDy) = Configuration.Instance.KeyboardControls.GetRightStick(keyboard); } @@ -255,6 +258,15 @@ namespace Ryujinx HidControllerBase controller = _device.Hid.PrimaryController; controller.SendInput(currentButton, leftJoystick, rightJoystick); + + // Toggle vsync + if (currentHotkeyButtons.HasFlag(HidHotkeyButtons.ToggleVSync) && + !_prevHotkeyButtons.HasFlag(HidHotkeyButtons.ToggleVSync)) + { + _device.EnableDeviceVsync = !_device.EnableDeviceVsync; + } + + _prevHotkeyButtons = currentHotkeyButtons; } private new void RenderFrame() @@ -345,4 +357,4 @@ namespace Ryujinx _mouse = e.Mouse; } } -} \ No newline at end of file +} diff --git a/Ryujinx/Ui/NpadKeyboard.cs b/Ryujinx/Ui/NpadKeyboard.cs index 1604da5bda..8d003c2c6d 100644 --- a/Ryujinx/Ui/NpadKeyboard.cs +++ b/Ryujinx/Ui/NpadKeyboard.cs @@ -35,6 +35,11 @@ namespace Ryujinx.UI.Input public Key ButtonZr; } + public struct KeyboardHotkeys + { + public Key ToggleVsync; + } + public class NpadKeyboard { /// @@ -47,6 +52,11 @@ namespace Ryujinx.UI.Input /// public NpadKeyboardRight RightJoycon { get; private set; } + /// + /// Hotkey Keyboard Bindings + /// + public KeyboardHotkeys Hotkeys { get; private set; } + public HidControllerButtons GetButtons(KeyboardState keyboard) { HidControllerButtons buttons = 0; @@ -97,5 +107,14 @@ namespace Ryujinx.UI.Input return (dx, dy); } + + public HidHotkeyButtons GetHotkeyButtons(KeyboardState keyboard) + { + HidHotkeyButtons buttons = 0; + + if (keyboard[(Key)Hotkeys.ToggleVsync]) buttons |= HidHotkeyButtons.ToggleVSync; + + return buttons; + } } } diff --git a/Ryujinx/_schema.json b/Ryujinx/_schema.json index 11eff12b08..d06c8e91b1 100644 --- a/Ryujinx/_schema.json +++ b/Ryujinx/_schema.json @@ -636,9 +636,24 @@ "default": "O" } } + }, + "hotkeys": { + "$id": "#/properties/keyboard_controls/properties/hotkeys", + "type": "object", + "title": "Hotkey Controls", + "required": [ + "toggle_vsync" + ], + "properties": { + "toggle_vsync": { + "$id": "#/properties/keyboard_controls/properties/hotkeys/properties/toggle_vsync", + "$ref": "#/definitions/key", + "title": "Toggle VSync", + "default": "Tab" + } + } } - } - }, + }, "gamepad_controls": { "$id": "#/properties/gamepad_controls", "type": "object", @@ -843,4 +858,4 @@ } } } -} \ No newline at end of file +}