1 files changed, 532 insertions, 0 deletions
diff --git a/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatArithmetic.cs b/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatArithmetic.cs
new file mode 100644
index 00000000..29803c31
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatArithmetic.cs
@@ -0,0 +1,532 @@
+using Ryujinx.Graphics.Shader.Decoders;
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using Ryujinx.Graphics.Shader.Translation;
+
+using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
+using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
+using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
+
+namespace Ryujinx.Graphics.Shader.Instructions
+{
+    static partial class InstEmit
+    {
+        public static void DaddR(EmitterContext context)
+        {
+            InstDaddR op = context.GetOp<InstDaddR>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcReg(context, op.SrcB, isFP64: true);
+
+            EmitFadd(context, Instruction.FP64, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
+        }
+
+        public static void DaddI(EmitterContext context)
+        {
+            InstDaddI op = context.GetOp<InstDaddI>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
+
+            EmitFadd(context, Instruction.FP64, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
+        }
+
+        public static void DaddC(EmitterContext context)
+        {
+            InstDaddC op = context.GetOp<InstDaddC>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
+
+            EmitFadd(context, Instruction.FP64, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
+        }
+
+        public static void DfmaR(EmitterContext context)
+        {
+            InstDfmaR op = context.GetOp<InstDfmaR>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcReg(context, op.SrcB, isFP64: true);
+            var srcC = GetSrcReg(context, op.SrcC, isFP64: true);
+
+            EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
+        }
+
+        public static void DfmaI(EmitterContext context)
+        {
+            InstDfmaI op = context.GetOp<InstDfmaI>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
+            var srcC = GetSrcReg(context, op.SrcC, isFP64: true);
+
+            EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
+        }
+
+        public static void DfmaC(EmitterContext context)
+        {
+            InstDfmaC op = context.GetOp<InstDfmaC>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
+            var srcC = GetSrcReg(context, op.SrcC, isFP64: true);
+
+            EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
+        }
+
+        public static void DfmaRc(EmitterContext context)
+        {
+            InstDfmaRc op = context.GetOp<InstDfmaRc>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcReg(context, op.SrcC, isFP64: true);
+            var srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
+
+            EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
+        }
+
+        public static void DmulR(EmitterContext context)
+        {
+            InstDmulR op = context.GetOp<InstDmulR>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcReg(context, op.SrcB, isFP64: true);
+
+            EmitFmul(context, Instruction.FP64, MultiplyScale.NoScale, srcA, srcB, op.Dest, op.NegA, false, op.WriteCC);
+        }
+
+        public static void DmulI(EmitterContext context)
+        {
+            InstDmulI op = context.GetOp<InstDmulI>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
+
+            EmitFmul(context, Instruction.FP64, MultiplyScale.NoScale, srcA, srcB, op.Dest, op.NegA, false, op.WriteCC);
+        }
+
+        public static void DmulC(EmitterContext context)
+        {
+            InstDmulC op = context.GetOp<InstDmulC>();
+
+            var srcA = GetSrcReg(context, op.SrcA, isFP64: true);
+            var srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
+
+            EmitFmul(context, Instruction.FP64, MultiplyScale.NoScale, srcA, srcB, op.Dest, op.NegA, false, op.WriteCC);
+        }
+
+        public static void FaddR(EmitterContext context)
+        {
+            InstFaddR op = context.GetOp<InstFaddR>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcReg(context, op.SrcB);
+
+            EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, op.Sat, op.WriteCC);
+        }
+
+        public static void FaddI(EmitterContext context)
+        {
+            InstFaddI op = context.GetOp<InstFaddI>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
+
+            EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, op.Sat, op.WriteCC);
+        }
+
+        public static void FaddC(EmitterContext context)
+        {
+            InstFaddC op = context.GetOp<InstFaddC>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
+
+            EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, op.Sat, op.WriteCC);
+        }
+
+        public static void Fadd32i(EmitterContext context)
+        {
+            InstFadd32i op = context.GetOp<InstFadd32i>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcImm(context, op.Imm32);
+
+            EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
+        }
+
+        public static void FfmaR(EmitterContext context)
+        {
+            InstFfmaR op = context.GetOp<InstFfmaR>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcReg(context, op.SrcB);
+            var srcC = GetSrcReg(context, op.SrcC);
+
+            EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
+        }
+
+        public static void FfmaI(EmitterContext context)
+        {
+            InstFfmaI op = context.GetOp<InstFfmaI>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
+            var srcC = GetSrcReg(context, op.SrcC);
+
+            EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
+        }
+
+        public static void FfmaC(EmitterContext context)
+        {
+            InstFfmaC op = context.GetOp<InstFfmaC>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
+            var srcC = GetSrcReg(context, op.SrcC);
+
+            EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
+        }
+
+        public static void FfmaRc(EmitterContext context)
+        {
+            InstFfmaRc op = context.GetOp<InstFfmaRc>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcReg(context, op.SrcC);
+            var srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
+
+            EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
+        }
+
+        public static void Ffma32i(EmitterContext context)
+        {
+            InstFfma32i op = context.GetOp<InstFfma32i>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcImm(context, op.Imm32);
+            var srcC = GetSrcReg(context, op.Dest);
+
+            EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
+        }
+
+        public static void FmulR(EmitterContext context)
+        {
+            InstFmulR op = context.GetOp<InstFmulR>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcReg(context, op.SrcB);
+
+            EmitFmul(context, Instruction.FP32, op.Scale, srcA, srcB, op.Dest, op.NegA, op.Sat, op.WriteCC);
+        }
+
+        public static void FmulI(EmitterContext context)
+        {
+            InstFmulI op = context.GetOp<InstFmulI>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
+
+            EmitFmul(context, Instruction.FP32, op.Scale, srcA, srcB, op.Dest, op.NegA, op.Sat, op.WriteCC);
+        }
+
+        public static void FmulC(EmitterContext context)
+        {
+            InstFmulC op = context.GetOp<InstFmulC>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
+
+            EmitFmul(context, Instruction.FP32, op.Scale, srcA, srcB, op.Dest, op.NegA, op.Sat, op.WriteCC);
+        }
+
+        public static void Fmul32i(EmitterContext context)
+        {
+            InstFmul32i op = context.GetOp<InstFmul32i>();
+
+            var srcA = GetSrcReg(context, op.SrcA);
+            var srcB = GetSrcImm(context, op.Imm32);
+
+            EmitFmul(context, Instruction.FP32, MultiplyScale.NoScale, srcA, srcB, op.Dest, false, op.Sat, op.WriteCC);
+        }
+
+        public static void Hadd2R(EmitterContext context)
+        {
+            InstHadd2R op = context.GetOp<InstHadd2R>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
+            var srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegB, op.AbsB);
+
+            EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: true, op.Dest, op.Sat);
+        }
+
+        public static void Hadd2I(EmitterContext context)
+        {
+            InstHadd2I op = context.GetOp<InstHadd2I>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
+            var srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
+
+            EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: true, op.Dest, op.Sat);
+        }
+
+        public static void Hadd2C(EmitterContext context)
+        {
+            InstHadd2C op = context.GetOp<InstHadd2C>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
+            var srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegB, op.AbsB);
+
+            EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: true, op.Dest, op.Sat);
+        }
+
+        public static void Hadd232i(EmitterContext context)
+        {
+            InstHadd232i op = context.GetOp<InstHadd232i>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, false);
+            var srcB = GetHalfSrc(context, op.Imm);
+
+            EmitHadd2Hmul2(context, OFmt.F16, srcA, srcB, isAdd: true, op.Dest, op.Sat);
+        }
+
+        public static void Hfma2R(EmitterContext context)
+        {
+            InstHfma2R op = context.GetOp<InstHfma2R>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
+            var srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegA, false);
+            var srcC = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegC, false);
+
+            EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
+        }
+
+        public static void Hfma2I(EmitterContext context)
+        {
+            InstHfma2I op = context.GetOp<InstHfma2I>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
+            var srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
+            var srcC = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegC, false);
+
+            EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
+        }
+
+        public static void Hfma2C(EmitterContext context)
+        {
+            InstHfma2C op = context.GetOp<InstHfma2C>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
+            var srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegA, false);
+            var srcC = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegC, false);
+
+            EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
+        }
+
+        public static void Hfma2Rc(EmitterContext context)
+        {
+            InstHfma2Rc op = context.GetOp<InstHfma2Rc>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
+            var srcB = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegA, false);
+            var srcC = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegC, false);
+
+            EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
+        }
+
+        public static void Hfma232i(EmitterContext context)
+        {
+            InstHfma232i op = context.GetOp<InstHfma232i>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
+            var srcB = GetHalfSrc(context, op.Imm);
+            var srcC = GetHalfSrc(context, HalfSwizzle.F16, op.Dest, op.NegC, false);
+
+            EmitHfma2(context, OFmt.F16, srcA, srcB, srcC, op.Dest, saturate: false);
+        }
+
+        public static void Hmul2R(EmitterContext context)
+        {
+            InstHmul2R op = context.GetOp<InstHmul2R>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, op.AbsA);
+            var srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegA, op.AbsB);
+
+            EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: false, op.Dest, op.Sat);
+        }
+
+        public static void Hmul2I(EmitterContext context)
+        {
+            InstHmul2I op = context.GetOp<InstHmul2I>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
+            var srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
+
+            EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: false, op.Dest, op.Sat);
+        }
+
+        public static void Hmul2C(EmitterContext context)
+        {
+            InstHmul2C op = context.GetOp<InstHmul2C>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, op.AbsA);
+            var srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegA, op.AbsB);
+
+            EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: false, op.Dest, op.Sat);
+        }
+
+        public static void Hmul232i(EmitterContext context)
+        {
+            InstHmul232i op = context.GetOp<InstHmul232i>();
+
+            var srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
+            var srcB = GetHalfSrc(context, op.Imm32);
+
+            EmitHadd2Hmul2(context, OFmt.F16, srcA, srcB, isAdd: false, op.Dest, op.Sat);
+        }
+
+        private static void EmitFadd(
+            EmitterContext context,
+            Instruction fpType,
+            Operand srcA,
+            Operand srcB,
+            int rd,
+            bool negateA,
+            bool negateB,
+            bool absoluteA,
+            bool absoluteB,
+            bool saturate,
+            bool writeCC)
+        {
+            bool isFP64 = fpType == Instruction.FP64;
+
+            srcA = context.FPAbsNeg(srcA, absoluteA, negateA, fpType);
+            srcB = context.FPAbsNeg(srcB, absoluteB, negateB, fpType);
+
+            Operand res = context.FPSaturate(context.FPAdd(srcA, srcB, fpType), saturate, fpType);
+
+            SetDest(context, res, rd, isFP64);
+
+            SetFPZnFlags(context, res, writeCC, fpType);
+        }
+
+        private static void EmitFfma(
+            EmitterContext context,
+            Instruction fpType,
+            Operand srcA,
+            Operand srcB,
+            Operand srcC,
+            int rd,
+            bool negateB,
+            bool negateC,
+            bool saturate,
+            bool writeCC)
+        {
+            bool isFP64 = fpType == Instruction.FP64;
+
+            srcB = context.FPNegate(srcB, negateB, fpType);
+            srcC = context.FPNegate(srcC, negateC, fpType);
+
+            Operand res = context.FPSaturate(context.FPFusedMultiplyAdd(srcA, srcB, srcC, fpType), saturate, fpType);
+
+            SetDest(context, res, rd, isFP64);
+
+            SetFPZnFlags(context, res, writeCC, fpType);
+        }
+
+        private static void EmitFmul(
+            EmitterContext context,
+            Instruction fpType,
+            MultiplyScale scale,
+            Operand srcA,
+            Operand srcB,
+            int rd,
+            bool negateB,
+            bool saturate,
+            bool writeCC)
+        {
+            bool isFP64 = fpType == Instruction.FP64;
+
+            srcB = context.FPNegate(srcB, negateB, fpType);
+
+            if (scale != MultiplyScale.NoScale)
+            {
+                Operand scaleConst = scale switch
+                {
+                    MultiplyScale.D2 => ConstF(0.5f),
+                    MultiplyScale.D4 => ConstF(0.25f),
+                    MultiplyScale.D8 => ConstF(0.125f),
+                    MultiplyScale.M2 => ConstF(2f),
+                    MultiplyScale.M4 => ConstF(4f),
+                    MultiplyScale.M8 => ConstF(8f),
+                    _ => ConstF(1f) // Invalid, behave as if it had no scale.
+                };
+
+                if (scaleConst.AsFloat() == 1f)
+                {
+                    context.Config.GpuAccessor.Log($"Invalid FP multiply scale \"{scale}\".");
+                }
+
+                if (isFP64)
+                {
+                    scaleConst = context.FP32ConvertToFP64(scaleConst);
+                }
+
+                srcA = context.FPMultiply(srcA, scaleConst, fpType);
+            }
+
+            Operand res = context.FPSaturate(context.FPMultiply(srcA, srcB, fpType), saturate, fpType);
+
+            SetDest(context, res, rd, isFP64);
+
+            SetFPZnFlags(context, res, writeCC, fpType);
+        }
+
+        private static void EmitHadd2Hmul2(
+            EmitterContext context,
+            OFmt swizzle,
+            Operand[] srcA,
+            Operand[] srcB,
+            bool isAdd,
+            int rd,
+            bool saturate)
+        {
+            Operand[] res = new Operand[2];
+
+            for (int index = 0; index < res.Length; index++)
+            {
+                if (isAdd)
+                {
+                    res[index] = context.FPAdd(srcA[index], srcB[index]);
+                }
+                else
+                {
+                    res[index] = context.FPMultiply(srcA[index], srcB[index]);
+                }
+
+                res[index] = context.FPSaturate(res[index], saturate);
+            }
+
+            context.Copy(GetDest(rd), GetHalfPacked(context, swizzle, res, rd));
+        }
+
+        public static void EmitHfma2(
+            EmitterContext context,
+            OFmt swizzle,
+            Operand[] srcA,
+            Operand[] srcB,
+            Operand[] srcC,
+            int rd,
+            bool saturate)
+        {
+            Operand[] res = new Operand[2];
+
+            for (int index = 0; index < res.Length; index++)
+            {
+                res[index] = context.FPFusedMultiplyAdd(srcA[index], srcB[index], srcC[index]);
+                res[index] = context.FPSaturate(res[index], saturate);
+            }
+
+            context.Copy(GetDest(rd), GetHalfPacked(context, swizzle, res, rd));
+        }
+    }
+}
+\ No newline at end of file