Ryujinx/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs

using System;

using static Ryujinx.Graphics.Gal.Shader.ShaderDecodeHelper;

namespace Ryujinx.Graphics.Gal.Shader
{
    static partial class ShaderDecode
    {
        private enum HalfOutputType
        {
            PackedFp16,
            Fp32,
            MergeH0,
            MergeH1
        }

        public static void Bfe_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitBfe(block, opCode, ShaderOper.Cr);
        }

        public static void Bfe_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitBfe(block, opCode, ShaderOper.Imm);
        }

        public static void Bfe_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitBfe(block, opCode, ShaderOper.Rr);
        }

        public static void Fadd_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitFadd(block, opCode, ShaderOper.Cr);
        }

        public static void Fadd_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitFadd(block, opCode, ShaderOper.Immf);
        }

        public static void Fadd_I32(ShaderIrBlock block, long opCode, int position)
        {
            ShaderIrNode operA = opCode.Gpr8();
            ShaderIrNode operB = opCode.Immf32_20();

            bool negB = opCode.Read(53);
            bool absA = opCode.Read(54);
            bool negA = opCode.Read(56);
            bool absB = opCode.Read(57);

            operA = GetAluFabsFneg(operA, absA, negA);
            operB = GetAluFabsFneg(operB, absB, negB);

            ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Fadd, operA, operB);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        public static void Fadd_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitFadd(block, opCode, ShaderOper.Rr);
        }

        public static void Ffma_CR(ShaderIrBlock block, long opCode, int position)
        {
            EmitFfma(block, opCode, ShaderOper.Cr);
        }

        public static void Ffma_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitFfma(block, opCode, ShaderOper.Immf);
        }

        public static void Ffma_RC(ShaderIrBlock block, long opCode, int position)
        {
            EmitFfma(block, opCode, ShaderOper.Rc);
        }

        public static void Ffma_RR(ShaderIrBlock block, long opCode, int position)
        {
            EmitFfma(block, opCode, ShaderOper.Rr);
        }

        public static void Fmnmx_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitFmnmx(block, opCode, ShaderOper.Cr);
        }

        public static void Fmnmx_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitFmnmx(block, opCode, ShaderOper.Immf);
        }

        public static void Fmnmx_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitFmnmx(block, opCode, ShaderOper.Rr);
        }

        public static void Fmul_I32(ShaderIrBlock block, long opCode, int position)
        {
            ShaderIrNode operA = opCode.Gpr8();
            ShaderIrNode operB = opCode.Immf32_20();

            ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Fmul, operA, operB);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        public static void Fmul_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitFmul(block, opCode, ShaderOper.Cr);
        }

        public static void Fmul_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitFmul(block, opCode, ShaderOper.Immf);
        }

        public static void Fmul_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitFmul(block, opCode, ShaderOper.Rr);
        }

        public static void Fset_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitFset(block, opCode, ShaderOper.Cr);
        }

        public static void Fset_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitFset(block, opCode, ShaderOper.Immf);
        }

        public static void Fset_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitFset(block, opCode, ShaderOper.Rr);
        }

        public static void Fsetp_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitFsetp(block, opCode, ShaderOper.Cr);
        }

        public static void Fsetp_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitFsetp(block, opCode, ShaderOper.Immf);
        }

        public static void Fsetp_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitFsetp(block, opCode, ShaderOper.Rr);
        }

        public static void Hadd2_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitBinaryHalfOp(block, opCode, ShaderIrInst.Fadd);
        }

        public static void Hmul2_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitBinaryHalfOp(block, opCode, ShaderIrInst.Fmul);
        }

        public static void Iadd_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitIadd(block, opCode, ShaderOper.Cr);
        }

        public static void Iadd_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitIadd(block, opCode, ShaderOper.Imm);
        }

        public static void Iadd_I32(ShaderIrBlock block, long opCode, int position)
        {
            ShaderIrNode operA = opCode.Gpr8();
            ShaderIrNode operB = opCode.Imm32_20();

            bool negA = opCode.Read(56);

            operA = GetAluIneg(operA, negA);

            ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Add, operA, operB);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        public static void Iadd_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitIadd(block, opCode, ShaderOper.Rr);
        }

        public static void Iadd3_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitIadd3(block, opCode, ShaderOper.Cr);
        }

        public static void Iadd3_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitIadd3(block, opCode, ShaderOper.Imm);
        }

        public static void Iadd3_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitIadd3(block, opCode, ShaderOper.Rr);
        }

        public static void Imnmx_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitImnmx(block, opCode, ShaderOper.Cr);
        }

        public static void Imnmx_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitImnmx(block, opCode, ShaderOper.Imm);
        }

        public static void Imnmx_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitImnmx(block, opCode, ShaderOper.Rr);
        }

        public static void Ipa(ShaderIrBlock block, long opCode, int position)
        {
            ShaderIrNode operA = opCode.Abuf28();
            ShaderIrNode operB = opCode.Gpr20();

            ShaderIpaMode mode = (ShaderIpaMode)(opCode.Read(54, 3));

            ShaderIrMetaIpa meta = new ShaderIrMetaIpa(mode);

            ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Ipa, operA, operB, null, meta);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        public static void Iscadd_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitIscadd(block, opCode, ShaderOper.Cr);
        }

        public static void Iscadd_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitIscadd(block, opCode, ShaderOper.Imm);
        }

        public static void Iscadd_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitIscadd(block, opCode, ShaderOper.Rr);
        }

        public static void Iset_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitIset(block, opCode, ShaderOper.Cr);
        }

        public static void Iset_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitIset(block, opCode, ShaderOper.Imm);
        }

        public static void Iset_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitIset(block, opCode, ShaderOper.Rr);
        }

        public static void Isetp_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitIsetp(block, opCode, ShaderOper.Cr);
        }

        public static void Isetp_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitIsetp(block, opCode, ShaderOper.Imm);
        }

        public static void Isetp_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitIsetp(block, opCode, ShaderOper.Rr);
        }

        public static void Lop_I32(ShaderIrBlock block, long opCode, int position)
        {
            int subOp = opCode.Read(53, 3);

            bool invA = opCode.Read(55);
            bool invB = opCode.Read(56);

            ShaderIrInst inst = 0;

            switch (subOp)
            {
                case 0: inst = ShaderIrInst.And; break;
                case 1: inst = ShaderIrInst.Or;  break;
                case 2: inst = ShaderIrInst.Xor; break;
            }

            ShaderIrNode operB = GetAluNot(opCode.Imm32_20(), invB);

            //SubOp == 3 is pass, used by the not instruction
            //which just moves the inverted register value.
            if (subOp < 3)
            {
                ShaderIrNode operA = GetAluNot(opCode.Gpr8(), invA);

                ShaderIrOp op = new ShaderIrOp(inst, operA, operB);

                block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
            }
            else
            {
                block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), operB)));
            }
        }

        public static void Lop_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitLop(block, opCode, ShaderOper.Cr);
        }

        public static void Lop_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitLop(block, opCode, ShaderOper.Imm);
        }

        public static void Lop_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitLop(block, opCode, ShaderOper.Rr);
        }

        public static void Mufu(ShaderIrBlock block, long opCode, int position)
        {
            int subOp = opCode.Read(20, 0xf);

            bool absA = opCode.Read(46);
            bool negA = opCode.Read(48);

            ShaderIrInst inst = 0;

            switch (subOp)
            {
                case 0: inst = ShaderIrInst.Fcos;  break;
                case 1: inst = ShaderIrInst.Fsin;  break;
                case 2: inst = ShaderIrInst.Fex2;  break;
                case 3: inst = ShaderIrInst.Flg2;  break;
                case 4: inst = ShaderIrInst.Frcp;  break;
                case 5: inst = ShaderIrInst.Frsq;  break;
                case 8: inst = ShaderIrInst.Fsqrt; break;

                default: throw new NotImplementedException(subOp.ToString());
            }

            ShaderIrNode operA = opCode.Gpr8();

            ShaderIrOp op = new ShaderIrOp(inst, GetAluFabsFneg(operA, absA, negA));

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        public static void Psetp(ShaderIrBlock block, long opCode, int position)
        {
            bool negA = opCode.Read(15);
            bool negB = opCode.Read(32);
            bool negP = opCode.Read(42);

            ShaderIrInst lopInst = opCode.BLop24();

            ShaderIrNode operA = opCode.Pred12();
            ShaderIrNode operB = opCode.Pred29();

            if (negA)
            {
                operA = new ShaderIrOp(ShaderIrInst.Bnot, operA);
            }

            if (negB)
            {
                operB = new ShaderIrOp(ShaderIrInst.Bnot, operB);
            }

            ShaderIrOp op = new ShaderIrOp(lopInst, operA, operB);

            ShaderIrOperPred p0Node = opCode.Pred3();
            ShaderIrOperPred p1Node = opCode.Pred0();
            ShaderIrOperPred p2Node = opCode.Pred39();

            block.AddNode(opCode.PredNode(new ShaderIrAsg(p0Node, op)));

            lopInst = opCode.BLop45();

            if (lopInst == ShaderIrInst.Band && p1Node.IsConst && p2Node.IsConst)
            {
                return;
            }

            ShaderIrNode p2NNode = p2Node;

            if (negP)
            {
                p2NNode = new ShaderIrOp(ShaderIrInst.Bnot, p2NNode);
            }

            op = new ShaderIrOp(ShaderIrInst.Bnot, p0Node);

            op = new ShaderIrOp(lopInst, op, p2NNode);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(p1Node, op)));

            op = new ShaderIrOp(lopInst, p0Node, p2NNode);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(p0Node, op)));
        }

        public static void Rro_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitRro(block, opCode, ShaderOper.Cr);
        }

        public static void Rro_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitRro(block, opCode, ShaderOper.Immf);
        }

        public static void Rro_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitRro(block, opCode, ShaderOper.Rr);
        }

        public static void Shl_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitAluBinary(block, opCode, ShaderOper.Cr, ShaderIrInst.Lsl);
        }

        public static void Shl_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitAluBinary(block, opCode, ShaderOper.Imm, ShaderIrInst.Lsl);
        }

        public static void Shl_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitAluBinary(block, opCode, ShaderOper.Rr, ShaderIrInst.Lsl);
        }

        public static void Shr_C(ShaderIrBlock block, long opCode, int position)
        {
            EmitAluBinary(block, opCode, ShaderOper.Cr, GetShrInst(opCode));
        }

        public static void Shr_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitAluBinary(block, opCode, ShaderOper.Imm, GetShrInst(opCode));
        }

        public static void Shr_R(ShaderIrBlock block, long opCode, int position)
        {
            EmitAluBinary(block, opCode, ShaderOper.Rr, GetShrInst(opCode));
        }

        private static ShaderIrInst GetShrInst(long opCode)
        {
            bool signed = opCode.Read(48);

            return signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr;
        }

        public static void Vmad(ShaderIrBlock block, long opCode, int position)
        {
            ShaderIrNode operA = opCode.Gpr8();

            ShaderIrNode operB;

            if (opCode.Read(50))
            {
                operB = opCode.Gpr20();
            }
            else
            {
                operB = opCode.Imm19_20();
            }

            ShaderIrOperGpr operC = opCode.Gpr39();

            ShaderIrNode tmp = new ShaderIrOp(ShaderIrInst.Mul, operA, operB);

            ShaderIrNode final = new ShaderIrOp(ShaderIrInst.Add, tmp, operC);

            int shr = opCode.Read(51, 3);

            if (shr != 0)
            {
                int shift = (shr == 2) ? 15 : 7;

                final = new ShaderIrOp(ShaderIrInst.Lsr, final, new ShaderIrOperImm(shift));
            }

            block.AddNode(new ShaderIrCmnt("Stubbed. Instruction is reduced to a * b + c"));

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), final)));
        }

        public static void Xmad_CR(ShaderIrBlock block, long opCode, int position)
        {
            EmitXmad(block, opCode, ShaderOper.Cr);
        }

        public static void Xmad_I(ShaderIrBlock block, long opCode, int position)
        {
            EmitXmad(block, opCode, ShaderOper.Imm);
        }

        public static void Xmad_RC(ShaderIrBlock block, long opCode, int position)
        {
            EmitXmad(block, opCode, ShaderOper.Rc);
        }

        public static void Xmad_RR(ShaderIrBlock block, long opCode, int position)
        {
            EmitXmad(block, opCode, ShaderOper.Rr);
        }

        private static void EmitAluBinary(
            ShaderIrBlock block,
            long          opCode,
            ShaderOper    oper,
            ShaderIrInst  inst)
        {
            ShaderIrNode operA = opCode.Gpr8(), operB;

            switch (oper)
            {
                case ShaderOper.Cr:  operB = opCode.Cbuf34();   break;
                case ShaderOper.Imm: operB = opCode.Imm19_20(); break;
                case ShaderOper.Rr:  operB = opCode.Gpr20();    break;

                default: throw new ArgumentException(nameof(oper));
            }

            ShaderIrNode op = new ShaderIrOp(inst, operA, operB);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        private static void EmitBfe(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            //TODO: Handle the case where position + length
            //is greater than the word size, in this case the sign bit
            //needs to be replicated to fill the remaining space.
            bool negB = opCode.Read(48);
            bool negA = opCode.Read(49);

            ShaderIrNode operA = opCode.Gpr8(), operB;

            switch (oper)
            {
                case ShaderOper.Cr:  operB = opCode.Cbuf34();   break;
                case ShaderOper.Imm: operB = opCode.Imm19_20(); break;
                case ShaderOper.Rr:  operB = opCode.Gpr20();    break;

                default: throw new ArgumentException(nameof(oper));
            }

            ShaderIrNode op;

            bool signed = opCode.Read(48); //?

            if (operB is ShaderIrOperImm posLen)
            {
                int position = (posLen.Value >> 0) & 0xff;
                int length   = (posLen.Value >> 8) & 0xff;

                int lSh = 32 - (position + length);

                ShaderIrInst rightShift = signed
                    ? ShaderIrInst.Asr
                    : ShaderIrInst.Lsr;

                op = new ShaderIrOp(ShaderIrInst.Lsl, operA, new ShaderIrOperImm(lSh));
                op = new ShaderIrOp(rightShift,       op,    new ShaderIrOperImm(lSh + position));
            }
            else
            {
                ShaderIrOperImm shift = new ShaderIrOperImm(8);
                ShaderIrOperImm mask  = new ShaderIrOperImm(0xff);

                ShaderIrNode opPos, opLen;

                opPos = new ShaderIrOp(ShaderIrInst.And, operB, mask);
                opLen = new ShaderIrOp(ShaderIrInst.Lsr, operB, shift);
                opLen = new ShaderIrOp(ShaderIrInst.And, opLen, mask);

                op = new ShaderIrOp(ShaderIrInst.Lsr, operA, opPos);

                op = ExtendTo32(op, signed, opLen);
            }

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        private static void EmitFadd(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            bool negB = opCode.Read(45);
            bool absA = opCode.Read(46);
            bool negA = opCode.Read(48);
            bool absB = opCode.Read(49);
            bool sat  = opCode.Read(50);

            ShaderIrNode operA = opCode.Gpr8(), operB;

            operA = GetAluFabsFneg(operA, absA, negA);

            switch (oper)
            {
                case ShaderOper.Cr:   operB = opCode.Cbuf34();    break;
                case ShaderOper.Immf: operB = opCode.Immf19_20(); break;
                case ShaderOper.Rr:   operB = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            operB = GetAluFabsFneg(operB, absB, negB);

            ShaderIrNode op = new ShaderIrOp(ShaderIrInst.Fadd, operA, operB);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), GetAluFsat(op, sat))));
        }

        private static void EmitFmul(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            bool negB = opCode.Read(48);
            bool sat  = opCode.Read(50);

            ShaderIrNode operA = opCode.Gpr8(), operB;

            switch (oper)
            {
                case ShaderOper.Cr:   operB = opCode.Cbuf34();    break;
                case ShaderOper.Immf: operB = opCode.Immf19_20(); break;
                case ShaderOper.Rr:   operB = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            operB = GetAluFneg(operB, negB);

            ShaderIrNode op = new ShaderIrOp(ShaderIrInst.Fmul, operA, operB);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), GetAluFsat(op, sat))));
        }

        private static void EmitFfma(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            bool negB = opCode.Read(48);
            bool negC = opCode.Read(49);
            bool sat  = opCode.Read(50);

            ShaderIrNode operA = opCode.Gpr8(), operB, operC;

            switch (oper)
            {
                case ShaderOper.Cr:   operB = opCode.Cbuf34();    break;
                case ShaderOper.Immf: operB = opCode.Immf19_20(); break;
                case ShaderOper.Rc:   operB = opCode.Gpr39();     break;
                case ShaderOper.Rr:   operB = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            operB = GetAluFneg(operB, negB);

            if (oper == ShaderOper.Rc)
            {
                operC = GetAluFneg(opCode.Cbuf34(), negC);
            }
            else
            {
                operC = GetAluFneg(opCode.Gpr39(), negC);
            }

            ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Ffma, operA, operB, operC);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), GetAluFsat(op, sat))));
        }

        private static void EmitIadd(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            ShaderIrNode operA = opCode.Gpr8();
            ShaderIrNode operB;

            switch (oper)
            {
                case ShaderOper.Cr:  operB = opCode.Cbuf34();   break;
                case ShaderOper.Imm: operB = opCode.Imm19_20(); break;
                case ShaderOper.Rr:  operB = opCode.Gpr20();    break;

                default: throw new ArgumentException(nameof(oper));
            }

            bool negA = opCode.Read(49);
            bool negB = opCode.Read(48);

            operA = GetAluIneg(operA, negA);
            operB = GetAluIneg(operB, negB);

            ShaderIrOp op = new ShaderIrOp(ShaderIrInst.Add, operA, operB);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        private static void EmitIadd3(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            int mode = opCode.Read(37, 3);

            bool neg1 = opCode.Read(51);
            bool neg2 = opCode.Read(50);
            bool neg3 = opCode.Read(49);

            int height1 = opCode.Read(35, 3);
            int height2 = opCode.Read(33, 3);
            int height3 = opCode.Read(31, 3);

            ShaderIrNode operB;

            switch (oper)
            {
                case ShaderOper.Cr:  operB = opCode.Cbuf34();   break;
                case ShaderOper.Imm: operB = opCode.Imm19_20(); break;
                case ShaderOper.Rr:  operB = opCode.Gpr20();    break;

                default: throw new ArgumentException(nameof(oper));
            }

            ShaderIrNode ApplyHeight(ShaderIrNode src, int height)
            {
                if (oper != ShaderOper.Rr)
                {
                    return src;
                }

                switch (height)
                {
                    case 0: return src;
                    case 1: return new ShaderIrOp(ShaderIrInst.And, src, new ShaderIrOperImm(0xffff));
                    case 2: return new ShaderIrOp(ShaderIrInst.Lsr, src, new ShaderIrOperImm(16));

                    default: throw new InvalidOperationException();
                }
            }

            ShaderIrNode src1 = GetAluIneg(ApplyHeight(opCode.Gpr8(),  height1), neg1);
            ShaderIrNode src2 = GetAluIneg(ApplyHeight(operB,          height2), neg2);
            ShaderIrNode src3 = GetAluIneg(ApplyHeight(opCode.Gpr39(), height3), neg3);

            ShaderIrOp sum = new ShaderIrOp(ShaderIrInst.Add, src1, src2);

            if (oper == ShaderOper.Rr)
            {
                switch (mode)
                {
                    case 1: sum = new ShaderIrOp(ShaderIrInst.Lsr, sum, new ShaderIrOperImm(16)); break;
                    case 2: sum = new ShaderIrOp(ShaderIrInst.Lsl, sum, new ShaderIrOperImm(16)); break;
                }
            }

            //Note: Here there should be a "+ 1" when carry flag is set
            //but since carry is mostly ignored by other instructions, it's excluded for now

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), new ShaderIrOp(ShaderIrInst.Add, sum, src3))));
        }

        private static void EmitIscadd(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            bool negB = opCode.Read(48);
            bool negA = opCode.Read(49);

            ShaderIrNode operA = opCode.Gpr8(), operB;

            ShaderIrOperImm scale = opCode.Imm5_39();

            switch (oper)
            {
                case ShaderOper.Cr:  operB = opCode.Cbuf34();   break;
                case ShaderOper.Imm: operB = opCode.Imm19_20(); break;
                case ShaderOper.Rr:  operB = opCode.Gpr20();    break;

                default: throw new ArgumentException(nameof(oper));
            }

            operA = GetAluIneg(operA, negA);
            operB = GetAluIneg(operB, negB);

            ShaderIrOp scaleOp = new ShaderIrOp(ShaderIrInst.Lsl, operA, scale);
            ShaderIrOp addOp   = new ShaderIrOp(ShaderIrInst.Add, operB, scaleOp);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), addOp)));
        }

        private static void EmitFmnmx(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            EmitMnmx(block, opCode, true, oper);
        }

        private static void EmitImnmx(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            EmitMnmx(block, opCode, false, oper);
        }

        private static void EmitMnmx(ShaderIrBlock block, long opCode, bool isFloat, ShaderOper oper)
        {
            bool negB = opCode.Read(45);
            bool absA = opCode.Read(46);
            bool negA = opCode.Read(48);
            bool absB = opCode.Read(49);

            ShaderIrNode operA = opCode.Gpr8(), operB;

            if (isFloat)
            {
                operA = GetAluFabsFneg(operA, absA, negA);
            }
            else
            {
                operA = GetAluIabsIneg(operA, absA, negA);
            }

            switch (oper)
            {
                case ShaderOper.Cr:   operB = opCode.Cbuf34();    break;
                case ShaderOper.Imm:  operB = opCode.Imm19_20();  break;
                case ShaderOper.Immf: operB = opCode.Immf19_20(); break;
                case ShaderOper.Rr:   operB = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            if (isFloat)
            {
                operB = GetAluFabsFneg(operB, absB, negB);
            }
            else
            {
                operB = GetAluIabsIneg(operB, absB, negB);
            }

            ShaderIrOperPred pred = opCode.Pred39();

            ShaderIrOp op;

            ShaderIrInst maxInst = isFloat ? ShaderIrInst.Fmax : ShaderIrInst.Max;
            ShaderIrInst minInst = isFloat ? ShaderIrInst.Fmin : ShaderIrInst.Min;

            if (pred.IsConst)
            {
                bool isMax = opCode.Read(42);

                op = new ShaderIrOp(isMax
                    ? maxInst
                    : minInst, operA, operB);

                block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
            }
            else
            {
                ShaderIrNode predN = opCode.Pred39N();

                ShaderIrOp opMax = new ShaderIrOp(maxInst, operA, operB);
                ShaderIrOp opMin = new ShaderIrOp(minInst, operA, operB);

                ShaderIrAsg asgMax = new ShaderIrAsg(opCode.Gpr0(), opMax);
                ShaderIrAsg asgMin = new ShaderIrAsg(opCode.Gpr0(), opMin);

                block.AddNode(opCode.PredNode(new ShaderIrCond(predN, asgMax, not: true)));
                block.AddNode(opCode.PredNode(new ShaderIrCond(predN, asgMin, not: false)));
            }
        }

        private static void EmitRro(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            //Note: this is a range reduction instruction and is supposed to
            //be used with Mufu, here it just moves the value and ignores the operation.
            bool negA = opCode.Read(45);
            bool absA = opCode.Read(49);

            ShaderIrNode operA;

            switch (oper)
            {
                case ShaderOper.Cr:   operA = opCode.Cbuf34();    break;
                case ShaderOper.Immf: operA = opCode.Immf19_20(); break;
                case ShaderOper.Rr:   operA = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            operA = GetAluFabsFneg(operA, absA, negA);

            block.AddNode(new ShaderIrCmnt("Stubbed."));

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), operA)));
        }

        private static void EmitFset(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            EmitSet(block, opCode, true, oper);
        }

        private static void EmitIset(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            EmitSet(block, opCode, false, oper);
        }

        private static void EmitSet(ShaderIrBlock block, long opCode, bool isFloat, ShaderOper oper)
        {
            bool negA = opCode.Read(43);
            bool absB = opCode.Read(44);
            bool negB = opCode.Read(53);
            bool absA = opCode.Read(54);

            bool boolFloat = opCode.Read(isFloat ? 52 : 44);

            ShaderIrNode operA = opCode.Gpr8(), operB;

            switch (oper)
            {
                case ShaderOper.Cr:   operB = opCode.Cbuf34();    break;
                case ShaderOper.Imm:  operB = opCode.Imm19_20();  break;
                case ShaderOper.Immf: operB = opCode.Immf19_20(); break;
                case ShaderOper.Rr:   operB = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            ShaderIrInst cmpInst;

            if (isFloat)
            {
                operA = GetAluFabsFneg(operA, absA, negA);
                operB = GetAluFabsFneg(operB, absB, negB);

                cmpInst = opCode.CmpF();
            }
            else
            {
                cmpInst = opCode.Cmp();
            }

            ShaderIrOp op = new ShaderIrOp(cmpInst, operA, operB);

            ShaderIrInst lopInst = opCode.BLop45();

            ShaderIrOperPred pNode = opCode.Pred39();

            ShaderIrNode imm0, imm1;

            if (boolFloat)
            {
                imm0 = new ShaderIrOperImmf(0);
                imm1 = new ShaderIrOperImmf(1);
            }
            else
            {
                imm0 = new ShaderIrOperImm(0);
                imm1 = new ShaderIrOperImm(-1);
            }

            ShaderIrNode asg0 = new ShaderIrAsg(opCode.Gpr0(), imm0);
            ShaderIrNode asg1 = new ShaderIrAsg(opCode.Gpr0(), imm1);

            if (lopInst != ShaderIrInst.Band || !pNode.IsConst)
            {
                ShaderIrOp op2 = new ShaderIrOp(lopInst, op, pNode);

                asg0 = new ShaderIrCond(op2, asg0, not: true);
                asg1 = new ShaderIrCond(op2, asg1, not: false);
            }
            else
            {
                asg0 = new ShaderIrCond(op, asg0, not: true);
                asg1 = new ShaderIrCond(op, asg1, not: false);
            }

            block.AddNode(opCode.PredNode(asg0));
            block.AddNode(opCode.PredNode(asg1));
        }

        private static void EmitFsetp(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            EmitSetp(block, opCode, true, oper);
        }

        private static void EmitIsetp(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            EmitSetp(block, opCode, false, oper);
        }

        private static void EmitSetp(ShaderIrBlock block, long opCode, bool isFloat, ShaderOper oper)
        {
            bool absA = opCode.Read(7);
            bool negP = opCode.Read(42);
            bool negA = opCode.Read(43);
            bool absB = opCode.Read(44);

            ShaderIrNode operA = opCode.Gpr8(), operB;

            switch (oper)
            {
                case ShaderOper.Cr:   operB = opCode.Cbuf34();    break;
                case ShaderOper.Imm:  operB = opCode.Imm19_20();  break;
                case ShaderOper.Immf: operB = opCode.Immf19_20(); break;
                case ShaderOper.Rr:   operB = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            ShaderIrInst cmpInst;

            if (isFloat)
            {
                operA = GetAluFabsFneg(operA, absA, negA);
                operB = GetAluFabs    (operB, absB);

                cmpInst = opCode.CmpF();
            }
            else
            {
                cmpInst = opCode.Cmp();
            }

            ShaderIrOp op = new ShaderIrOp(cmpInst, operA, operB);

            ShaderIrOperPred p0Node = opCode.Pred3();
            ShaderIrOperPred p1Node = opCode.Pred0();
            ShaderIrOperPred p2Node = opCode.Pred39();

            block.AddNode(opCode.PredNode(new ShaderIrAsg(p0Node, op)));

            ShaderIrInst lopInst = opCode.BLop45();

            if (lopInst == ShaderIrInst.Band && p1Node.IsConst && p2Node.IsConst)
            {
                return;
            }

            ShaderIrNode p2NNode = p2Node;

            if (negP)
            {
                p2NNode = new ShaderIrOp(ShaderIrInst.Bnot, p2NNode);
            }

            op = new ShaderIrOp(ShaderIrInst.Bnot, p0Node);

            op = new ShaderIrOp(lopInst, op, p2NNode);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(p1Node, op)));

            op = new ShaderIrOp(lopInst, p0Node, p2NNode);

            block.AddNode(opCode.PredNode(new ShaderIrAsg(p0Node, op)));
        }

        private static void EmitBinaryHalfOp(ShaderIrBlock block, long opCode, ShaderIrInst inst)
        {
            bool absB = opCode.Read(30);
            bool negB = opCode.Read(31);
            bool sat  = opCode.Read(32);
            bool absA = opCode.Read(44);

            ShaderIrOperGpr[] vecA = opCode.GprHalfVec8();
            ShaderIrOperGpr[] vecB = opCode.GprHalfVec20();

            HalfOutputType outputType = (HalfOutputType)opCode.Read(49, 3);

            int elems = outputType == HalfOutputType.PackedFp16 ? 2 : 1;
            int first = outputType == HalfOutputType.MergeH1    ? 1 : 0;

            for (int index = first; index < elems; index++)
            {
                ShaderIrNode operA = GetAluFabs    (vecA[index], absA);
                ShaderIrNode operB = GetAluFabsFneg(vecB[index], absB, negB);

                ShaderIrNode op = new ShaderIrOp(inst, operA, operB);

                ShaderIrOperGpr dst = GetHalfDst(opCode, outputType, index);

                block.AddNode(opCode.PredNode(new ShaderIrAsg(dst, GetAluFsat(op, sat))));
            }
        }

        private static ShaderIrOperGpr GetHalfDst(long opCode, HalfOutputType outputType, int index)
        {
            switch (outputType)
            {
                case HalfOutputType.PackedFp16: return opCode.GprHalf0(index);
                case HalfOutputType.Fp32:       return opCode.Gpr0();
                case HalfOutputType.MergeH0:    return opCode.GprHalf0(0);
                case HalfOutputType.MergeH1:    return opCode.GprHalf0(1);
            }

            throw new ArgumentException(nameof(outputType));
        }

        private static void EmitLop(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            int subOp = opCode.Read(41, 3);

            bool invA = opCode.Read(39);
            bool invB = opCode.Read(40);

            ShaderIrInst inst = 0;

            switch (subOp)
            {
                case 0: inst = ShaderIrInst.And; break;
                case 1: inst = ShaderIrInst.Or;  break;
                case 2: inst = ShaderIrInst.Xor; break;
            }

            ShaderIrNode operA = GetAluNot(opCode.Gpr8(), invA);
            ShaderIrNode operB;

            switch (oper)
            {
                case ShaderOper.Cr:  operB = opCode.Cbuf34();   break;
                case ShaderOper.Imm: operB = opCode.Imm19_20(); break;
                case ShaderOper.Rr:  operB = opCode.Gpr20();    break;

                default: throw new ArgumentException(nameof(oper));
            }

            operB = GetAluNot(operB, invB);

            ShaderIrNode op;

            if (subOp < 3)
            {
                op = new ShaderIrOp(inst, operA, operB);
            }
            else
            {
                op = operB;
            }

            ShaderIrNode compare = new ShaderIrOp(ShaderIrInst.Cne, op, new ShaderIrOperImm(0));

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Pred48(), compare)));

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), op)));
        }

        private enum XmadMode
        {
            Cfull = 0,
            Clo   = 1,
            Chi   = 2,
            Csfu  = 3,
            Cbcc  = 4
        }

        private static void EmitXmad(ShaderIrBlock block, long opCode, ShaderOper oper)
        {
            bool signedA = opCode.Read(48);
            bool signedB = opCode.Read(49);
            bool highB   = opCode.Read(52);
            bool highA   = opCode.Read(53);

            int mode = opCode.Read(50, 7);

            ShaderIrNode operA = opCode.Gpr8(), operB, operC;

            switch (oper)
            {
                case ShaderOper.Cr:  operB = opCode.Cbuf34();    break;
                case ShaderOper.Imm: operB = opCode.ImmU16_20(); break;
                case ShaderOper.Rc:  operB = opCode.Gpr39();     break;
                case ShaderOper.Rr:  operB = opCode.Gpr20();     break;

                default: throw new ArgumentException(nameof(oper));
            }

            ShaderIrNode operB2 = operB;

            if (oper == ShaderOper.Imm)
            {
                int imm = ((ShaderIrOperImm)operB2).Value;

                if (!highB)
                {
                    imm <<= 16;
                }

                if (signedB)
                {
                    imm >>= 16;
                }
                else
                {
                    imm = (int)((uint)imm >> 16);
                }

                operB2 = new ShaderIrOperImm(imm);
            }

            ShaderIrOperImm imm16 = new ShaderIrOperImm(16);

            //If we are working with the lower 16-bits of the A/B operands,
            //we need to shift the lower 16-bits to the top 16-bits. Later,
            //they will be right shifted. For U16 types, this will be a logical
            //right shift, and for S16 types, a arithmetic right shift.
            if (!highA)
            {
                operA = new ShaderIrOp(ShaderIrInst.Lsl, operA, imm16);
            }

            if (!highB && oper != ShaderOper.Imm)
            {
                operB2 = new ShaderIrOp(ShaderIrInst.Lsl, operB2, imm16);
            }

            ShaderIrInst shiftA = signedA ? ShaderIrInst.Asr : ShaderIrInst.Lsr;
            ShaderIrInst shiftB = signedB ? ShaderIrInst.Asr : ShaderIrInst.Lsr;

            operA = new ShaderIrOp(shiftA, operA,  imm16);

            if (oper != ShaderOper.Imm)
            {
                operB2 = new ShaderIrOp(shiftB, operB2, imm16);
            }

            bool productShiftLeft = false;
            bool merge            = false;

            if (oper == ShaderOper.Rc)
            {
                operC = opCode.Cbuf34();
            }
            else
            {
                operC = opCode.Gpr39();

                productShiftLeft = opCode.Read(36);
                merge            = opCode.Read(37);
            }

            ShaderIrOp mulOp = new ShaderIrOp(ShaderIrInst.Mul, operA, operB2);

            if (productShiftLeft)
            {
                mulOp = new ShaderIrOp(ShaderIrInst.Lsl, mulOp, imm16);
            }

            switch ((XmadMode)mode)
            {
                case XmadMode.Clo: operC = ExtendTo32(operC, signed: false, size: 16); break;

                case XmadMode.Chi: operC = new ShaderIrOp(ShaderIrInst.Lsr, operC, imm16); break;

                case XmadMode.Cbcc:
                {
                    ShaderIrOp operBLsh16 = new ShaderIrOp(ShaderIrInst.Lsl, operB, imm16);

                    operC = new ShaderIrOp(ShaderIrInst.Add, operC, operBLsh16);

                    break;
                }

                case XmadMode.Csfu:
                {
                    ShaderIrOperImm imm31 = new ShaderIrOperImm(31);

                    ShaderIrOp signAdjustA = new ShaderIrOp(ShaderIrInst.Lsr, operA,  imm31);
                    ShaderIrOp signAdjustB = new ShaderIrOp(ShaderIrInst.Lsr, operB2, imm31);

                    signAdjustA = new ShaderIrOp(ShaderIrInst.Lsl, signAdjustA, imm16);
                    signAdjustB = new ShaderIrOp(ShaderIrInst.Lsl, signAdjustB, imm16);

                    ShaderIrOp signAdjust = new ShaderIrOp(ShaderIrInst.Add, signAdjustA, signAdjustB);

                    operC = new ShaderIrOp(ShaderIrInst.Sub, operC, signAdjust);

                    break;
                }
            }

            ShaderIrOp addOp = new ShaderIrOp(ShaderIrInst.Add, mulOp, operC);

            if (merge)
            {
                ShaderIrOperImm imm16Mask = new ShaderIrOperImm(0xffff);

                addOp = new ShaderIrOp(ShaderIrInst.And, addOp, imm16Mask);
                operB = new ShaderIrOp(ShaderIrInst.Lsl, operB, imm16);
                addOp = new ShaderIrOp(ShaderIrInst.Or,  addOp, operB);
            }

            block.AddNode(opCode.PredNode(new ShaderIrAsg(opCode.Gpr0(), addOp)));
        }
    }
}