423 lines
No EOL
14 KiB
C#
423 lines
No EOL
14 KiB
C#
using Ryujinx.Graphics.Shader.Decoders;
|
|
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
|
using Ryujinx.Graphics.Shader.Translation;
|
|
using System;
|
|
|
|
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 Fadd(EmitterContext context)
|
|
{
|
|
IOpCodeFArith op = (IOpCodeFArith)context.CurrOp;
|
|
|
|
bool absoluteA = op.AbsoluteA, absoluteB, negateA, negateB;
|
|
|
|
if (op is OpCodeFArithImm32)
|
|
{
|
|
negateB = op.RawOpCode.Extract(53);
|
|
negateA = op.RawOpCode.Extract(56);
|
|
absoluteB = op.RawOpCode.Extract(57);
|
|
}
|
|
else
|
|
{
|
|
negateB = op.RawOpCode.Extract(45);
|
|
negateA = op.RawOpCode.Extract(48);
|
|
absoluteB = op.RawOpCode.Extract(49);
|
|
}
|
|
|
|
Operand srcA = context.FPAbsNeg(GetSrcA(context), absoluteA, negateA);
|
|
Operand srcB = context.FPAbsNeg(GetSrcB(context), absoluteB, negateB);
|
|
|
|
Operand dest = GetDest(context);
|
|
|
|
context.Copy(dest, context.FPSaturate(context.FPAdd(srcA, srcB), op.Saturate));
|
|
|
|
SetFPZnFlags(context, dest, op.SetCondCode);
|
|
}
|
|
|
|
public static void Ffma(EmitterContext context)
|
|
{
|
|
IOpCodeFArith op = (IOpCodeFArith)context.CurrOp;
|
|
|
|
bool negateB = op.RawOpCode.Extract(48);
|
|
bool negateC = op.RawOpCode.Extract(49);
|
|
|
|
Operand srcA = GetSrcA(context);
|
|
|
|
Operand srcB = context.FPNegate(GetSrcB(context), negateB);
|
|
Operand srcC = context.FPNegate(GetSrcC(context), negateC);
|
|
|
|
Operand dest = GetDest(context);
|
|
|
|
context.Copy(dest, context.FPSaturate(context.FPFusedMultiplyAdd(srcA, srcB, srcC), op.Saturate));
|
|
|
|
SetFPZnFlags(context, dest, op.SetCondCode);
|
|
}
|
|
|
|
public static void Fmnmx(EmitterContext context)
|
|
{
|
|
IOpCodeFArith op = (IOpCodeFArith)context.CurrOp;
|
|
|
|
bool absoluteA = op.AbsoluteA;
|
|
bool negateB = op.RawOpCode.Extract(45);
|
|
bool negateA = op.RawOpCode.Extract(48);
|
|
bool absoluteB = op.RawOpCode.Extract(49);
|
|
|
|
Operand srcA = context.FPAbsNeg(GetSrcA(context), absoluteA, negateA);
|
|
Operand srcB = context.FPAbsNeg(GetSrcB(context), absoluteB, negateB);
|
|
|
|
Operand resMin = context.FPMinimum(srcA, srcB);
|
|
Operand resMax = context.FPMaximum(srcA, srcB);
|
|
|
|
Operand pred = GetPredicate39(context);
|
|
|
|
Operand dest = GetDest(context);
|
|
|
|
context.Copy(dest, context.ConditionalSelect(pred, resMin, resMax));
|
|
|
|
SetFPZnFlags(context, dest, op.SetCondCode);
|
|
}
|
|
|
|
public static void Fmul(EmitterContext context)
|
|
{
|
|
IOpCodeFArith op = (IOpCodeFArith)context.CurrOp;
|
|
|
|
bool isImm32 = op is OpCodeFArithImm32;
|
|
|
|
bool negateB = !isImm32 && op.RawOpCode.Extract(48);
|
|
|
|
Operand srcA = GetSrcA(context);
|
|
|
|
Operand srcB = context.FPNegate(GetSrcB(context), negateB);
|
|
|
|
switch (op.Scale)
|
|
{
|
|
case FmulScale.None: break;
|
|
|
|
case FmulScale.Divide2: srcA = context.FPDivide (srcA, ConstF(2)); break;
|
|
case FmulScale.Divide4: srcA = context.FPDivide (srcA, ConstF(4)); break;
|
|
case FmulScale.Divide8: srcA = context.FPDivide (srcA, ConstF(8)); break;
|
|
case FmulScale.Multiply2: srcA = context.FPMultiply(srcA, ConstF(2)); break;
|
|
case FmulScale.Multiply4: srcA = context.FPMultiply(srcA, ConstF(4)); break;
|
|
case FmulScale.Multiply8: srcA = context.FPMultiply(srcA, ConstF(8)); break;
|
|
|
|
default: break; //TODO: Warning.
|
|
}
|
|
|
|
Operand dest = GetDest(context);
|
|
|
|
bool saturate = isImm32 ? op.RawOpCode.Extract(55) : op.Saturate;
|
|
|
|
context.Copy(dest, context.FPSaturate(context.FPMultiply(srcA, srcB), saturate));
|
|
|
|
SetFPZnFlags(context, dest, op.SetCondCode);
|
|
}
|
|
|
|
public static void Fset(EmitterContext context)
|
|
{
|
|
OpCodeSet op = (OpCodeSet)context.CurrOp;
|
|
|
|
Condition cmpOp = (Condition)op.RawOpCode.Extract(48, 4);
|
|
|
|
bool negateA = op.RawOpCode.Extract(43);
|
|
bool absoluteB = op.RawOpCode.Extract(44);
|
|
bool boolFloat = op.RawOpCode.Extract(52);
|
|
bool negateB = op.RawOpCode.Extract(53);
|
|
bool absoluteA = op.RawOpCode.Extract(54);
|
|
|
|
Operand srcA = context.FPAbsNeg(GetSrcA(context), absoluteA, negateA);
|
|
Operand srcB = context.FPAbsNeg(GetSrcB(context), absoluteB, negateB);
|
|
|
|
Operand res = GetFPComparison(context, cmpOp, srcA, srcB);
|
|
|
|
Operand pred = GetPredicate39(context);
|
|
|
|
res = GetPredLogicalOp(context, op.LogicalOp, res, pred);
|
|
|
|
Operand dest = GetDest(context);
|
|
|
|
if (boolFloat)
|
|
{
|
|
context.Copy(dest, context.ConditionalSelect(res, ConstF(1), Const(0)));
|
|
}
|
|
else
|
|
{
|
|
context.Copy(dest, res);
|
|
}
|
|
|
|
// TODO: CC, X
|
|
}
|
|
|
|
public static void Fsetp(EmitterContext context)
|
|
{
|
|
OpCodeSet op = (OpCodeSet)context.CurrOp;
|
|
|
|
Condition cmpOp = (Condition)op.RawOpCode.Extract(48, 4);
|
|
|
|
bool negateB = op.RawOpCode.Extract(6);
|
|
bool absoluteA = op.RawOpCode.Extract(7);
|
|
bool negateA = op.RawOpCode.Extract(43);
|
|
bool absoluteB = op.RawOpCode.Extract(44);
|
|
|
|
Operand srcA = context.FPAbsNeg(GetSrcA(context), absoluteA, negateA);
|
|
Operand srcB = context.FPAbsNeg(GetSrcB(context), absoluteB, negateB);
|
|
|
|
Operand p0Res = GetFPComparison(context, cmpOp, srcA, srcB);
|
|
|
|
Operand p1Res = context.BitwiseNot(p0Res);
|
|
|
|
Operand pred = GetPredicate39(context);
|
|
|
|
p0Res = GetPredLogicalOp(context, op.LogicalOp, p0Res, pred);
|
|
p1Res = GetPredLogicalOp(context, op.LogicalOp, p1Res, pred);
|
|
|
|
context.Copy(Register(op.Predicate3), p0Res);
|
|
context.Copy(Register(op.Predicate0), p1Res);
|
|
}
|
|
|
|
public static void Fswzadd(EmitterContext context)
|
|
{
|
|
OpCodeAlu op = (OpCodeAlu)context.CurrOp;
|
|
|
|
int mask = op.RawOpCode.Extract(28, 8);
|
|
|
|
Operand srcA = GetSrcA(context);
|
|
Operand srcB = GetSrcB(context);
|
|
|
|
Operand dest = GetDest(context);
|
|
|
|
context.Copy(dest, context.FPSwizzleAdd(srcA, srcB, mask));
|
|
|
|
SetFPZnFlags(context, dest, op.SetCondCode);
|
|
}
|
|
|
|
public static void Hadd2(EmitterContext context)
|
|
{
|
|
Hadd2Hmul2Impl(context, isAdd: true);
|
|
}
|
|
|
|
public static void Hfma2(EmitterContext context)
|
|
{
|
|
IOpCodeHfma op = (IOpCodeHfma)context.CurrOp;
|
|
|
|
Operand[] srcA = GetHfmaSrcA(context);
|
|
Operand[] srcB = GetHfmaSrcB(context);
|
|
Operand[] srcC = GetHfmaSrcC(context);
|
|
|
|
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], op.Saturate);
|
|
}
|
|
|
|
context.Copy(GetDest(context), GetHalfPacked(context, res));
|
|
}
|
|
|
|
public static void Hmul2(EmitterContext context)
|
|
{
|
|
Hadd2Hmul2Impl(context, isAdd: false);
|
|
}
|
|
|
|
private static void Hadd2Hmul2Impl(EmitterContext context, bool isAdd)
|
|
{
|
|
OpCode op = context.CurrOp;
|
|
|
|
bool saturate = op.RawOpCode.Extract(op is IOpCodeReg ? 32 : 52);
|
|
|
|
Operand[] srcA = GetHalfSrcA(context);
|
|
Operand[] srcB = GetHalfSrcB(context);
|
|
|
|
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(context), GetHalfPacked(context, res));
|
|
}
|
|
|
|
public static void Hsetp2(EmitterContext context)
|
|
{
|
|
OpCodeSet op = (OpCodeSet)context.CurrOp;
|
|
|
|
bool hAnd = op.RawOpCode.Extract(53);
|
|
|
|
Condition cmpOp = op is IOpCodeReg
|
|
? (Condition)op.RawOpCode.Extract(35, 4)
|
|
: (Condition)op.RawOpCode.Extract(49, 4);
|
|
|
|
Operand[] srcA = GetHalfSrcA(context);
|
|
Operand[] srcB = GetHalfSrcB(context);
|
|
|
|
Operand[] res = new Operand[2];
|
|
|
|
Operand pred = GetPredicate39(context);
|
|
|
|
Operand p0Res = GetFPComparison(context, cmpOp, srcA[0], srcB[0]);
|
|
Operand p1Res = GetFPComparison(context, cmpOp, srcA[1], srcB[1]);
|
|
|
|
if (hAnd)
|
|
{
|
|
p0Res = context.BitwiseAnd(p0Res, p1Res);
|
|
p1Res = context.BitwiseNot(p0Res);
|
|
}
|
|
|
|
p0Res = GetPredLogicalOp(context, op.LogicalOp, p0Res, pred);
|
|
p1Res = GetPredLogicalOp(context, op.LogicalOp, p1Res, pred);
|
|
|
|
context.Copy(Register(op.Predicate3), p0Res);
|
|
context.Copy(Register(op.Predicate0), p1Res);
|
|
}
|
|
|
|
public static void Mufu(EmitterContext context)
|
|
{
|
|
IOpCodeFArith op = (IOpCodeFArith)context.CurrOp;
|
|
|
|
bool negateB = op.RawOpCode.Extract(48);
|
|
|
|
Operand res = context.FPAbsNeg(GetSrcA(context), op.AbsoluteA, negateB);
|
|
|
|
MufuOperation subOp = (MufuOperation)context.CurrOp.RawOpCode.Extract(20, 4);
|
|
|
|
switch (subOp)
|
|
{
|
|
case MufuOperation.Cosine:
|
|
res = context.FPCosine(res);
|
|
break;
|
|
|
|
case MufuOperation.Sine:
|
|
res = context.FPSine(res);
|
|
break;
|
|
|
|
case MufuOperation.ExponentB2:
|
|
res = context.FPExponentB2(res);
|
|
break;
|
|
|
|
case MufuOperation.LogarithmB2:
|
|
res = context.FPLogarithmB2(res);
|
|
break;
|
|
|
|
case MufuOperation.Reciprocal:
|
|
res = context.FPReciprocal(res);
|
|
break;
|
|
|
|
case MufuOperation.ReciprocalSquareRoot:
|
|
res = context.FPReciprocalSquareRoot(res);
|
|
break;
|
|
|
|
case MufuOperation.SquareRoot:
|
|
res = context.FPSquareRoot(res);
|
|
break;
|
|
|
|
default: /* TODO */ break;
|
|
}
|
|
|
|
context.Copy(GetDest(context), context.FPSaturate(res, op.Saturate));
|
|
}
|
|
|
|
private static Operand GetFPComparison(
|
|
EmitterContext context,
|
|
Condition cond,
|
|
Operand srcA,
|
|
Operand srcB)
|
|
{
|
|
Operand res;
|
|
|
|
if (cond == Condition.Always)
|
|
{
|
|
res = Const(IrConsts.True);
|
|
}
|
|
else if (cond == Condition.Never)
|
|
{
|
|
res = Const(IrConsts.False);
|
|
}
|
|
else if (cond == Condition.Nan || cond == Condition.Number)
|
|
{
|
|
res = context.BitwiseOr(context.IsNan(srcA), context.IsNan(srcB));
|
|
|
|
if (cond == Condition.Number)
|
|
{
|
|
res = context.BitwiseNot(res);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Instruction inst;
|
|
|
|
switch (cond & ~Condition.Nan)
|
|
{
|
|
case Condition.Less: inst = Instruction.CompareLess; break;
|
|
case Condition.Equal: inst = Instruction.CompareEqual; break;
|
|
case Condition.LessOrEqual: inst = Instruction.CompareLessOrEqual; break;
|
|
case Condition.Greater: inst = Instruction.CompareGreater; break;
|
|
case Condition.NotEqual: inst = Instruction.CompareNotEqual; break;
|
|
case Condition.GreaterOrEqual: inst = Instruction.CompareGreaterOrEqual; break;
|
|
|
|
default: throw new InvalidOperationException($"Unexpected condition \"{cond}\".");
|
|
}
|
|
|
|
res = context.Add(inst | Instruction.FP, Local(), srcA, srcB);
|
|
|
|
if ((cond & Condition.Nan) != 0)
|
|
{
|
|
res = context.BitwiseOr(res, context.IsNan(srcA));
|
|
res = context.BitwiseOr(res, context.IsNan(srcB));
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
private static void SetFPZnFlags(EmitterContext context, Operand dest, bool setCC)
|
|
{
|
|
if (setCC)
|
|
{
|
|
context.Copy(GetZF(context), context.FPCompareEqual(dest, ConstF(0)));
|
|
context.Copy(GetNF(context), context.FPCompareLess (dest, ConstF(0)));
|
|
}
|
|
}
|
|
|
|
private static Operand[] GetHfmaSrcA(EmitterContext context)
|
|
{
|
|
IOpCodeHfma op = (IOpCodeHfma)context.CurrOp;
|
|
|
|
return GetHalfUnpacked(context, GetSrcA(context), op.SwizzleA);
|
|
}
|
|
|
|
private static Operand[] GetHfmaSrcB(EmitterContext context)
|
|
{
|
|
IOpCodeHfma op = (IOpCodeHfma)context.CurrOp;
|
|
|
|
Operand[] operands = GetHalfUnpacked(context, GetSrcB(context), op.SwizzleB);
|
|
|
|
return FPAbsNeg(context, operands, false, op.NegateB);
|
|
}
|
|
|
|
private static Operand[] GetHfmaSrcC(EmitterContext context)
|
|
{
|
|
IOpCodeHfma op = (IOpCodeHfma)context.CurrOp;
|
|
|
|
Operand[] operands = GetHalfUnpacked(context, GetSrcC(context), op.SwizzleC);
|
|
|
|
return FPAbsNeg(context, operands, false, op.NegateC);
|
|
}
|
|
}
|
|
} |