diff --git a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/CodeGenContext.cs b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/CodeGenContext.cs index f41e396250..9a683f461f 100644 --- a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/CodeGenContext.cs +++ b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/CodeGenContext.cs @@ -8,6 +8,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl { public const string Tab = " "; + public StructuredFunction CurrentFunction { get; set; } public StructuredProgramInfo Info { get; } public ShaderConfig Config { get; } diff --git a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Declarations.cs b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Declarations.cs index 11d46278e1..13e795091d 100644 --- a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Declarations.cs +++ b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Declarations.cs @@ -10,6 +10,41 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl context.AppendLine("#include "); context.AppendLine(); context.AppendLine("using namespace metal;"); + + if ((info.HelperFunctionsMask & HelperFunctionsMask.MultiplyHighS32) != 0) + { + + } + + if ((info.HelperFunctionsMask & HelperFunctionsMask.MultiplyHighU32) != 0) + { + + } + + if ((info.HelperFunctionsMask & HelperFunctionsMask.Shuffle) != 0) + { + + } + + if ((info.HelperFunctionsMask & HelperFunctionsMask.ShuffleDown) != 0) + { + + } + + if ((info.HelperFunctionsMask & HelperFunctionsMask.ShuffleUp) != 0) + { + + } + + if ((info.HelperFunctionsMask & HelperFunctionsMask.ShuffleXor) != 0) + { + + } + + if ((info.HelperFunctionsMask & HelperFunctionsMask.SwizzleAdd) != 0) + { + + } } } } \ No newline at end of file diff --git a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/HelperFunctions/HelperFunctionNames.cs b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/HelperFunctions/HelperFunctionNames.cs new file mode 100644 index 0000000000..040765ca8b --- /dev/null +++ b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/HelperFunctions/HelperFunctionNames.cs @@ -0,0 +1,14 @@ +namespace Ryujinx.Graphics.Shader.CodeGen.Msl +{ + static class HelperFunctionNames + { + public static string MultiplyHighS32 = "helperMultiplyHighS32"; + public static string MultiplyHighU32 = "helperMultiplyHighU32"; + + public static string Shuffle = "helperShuffle"; + public static string ShuffleDown = "helperShuffleDown"; + public static string ShuffleUp = "helperShuffleUp"; + public static string ShuffleXor = "helperShuffleXor"; + public static string SwizzleAdd = "helperSwizzleAdd"; + } +} diff --git a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/HelperFunctions/VoteAllEqual.metal b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/HelperFunctions/VoteAllEqual.metal new file mode 100644 index 0000000000..3eb0f50768 --- /dev/null +++ b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/HelperFunctions/VoteAllEqual.metal @@ -0,0 +1,5 @@ +template<> +inline bool voteAllEqual(bool value) +{ + return simd_all(value) || !simd_any(value); +} diff --git a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGen.cs b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGen.cs new file mode 100644 index 0000000000..dadd9f7bfb --- /dev/null +++ b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGen.cs @@ -0,0 +1,121 @@ +using Ryujinx.Graphics.Shader.IntermediateRepresentation; +using Ryujinx.Graphics.Shader.StructuredIr; +using System; + +using static Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions.InstGenHelper; +using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo; + +namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions +{ + static class InstGen + { + private static string GetExpression(CodeGenContext context, AstOperation operation) + { + Instruction inst = operation.Inst; + + InstInfo info = GetInstructionInfo(inst); + + if ((info.Type & InstType.Call) != 0) + { + bool atomic = (info.Type & InstType.Atomic) != 0; + + int arity = (int)(info.Type & InstType.ArityMask); + + string args = string.Empty; + + // Generate function + + return info.OpName + '(' + args + ')'; + } + else if ((info.Type & InstType.Op) != 0) + { + string op = info.OpName; + + if (inst == Instruction.Return && operation.SourcesCount != 0) + { + return $"{op} {GetSourceExpr(context, operation.GetSource(0), context.CurrentFunction.ReturnType)}"; + } + + int arity = (int)(info.Type & InstType.ArityMask); + + string[] expr = new string[arity]; + + for (int index = 0; index < arity; index++) + { + IAstNode src = operation.GetSource(index); + + string srcExpr = GetSourceExpr(context, src, GetSrcVarType(inst, index)); + + bool isLhs = arity == 2 && index == 0; + + expr[index] = Enclose(srcExpr, src, inst, info, isLhs); + } + + switch (arity) + { + case 0: + return op; + + case 1: + return op + expr[0]; + + case 2: + return $"{expr[0]} {op} {expr[1]}"; + + case 3: + return $"{expr[0]} {op[0]} {expr[1]} {op[1]} {expr[2]}"; + } + } + else if ((info.Type & InstType.Special) != 0) + { + switch (inst & Instruction.Mask) + { + case Instruction.Ballot: + return ""; + case Instruction.Barrier: + return ""; + case Instruction.Call: + return ""; + case Instruction.FSIBegin: + return ""; + case Instruction.FSIEnd: + return ""; + case Instruction.FindLSB: + return ""; + case Instruction.FindMSBS32: + return ""; + case Instruction.FindMSBU32: + return ""; + case Instruction.GroupMemoryBarrier: + return ""; + case Instruction.ImageLoad: + return ""; + case Instruction.ImageStore: + return ""; + case Instruction.ImageAtomic: + return ""; + case Instruction.Load: + return ""; + case Instruction.Lod: + return ""; + case Instruction.MemoryBarrier: + return ""; + case Instruction.Negate: + return ""; + case Instruction.Store: + return ""; + case Instruction.TextureSample: + return ""; + case Instruction.TextureSize: + return ""; + case Instruction.VectorExtract: + return ""; + case Instruction.VoteAllEqual: + return ""; + } + } + + throw new InvalidOperationException($"Unexpected instruction type \"{info.Type}\"."); + } + } +} diff --git a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGenHelper.cs b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGenHelper.cs index c8757ad35d..79586b0063 100644 --- a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGenHelper.cs +++ b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGenHelper.cs @@ -1,4 +1,6 @@ using Ryujinx.Graphics.Shader.IntermediateRepresentation; +using Ryujinx.Graphics.Shader.StructuredIr; +using Ryujinx.Graphics.Shader.Translation; namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions { @@ -20,7 +22,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions Add(Instruction.AtomicSwap, 0); Add(Instruction.AtomicXor, InstType.AtomicBinary, "xor"); Add(Instruction.Absolute, InstType.AtomicBinary, "abs"); - Add(Instruction.Add, InstType.OpBinaryCom, "+"); + Add(Instruction.Add, InstType.OpBinaryCom, "+", 2); Add(Instruction.Ballot, InstType.Special); Add(Instruction.Barrier, InstType.Special); Add(Instruction.BitCount, InstType.CallUnary, "popcount"); @@ -28,25 +30,25 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions Add(Instruction.BitfieldExtractU32, InstType.CallTernary, "extract_bits"); Add(Instruction.BitfieldInsert, InstType.CallQuaternary, "insert_bits"); Add(Instruction.BitfieldReverse, InstType.CallUnary, "reverse_bits"); - Add(Instruction.BitwiseAnd, InstType.OpBinaryCom, "&"); - Add(Instruction.BitwiseExclusiveOr, InstType.OpBinaryCom, "^"); - Add(Instruction.BitwiseNot, InstType.OpUnary, "~"); - Add(Instruction.BitwiseOr, InstType.OpBinaryCom, "|"); + Add(Instruction.BitwiseAnd, InstType.OpBinaryCom, "&", 6); + Add(Instruction.BitwiseExclusiveOr, InstType.OpBinaryCom, "^", 7); + Add(Instruction.BitwiseNot, InstType.OpUnary, "~", 0); + Add(Instruction.BitwiseOr, InstType.OpBinaryCom, "|", 8); Add(Instruction.Call, InstType.Special); Add(Instruction.Ceiling, InstType.CallUnary, "ceil"); Add(Instruction.Clamp, InstType.CallTernary, "clamp"); Add(Instruction.ClampU32, InstType.CallTernary, "clamp"); - Add(Instruction.CompareEqual, InstType.OpBinaryCom, "=="); - Add(Instruction.CompareGreater, InstType.OpBinary, ">"); - Add(Instruction.CompareGreaterOrEqual, InstType.OpBinary, ">="); - Add(Instruction.CompareGreaterOrEqualU32, InstType.OpBinary, ">="); - Add(Instruction.CompareGreaterU32, InstType.OpBinary, ">"); - Add(Instruction.CompareLess, InstType.OpBinary, "<"); - Add(Instruction.CompareLessOrEqual, InstType.OpBinary, "<="); - Add(Instruction.CompareLessOrEqualU32, InstType.OpBinary, "<="); - Add(Instruction.CompareLessU32, InstType.OpBinary, "<"); - Add(Instruction.CompareNotEqual, InstType.OpBinaryCom, "!="); - Add(Instruction.ConditionalSelect, InstType.OpTernary, "?:"); + Add(Instruction.CompareEqual, InstType.OpBinaryCom, "==", 5); + Add(Instruction.CompareGreater, InstType.OpBinary, ">", 4); + Add(Instruction.CompareGreaterOrEqual, InstType.OpBinary, ">=", 4); + Add(Instruction.CompareGreaterOrEqualU32, InstType.OpBinary, ">=", 4); + Add(Instruction.CompareGreaterU32, InstType.OpBinary, ">", 4); + Add(Instruction.CompareLess, InstType.OpBinary, "<", 4); + Add(Instruction.CompareLessOrEqual, InstType.OpBinary, "<=", 4); + Add(Instruction.CompareLessOrEqualU32, InstType.OpBinary, "<=", 4); + Add(Instruction.CompareLessU32, InstType.OpBinary, "<", 4); + Add(Instruction.CompareNotEqual, InstType.OpBinaryCom, "!=", 5); + Add(Instruction.ConditionalSelect, InstType.OpTernary, "?:", 12); Add(Instruction.ConvertFP32ToFP64, 0); // MSL does not have a 64-bit FP Add(Instruction.ConvertFP64ToFP32, 0); // MSL does not have a 64-bit FP Add(Instruction.ConvertFP32ToS32, InstType.Cast, "int"); @@ -61,7 +63,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions Add(Instruction.Ddx, InstType.CallUnary, "dfdx"); Add(Instruction.Ddy, InstType.CallUnary, "dfdy"); Add(Instruction.Discard, InstType.CallNullary, "discard_fragment"); - Add(Instruction.Divide, InstType.OpBinary, "/"); + Add(Instruction.Divide, InstType.OpBinary, "/", 1); Add(Instruction.EmitVertex, 0); // MSL does not have geometry shaders Add(Instruction.EndPrimitive, 0); // MSL does not have geometry shaders Add(Instruction.ExponentB2, InstType.CallUnary, "exp2"); @@ -81,10 +83,10 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions Add(Instruction.Load, InstType.Special); Add(Instruction.Lod, InstType.Special); Add(Instruction.LogarithmB2, InstType.CallUnary, "log2"); - Add(Instruction.LogicalAnd, InstType.OpBinaryCom, "&&"); - Add(Instruction.LogicalExclusiveOr, InstType.OpBinaryCom, "^"); - Add(Instruction.LogicalNot, InstType.OpUnary, "!"); - Add(Instruction.LogicalOr, InstType.OpBinaryCom, "||"); + Add(Instruction.LogicalAnd, InstType.OpBinaryCom, "&&", 9); + Add(Instruction.LogicalExclusiveOr, InstType.OpBinaryCom, "^", 10); + Add(Instruction.LogicalNot, InstType.OpUnary, "!", 0); + Add(Instruction.LogicalOr, InstType.OpBinaryCom, "||", 11); Add(Instruction.LoopBreak, InstType.OpNullary, "break"); Add(Instruction.LoopContinue, InstType.OpNullary, "continue"); Add(Instruction.PackDouble2x32, 0); // MSL does not have a 64-bit FP @@ -95,27 +97,25 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions Add(Instruction.Minimum, InstType.CallBinary, "min"); Add(Instruction.MinimumU32, InstType.CallBinary, "min"); Add(Instruction.Modulo, InstType.CallBinary, "%"); - Add(Instruction.Multiply, InstType.OpBinaryCom, "*"); - Add(Instruction.MultiplyHighS32, InstType.Special); - Add(Instruction.MultiplyHighU32, InstType.Special); - Add(Instruction.Negate, InstType.Special); + Add(Instruction.Multiply, InstType.OpBinaryCom, "*", 1); + Add(Instruction.MultiplyHighS32, InstType.CallBinary, HelperFunctionNames.MultiplyHighS32); + Add(Instruction.MultiplyHighU32, InstType.CallBinary, HelperFunctionNames.MultiplyHighU32); + Add(Instruction.Negate, InstType.OpUnary, "-"); Add(Instruction.ReciprocalSquareRoot, InstType.CallUnary, "rsqrt"); Add(Instruction.Return, InstType.OpNullary, "return"); Add(Instruction.Round, InstType.CallUnary, "round"); - Add(Instruction.ShiftLeft, InstType.OpBinary, "<<"); - Add(Instruction.ShiftRightS32, InstType.OpBinary, ">>"); - Add(Instruction.ShiftRightU32, InstType.OpBinary, ">>"); - // TODO: Shuffle funcs - Add(Instruction.Shuffle, 0); - Add(Instruction.ShuffleDown, 0); - Add(Instruction.ShuffleUp, 0); - Add(Instruction.ShuffleXor, 0); + Add(Instruction.ShiftLeft, InstType.OpBinary, "<<", 3); + Add(Instruction.ShiftRightS32, InstType.OpBinary, ">>", 3); + Add(Instruction.ShiftRightU32, InstType.OpBinary, ">>", 3); + Add(Instruction.Shuffle, InstType.CallQuaternary, HelperFunctionNames.Shuffle); + Add(Instruction.ShuffleDown, InstType.CallQuaternary, HelperFunctionNames.ShuffleDown); + Add(Instruction.ShuffleUp, InstType.CallQuaternary, HelperFunctionNames.ShuffleUp); + Add(Instruction.ShuffleXor, InstType.CallQuaternary, HelperFunctionNames.ShuffleXor); Add(Instruction.Sine, InstType.CallUnary, "sin"); Add(Instruction.SquareRoot, InstType.CallUnary, "sqrt"); Add(Instruction.Store, InstType.Special); - Add(Instruction.Subtract, InstType.OpBinary, "-"); - // TODO: Swizzle add - Add(Instruction.SwizzleAdd, InstType.Special); + Add(Instruction.Subtract, InstType.OpBinary, "-", 2); + Add(Instruction.SwizzleAdd, InstType.CallTernary, HelperFunctionNames.SwizzleAdd); Add(Instruction.TextureSample, InstType.Special); Add(Instruction.TextureSize, InstType.Special); Add(Instruction.Truncate, InstType.CallUnary, "trunc"); @@ -123,15 +123,100 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions Add(Instruction.UnpackHalf2x16, InstType.CallUnary, "unpack_unorm2x16_to_half"); Add(Instruction.VectorExtract, InstType.Special); Add(Instruction.VoteAll, InstType.CallUnary, "simd_all"); - // TODO: https://github.com/KhronosGroup/SPIRV-Cross/blob/bccaa94db814af33d8ef05c153e7c34d8bd4d685/reference/shaders-msl/comp/shader_group_vote.msl21.comp#L9 Add(Instruction.VoteAllEqual, InstType.Special); Add(Instruction.VoteAny, InstType.CallUnary, "simd_any"); #pragma warning restore IDE0055 } - private static void Add(Instruction inst, InstType flags, string opName = null) + private static void Add(Instruction inst, InstType flags, string opName = null, int precedence = 0) { - _infoTable[(int)inst] = new InstInfo(flags, opName); + _infoTable[(int)inst] = new InstInfo(flags, opName, precedence); + } + + public static InstInfo GetInstructionInfo(Instruction inst) + { + return _infoTable[(int)(inst & Instruction.Mask)]; + } + + public static string GetSourceExpr(CodeGenContext context, IAstNode node, AggregateType dstType) + { + // TODO: Implement this + // return ReinterpretCast(context, node, OperandManager.GetNodeDestType(context, node), dstType); + return ""; + } + + public static string Enclose(string expr, IAstNode node, Instruction pInst, bool isLhs) + { + InstInfo pInfo = GetInstructionInfo(pInst); + + return Enclose(expr, node, pInst, pInfo, isLhs); + } + + public static string Enclose(string expr, IAstNode node, Instruction pInst, InstInfo pInfo, bool isLhs = false) + { + if (NeedsParenthesis(node, pInst, pInfo, isLhs)) + { + expr = "(" + expr + ")"; + } + + return expr; + } + + public static bool NeedsParenthesis(IAstNode node, Instruction pInst, InstInfo pInfo, bool isLhs) + { + // If the node isn't a operation, then it can only be a operand, + // and those never needs to be surrounded in parenthesis. + if (node is not AstOperation operation) + { + // This is sort of a special case, if this is a negative constant, + // and it is consumed by a unary operation, we need to put on the parenthesis, + // as in MSL, while a sequence like ~-1 is valid, --2 is not. + if (IsNegativeConst(node) && pInfo.Type == InstType.OpUnary) + { + return true; + } + + return false; + } + + if ((pInfo.Type & (InstType.Call | InstType.Special)) != 0) + { + return false; + } + + InstInfo info = _infoTable[(int)(operation.Inst & Instruction.Mask)]; + + if ((info.Type & (InstType.Call | InstType.Special)) != 0) + { + return false; + } + + if (info.Precedence < pInfo.Precedence) + { + return false; + } + + if (info.Precedence == pInfo.Precedence && isLhs) + { + return false; + } + + if (pInst == operation.Inst && info.Type == InstType.OpBinaryCom) + { + return false; + } + + return true; + } + + private static bool IsNegativeConst(IAstNode node) + { + if (node is not AstOperand operand) + { + return false; + } + + return operand.Type == OperandType.Constant && operand.Value < 0; } } } diff --git a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstInfo.cs b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstInfo.cs index 62cbda199c..5e5d04d6b4 100644 --- a/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstInfo.cs +++ b/src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstInfo.cs @@ -6,10 +6,13 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions public string OpName { get; } - public InstInfo(InstType type, string opName) + public int Precedence { get; } + + public InstInfo(InstType type, string opName, int precedence) { Type = type; OpName = opName; + Precedence = precedence; } } } diff --git a/src/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj b/src/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj index 8ccf5348fe..e0a92da5ac 100644 --- a/src/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj +++ b/src/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj @@ -14,5 +14,8 @@ - + + + +