Getting somewhere…

src/Ryujinx.Graphics.Shader/CodeGen/Msl/CodeGenContext.cs

@@ -9,9 +9,13 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl
         public const string Tab = "    ";
 
         public StructuredFunction CurrentFunction { get; set; }
+
         public StructuredProgramInfo Info { get; }
+
         public ShaderConfig Config { get; }
 
+        public OperandManager OperandManager { get;  }
+
         private readonly StringBuilder _sb;
 
         private int _level;
@@ -23,6 +27,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl
             Info = info;
             Config = config;
 
+            OperandManager = new OperandManager();
+
             _sb = new StringBuilder();
         }
 

src/Ryujinx.Graphics.Shader/CodeGen/Msl/Declarations.cs

@@ -1,4 +1,6 @@
 using Ryujinx.Graphics.Shader.StructuredIr;
+using Ryujinx.Graphics.Shader.Translation;
+using System;
 
 namespace Ryujinx.Graphics.Shader.CodeGen.Msl
 {
@@ -11,40 +13,45 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl
             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)
             {
 
             }
         }
+
+        public static void DeclareLocals(CodeGenContext context, StructuredFunction function)
+        {
+            foreach (AstOperand decl in function.Locals)
+            {
+                string name = context.OperandManager.DeclareLocal(decl);
+
+                context.AppendLine(GetVarTypeName(context, decl.VarType) + " " + name + ";");
+            }
+        }
+
+        public static string GetVarTypeName(CodeGenContext context, AggregateType type)
+        {
+            return type switch
+            {
+                AggregateType.Void => "void",
+                AggregateType.Bool => "bool",
+                AggregateType.FP32 => "float",
+                AggregateType.S32 => "int",
+                AggregateType.U32 => "uint",
+                AggregateType.Vector2 | AggregateType.Bool => "bool2",
+                AggregateType.Vector2 | AggregateType.FP32 => "float2",
+                AggregateType.Vector2 | AggregateType.S32 => "int2",
+                AggregateType.Vector2 | AggregateType.U32 => "uint2",
+                AggregateType.Vector3 | AggregateType.Bool => "bool3",
+                AggregateType.Vector3 | AggregateType.FP32 => "float3",
+                AggregateType.Vector3 | AggregateType.S32 => "int3",
+                AggregateType.Vector3 | AggregateType.U32 => "uint3",
+                AggregateType.Vector4 | AggregateType.Bool => "bool4",
+                AggregateType.Vector4 | AggregateType.FP32 => "float4",
+                AggregateType.Vector4 | AggregateType.S32 => "int4",
+                AggregateType.Vector4 | AggregateType.U32 => "uint4",
+                _ => throw new ArgumentException($"Invalid variable type \"{type}\"."),
+            };
+        }
     }
 }

src/Ryujinx.Graphics.Shader/CodeGen/Msl/DefaultNames.cs

@@ -0,0 +1,15 @@
+namespace Ryujinx.Graphics.Shader.CodeGen.Msl
+{
+    static class DefaultNames
+    {
+        public const string LocalNamePrefix = "temp";
+
+        public const string PerPatchAttributePrefix = "patchAttr";
+        public const string IAttributePrefix = "inAttr";
+        public const string OAttributePrefix = "outAttr";
+
+        public const string ArgumentNamePrefix = "a";
+
+        public const string UndefinedName = "undef";
+    }
+}

src/Ryujinx.Graphics.Shader/CodeGen/Msl/Instructions/InstGen.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Graphics.Shader.IntermediateRepresentation;
 using Ryujinx.Graphics.Shader.StructuredIr;
+using Ryujinx.Graphics.Shader.Translation;
 using System;
 
 using static Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions.InstGenHelper;
@@ -9,6 +10,20 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions
 {
     static class InstGen
     {
+        public static string GetExpression(CodeGenContext context, IAstNode node)
+        {
+            if (node is AstOperation operation)
+            {
+                return GetExpression(context, operation);
+            }
+            else if (node is AstOperand operand)
+            {
+                return context.OperandManager.GetExpression(context, operand);
+            }
+
+            throw new ArgumentException($"Invalid node type \"{node?.GetType().Name ?? "null"}\".");
+        }
+
         private static string GetExpression(CodeGenContext context, AstOperation operation)
         {
             Instruction inst = operation.Inst;
@@ -23,7 +38,24 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions
 
                 string args = string.Empty;
 
-                // Generate function
+                if (atomic)
+                {
+                    // Hell
+                }
+                else
+                {
+                    for (int argIndex = 0; argIndex < arity; argIndex++)
+                    {
+                        if (argIndex != 0)
+                        {
+                            args += ", ";
+                        }
+
+                        AggregateType dstType = GetSrcVarType(inst, argIndex);
+
+                        args += GetSourceExpr(context, operation.GetSource(argIndex), dstType);
+                    }
+                }
 
                 return info.OpName + '(' + args + ')';
             }
@@ -71,43 +103,43 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions
                 switch (inst & Instruction.Mask)
                 {
                     case Instruction.Barrier:
-                        return "";
+                        return "|| BARRIER ||";
                     case Instruction.Call:
-                        return "";
+                        return "|| CALL ||";
                     case Instruction.FSIBegin:
-                        return "";
+                        return "|| FSI BEGIN ||";
                     case Instruction.FSIEnd:
-                        return "";
+                        return "|| FSI END ||";
                     case Instruction.FindLSB:
-                        return "";
+                        return "|| FIND LSB ||";
                     case Instruction.FindMSBS32:
-                        return "";
+                        return "|| FIND MSB S32 ||";
                     case Instruction.FindMSBU32:
-                        return "";
+                        return "|| FIND MSB U32 ||";
                     case Instruction.GroupMemoryBarrier:
-                        return "";
+                        return "|| FIND GROUP MEMORY BARRIER ||";
                     case Instruction.ImageLoad:
-                        return "";
+                        return "|| IMAGE LOAD ||";
                     case Instruction.ImageStore:
-                        return "";
+                        return "|| IMAGE STORE ||";
                     case Instruction.ImageAtomic:
-                        return "";
+                        return "|| IMAGE ATOMIC ||";
                     case Instruction.Load:
-                        return "";
+                        return "|| LOAD ||";
                     case Instruction.Lod:
-                        return "";
+                        return "|| LOD ||";
                     case Instruction.MemoryBarrier:
-                        return "";
+                        return "|| MEMORY BARRIER ||";
                     case Instruction.Store:
-                        return "";
+                        return "|| STORE ||";
                     case Instruction.TextureSample:
-                        return "";
+                        return "|| TEXTURE SAMPLE ||";
                     case Instruction.TextureSize:
-                        return "";
+                        return "|| TEXTURE SIZE ||";
                     case Instruction.VectorExtract:
-                        return "";
+                        return "|| VECTOR EXTRACT ||";
                     case Instruction.VoteAllEqual:
-                        return "";
+                        return "|| VOTE ALL EQUAL ||";
                 }
             }
 

src/Ryujinx.Graphics.Shader/CodeGen/Msl/MslGenerator.cs

@@ -1,6 +1,10 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions;
 using Ryujinx.Graphics.Shader.StructuredIr;
 using Ryujinx.Graphics.Shader.Translation;
+using System;
+
+using static Ryujinx.Graphics.Shader.CodeGen.Msl.TypeConversion;
 
 namespace Ryujinx.Graphics.Shader.CodeGen.Msl
 {
@@ -18,7 +22,178 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Msl
 
             Declarations.Declare(context, info);
 
+            if (info.Functions.Count != 0)
+            {
+                for (int i = 1; i < info.Functions.Count; i++)
+                {
+                    context.AppendLine($"{GetFunctionSignature(context, info.Functions[i], config.Stage)};");
+                }
+
+                context.AppendLine();
+
+                for (int i = 1; i < info.Functions.Count; i++)
+                {
+                    PrintFunction(context, info.Functions[i], config.Stage);
+
+                    context.AppendLine();
+                }
+            }
+
+            PrintFunction(context, info.Functions[0], config.Stage, true);
+
             return context.GetCode();
         }
+
+        private static void PrintFunction(CodeGenContext context, StructuredFunction function, ShaderStage stage, bool isMainFunc = false)
+        {
+            context.CurrentFunction = function;
+
+            context.AppendLine(GetFunctionSignature(context, function, stage, isMainFunc));
+            context.EnterScope();
+
+            Declarations.DeclareLocals(context, function);
+
+            PrintBlock(context, function.MainBlock, isMainFunc);
+
+            context.LeaveScope();
+        }
+
+        private static string GetFunctionSignature(CodeGenContext context, StructuredFunction function, ShaderStage stage, bool isMainFunc = false)
+        {
+            string[] args = new string[function.InArguments.Length + function.OutArguments.Length];
+
+            for (int i = 0; i < function.InArguments.Length; i++)
+            {
+                args[i] = $"{Declarations.GetVarTypeName(context, function.InArguments[i])} {OperandManager.GetArgumentName(i)}";
+            }
+
+            for (int i = 0; i < function.OutArguments.Length; i++)
+            {
+                int j = i + function.InArguments.Length;
+
+                // Likely need to be made into pointers
+                args[j] = $"out {Declarations.GetVarTypeName(context, function.OutArguments[i])} {OperandManager.GetArgumentName(j)}";
+            }
+
+            string funcKeyword = "inline";
+            string funcName = null;
+            if (isMainFunc)
+            {
+                if (stage == ShaderStage.Vertex)
+                {
+                    funcKeyword = "vertex";
+                    funcName = "vertexMain";
+                }
+                else if (stage == ShaderStage.Fragment)
+                {
+                    funcKeyword = "fragment";
+                    funcName = "fragmentMain";
+                }
+            }
+
+            return $"{funcKeyword} {Declarations.GetVarTypeName(context, function.ReturnType)} {funcName ?? function.Name}({string.Join(", ", args)})";
+        }
+
+        private static void PrintBlock(CodeGenContext context, AstBlock block, bool isMainFunction)
+        {
+            AstBlockVisitor visitor = new(block);
+
+            visitor.BlockEntered += (sender, e) =>
+            {
+                switch (e.Block.Type)
+                {
+                    case AstBlockType.DoWhile:
+                        context.AppendLine("do");
+                        break;
+
+                    case AstBlockType.Else:
+                        context.AppendLine("else");
+                        break;
+
+                    case AstBlockType.ElseIf:
+                        context.AppendLine($"else if ({GetCondExpr(context, e.Block.Condition)})");
+                        break;
+
+                    case AstBlockType.If:
+                        context.AppendLine($"if ({GetCondExpr(context, e.Block.Condition)})");
+                        break;
+
+                    default:
+                        throw new InvalidOperationException($"Found unexpected block type \"{e.Block.Type}\".");
+                }
+
+                context.EnterScope();
+            };
+
+            visitor.BlockLeft += (sender, e) =>
+            {
+                context.LeaveScope();
+
+                if (e.Block.Type == AstBlockType.DoWhile)
+                {
+                    context.AppendLine($"while ({GetCondExpr(context, e.Block.Condition)});");
+                }
+            };
+
+            bool supportsBarrierDivergence = context.Config.GpuAccessor.QueryHostSupportsShaderBarrierDivergence();
+            bool mayHaveReturned = false;
+
+            foreach (IAstNode node in visitor.Visit())
+            {
+                if (node is AstOperation operation)
+                {
+                    if (!supportsBarrierDivergence)
+                    {
+                        if (operation.Inst == IntermediateRepresentation.Instruction.Barrier)
+                        {
+                            // Barrier on divergent control flow paths may cause the GPU to hang,
+                            // so skip emitting the barrier for those cases.
+                            if (visitor.Block.Type != AstBlockType.Main || mayHaveReturned || !isMainFunction)
+                            {
+                                context.Config.GpuAccessor.Log($"Shader has barrier on potentially divergent block, the barrier will be removed.");
+
+                                continue;
+                            }
+                        }
+                        else if (operation.Inst == IntermediateRepresentation.Instruction.Return)
+                        {
+                            mayHaveReturned = true;
+                        }
+                    }
+
+                    string expr = InstGen.GetExpression(context, operation);
+
+                    if (expr != null)
+                    {
+                        context.AppendLine(expr + ";");
+                    }
+                }
+                else if (node is AstAssignment assignment)
+                {
+                    AggregateType dstType = OperandManager.GetNodeDestType(context, assignment.Destination);
+                    AggregateType srcType = OperandManager.GetNodeDestType(context, assignment.Source);
+
+                    string dest = InstGen.GetExpression(context, assignment.Destination);
+                    string src = ReinterpretCast(context, assignment.Source, srcType, dstType);
+
+                    context.AppendLine(dest + " = " + src + ";");
+                }
+                else if (node is AstComment comment)
+                {
+                    context.AppendLine("// " + comment.Comment);
+                }
+                else
+                {
+                    throw new InvalidOperationException($"Found unexpected node type \"{node?.GetType().Name ?? "null"}\".");
+                }
+            }
+        }
+
+        private static string GetCondExpr(CodeGenContext context, IAstNode cond)
+        {
+            AggregateType srcType = OperandManager.GetNodeDestType(context, cond);
+
+            return ReinterpretCast(context, cond, srcType, AggregateType.Bool);
+        }
     }
 }

src/Ryujinx.Graphics.Shader/CodeGen/Msl/NumberFormatter.cs

@@ -0,0 +1,102 @@
+using Ryujinx.Graphics.Shader.Translation;
+using System;
+using System.Globalization;
+
+namespace Ryujinx.Graphics.Shader.CodeGen.Msl
+{
+    static class NumberFormatter
+    {
+        private const int MaxDecimal = 256;
+
+        public static bool TryFormat(int value, AggregateType dstType, out string formatted)
+        {
+            if (dstType == AggregateType.FP32)
+            {
+                return TryFormatFloat(BitConverter.Int32BitsToSingle(value), out formatted);
+            }
+            else if (dstType == AggregateType.S32)
+            {
+                formatted = FormatInt(value);
+            }
+            else if (dstType == AggregateType.U32)
+            {
+                formatted = FormatUint((uint)value);
+            }
+            else if (dstType == AggregateType.Bool)
+            {
+                formatted = value != 0 ? "true" : "false";
+            }
+            else
+            {
+                throw new ArgumentException($"Invalid variable type \"{dstType}\".");
+            }
+
+            return true;
+        }
+
+        public static string FormatFloat(float value)
+        {
+            if (!TryFormatFloat(value, out string formatted))
+            {
+                throw new ArgumentException("Failed to convert float value to string.");
+            }
+
+            return formatted;
+        }
+
+        public static bool TryFormatFloat(float value, out string formatted)
+        {
+            if (float.IsNaN(value) || float.IsInfinity(value))
+            {
+                formatted = null;
+
+                return false;
+            }
+
+            formatted = value.ToString("F9", CultureInfo.InvariantCulture);
+
+            if (!formatted.Contains('.'))
+            {
+                formatted += ".0f";
+            }
+
+            return true;
+        }
+
+        public static string FormatInt(int value, AggregateType dstType)
+        {
+            if (dstType == AggregateType.S32)
+            {
+                return FormatInt(value);
+            }
+            else if (dstType == AggregateType.U32)
+            {
+                return FormatUint((uint)value);
+            }
+            else
+            {
+                throw new ArgumentException($"Invalid variable type \"{dstType}\".");
+            }
+        }
+
+        public static string FormatInt(int value)
+        {
+            if (value <= MaxDecimal && value >= -MaxDecimal)
+            {
+                return value.ToString(CultureInfo.InvariantCulture);
+            }
+
+            return "0x" + value.ToString("X", CultureInfo.InvariantCulture);
+        }
+
+        public static string FormatUint(uint value)
+        {
+            if (value <= MaxDecimal && value >= 0)
+            {
+                return value.ToString(CultureInfo.InvariantCulture) + "u";
+            }
+
+            return "0x" + value.ToString("X", CultureInfo.InvariantCulture) + "u";
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/CodeGen/Msl/OperandManager.cs

@@ -0,0 +1,173 @@
+using Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions;
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using Ryujinx.Graphics.Shader.StructuredIr;
+using Ryujinx.Graphics.Shader.Translation;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
+
+namespace Ryujinx.Graphics.Shader.CodeGen.Msl
+{
+    class OperandManager
+    {
+         private readonly Dictionary<AstOperand, string> _locals;
+
+        public OperandManager()
+        {
+            _locals = new Dictionary<AstOperand, string>();
+        }
+
+        public string DeclareLocal(AstOperand operand)
+        {
+            string name = $"{DefaultNames.LocalNamePrefix}_{_locals.Count}";
+
+            _locals.Add(operand, name);
+
+            return name;
+        }
+
+        public string GetExpression(CodeGenContext context, AstOperand operand)
+        {
+            return operand.Type switch
+            {
+                OperandType.Argument => GetArgumentName(operand.Value),
+                OperandType.Constant => NumberFormatter.FormatInt(operand.Value),
+                OperandType.LocalVariable => _locals[operand],
+                OperandType.Undefined => DefaultNames.UndefinedName,
+                _ => throw new ArgumentException($"Invalid operand type \"{operand.Type}\"."),
+            };
+        }
+
+        public static string GetArgumentName(int argIndex)
+        {
+            return $"{DefaultNames.ArgumentNamePrefix}{argIndex}";
+        }
+
+        public static AggregateType GetNodeDestType(CodeGenContext context, IAstNode node)
+        {
+            // TODO: Get rid of that function entirely and return the type from the operation generation
+            // functions directly, like SPIR-V does.
+
+            if (node is AstOperation operation)
+            {
+                if (operation.Inst == Instruction.Load || operation.Inst.IsAtomic())
+                {
+                    switch (operation.StorageKind)
+                    {
+                        case StorageKind.ConstantBuffer:
+                        case StorageKind.StorageBuffer:
+                            if (operation.GetSource(0) is not AstOperand bindingIndex || bindingIndex.Type != OperandType.Constant)
+                            {
+                                throw new InvalidOperationException($"First input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
+                            }
+
+                            if (operation.GetSource(1) is not AstOperand fieldIndex || fieldIndex.Type != OperandType.Constant)
+                            {
+                                throw new InvalidOperationException($"Second input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
+                            }
+
+                            BufferDefinition buffer = operation.StorageKind == StorageKind.ConstantBuffer
+                                ? context.Config.Properties.ConstantBuffers[bindingIndex.Value]
+                                : context.Config.Properties.StorageBuffers[bindingIndex.Value];
+                            StructureField field = buffer.Type.Fields[fieldIndex.Value];
+
+                            return field.Type & AggregateType.ElementTypeMask;
+
+                        case StorageKind.LocalMemory:
+                        case StorageKind.SharedMemory:
+                            if (operation.GetSource(0) is not AstOperand { Type: OperandType.Constant } bindingId)
+                            {
+                                throw new InvalidOperationException($"First input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
+                            }
+
+                            MemoryDefinition memory = operation.StorageKind == StorageKind.LocalMemory
+                                ? context.Config.Properties.LocalMemories[bindingId.Value]
+                                : context.Config.Properties.SharedMemories[bindingId.Value];
+
+                            return memory.Type & AggregateType.ElementTypeMask;
+
+                        case StorageKind.Input:
+                        case StorageKind.InputPerPatch:
+                        case StorageKind.Output:
+                        case StorageKind.OutputPerPatch:
+                            if (operation.GetSource(0) is not AstOperand varId || varId.Type != OperandType.Constant)
+                            {
+                                throw new InvalidOperationException($"First input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
+                            }
+
+                            IoVariable ioVariable = (IoVariable)varId.Value;
+                            bool isOutput = operation.StorageKind == StorageKind.Output || operation.StorageKind == StorageKind.OutputPerPatch;
+                            bool isPerPatch = operation.StorageKind == StorageKind.InputPerPatch || operation.StorageKind == StorageKind.OutputPerPatch;
+                            int location = 0;
+                            int component = 0;
+
+                            if (context.Config.HasPerLocationInputOrOutput(ioVariable, isOutput))
+                            {
+                                if (operation.GetSource(1) is not AstOperand vecIndex || vecIndex.Type != OperandType.Constant)
+                                {
+                                    throw new InvalidOperationException($"Second input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
+                                }
+
+                                location = vecIndex.Value;
+
+                                if (operation.SourcesCount > 2 &&
+                                    operation.GetSource(2) is AstOperand elemIndex &&
+                                    elemIndex.Type == OperandType.Constant &&
+                                    context.Config.HasPerLocationInputOrOutputComponent(ioVariable, location, elemIndex.Value, isOutput))
+                                {
+                                    component = elemIndex.Value;
+                                }
+                            }
+
+                            (_, AggregateType varType) = IoMap.GetMSLBuiltIn(ioVariable);
+
+                            return varType & AggregateType.ElementTypeMask;
+                    }
+                }
+                else if (operation.Inst == Instruction.Call)
+                {
+                    AstOperand funcId = (AstOperand)operation.GetSource(0);
+
+                    Debug.Assert(funcId.Type == OperandType.Constant);
+
+                    return context.GetFunction(funcId.Value).ReturnType;
+                }
+                else if (operation.Inst == Instruction.VectorExtract)
+                {
+                    return GetNodeDestType(context, operation.GetSource(0)) & ~AggregateType.ElementCountMask;
+                }
+                else if (operation is AstTextureOperation texOp)
+                {
+                    if (texOp.Inst == Instruction.ImageLoad ||
+                        texOp.Inst == Instruction.ImageStore ||
+                        texOp.Inst == Instruction.ImageAtomic)
+                    {
+                        return texOp.GetVectorType(texOp.Format.GetComponentType());
+                    }
+                    else if (texOp.Inst == Instruction.TextureSample)
+                    {
+                        return texOp.GetVectorType(GetDestVarType(operation.Inst));
+                    }
+                }
+
+                return GetDestVarType(operation.Inst);
+            }
+            else if (node is AstOperand operand)
+            {
+                if (operand.Type == OperandType.Argument)
+                {
+                    int argIndex = operand.Value;
+
+                    return context.CurrentFunction.GetArgumentType(argIndex);
+                }
+
+                return OperandInfo.GetVarType(operand);
+            }
+            else
+            {
+                throw new ArgumentException($"Invalid node type \"{node?.GetType().Name ?? "null"}\".");
+            }
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/CodeGen/Msl/TypeConversion.cs

@@ -0,0 +1,95 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.Shader.CodeGen.Msl.Instructions;
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using Ryujinx.Graphics.Shader.StructuredIr;
+using Ryujinx.Graphics.Shader.Translation;
+
+namespace Ryujinx.Graphics.Shader.CodeGen.Msl
+{
+    static class TypeConversion
+    {
+public static string ReinterpretCast(
+            CodeGenContext context,
+            IAstNode node,
+            AggregateType srcType,
+            AggregateType dstType)
+        {
+            if (node is AstOperand operand && operand.Type == OperandType.Constant)
+            {
+                if (NumberFormatter.TryFormat(operand.Value, dstType, out string formatted))
+                {
+                    return formatted;
+                }
+            }
+
+            string expr = InstGen.GetExpression(context, node);
+
+            return ReinterpretCast(expr, node, srcType, dstType);
+        }
+
+        private static string ReinterpretCast(string expr, IAstNode node, AggregateType srcType, AggregateType dstType)
+        {
+            if (srcType == dstType)
+            {
+                return expr;
+            }
+
+            if (srcType == AggregateType.FP32)
+            {
+                switch (dstType)
+                {
+                    case AggregateType.Bool:
+                        return $"(floatBitsToInt({expr}) != 0)";
+                    case AggregateType.S32:
+                        return $"floatBitsToInt({expr})";
+                    case AggregateType.U32:
+                        return $"floatBitsToUint({expr})";
+                }
+            }
+            else if (dstType == AggregateType.FP32)
+            {
+                switch (srcType)
+                {
+                    case AggregateType.Bool:
+                        return $"intBitsToFloat({ReinterpretBoolToInt(expr, node, AggregateType.S32)})";
+                    case AggregateType.S32:
+                        return $"intBitsToFloat({expr})";
+                    case AggregateType.U32:
+                        return $"uintBitsToFloat({expr})";
+                }
+            }
+            else if (srcType == AggregateType.Bool)
+            {
+                return ReinterpretBoolToInt(expr, node, dstType);
+            }
+            else if (dstType == AggregateType.Bool)
+            {
+                expr = InstGenHelper.Enclose(expr, node, Instruction.CompareNotEqual, isLhs: true);
+
+                return $"({expr} != 0)";
+            }
+            else if (dstType == AggregateType.S32)
+            {
+                return $"int({expr})";
+            }
+            else if (dstType == AggregateType.U32)
+            {
+                return $"uint({expr})";
+            }
+
+            Logger.Warning?.Print(LogClass.Gpu, $"Invalid reinterpret cast from \"{srcType}\" to \"{dstType}\".");
+            // TODO: Make this an error again
+            return $"INVALID CAST ({expr})";
+        }
+
+        private static string ReinterpretBoolToInt(string expr, IAstNode node, AggregateType dstType)
+        {
+            string trueExpr = NumberFormatter.FormatInt(IrConsts.True, dstType);
+            string falseExpr = NumberFormatter.FormatInt(IrConsts.False, dstType);
+
+            expr = InstGenHelper.Enclose(expr, node, Instruction.ConditionalSelect, isLhs: false);
+
+            return $"({expr} ? {trueExpr} : {falseExpr})";
+        }
+    }
+}