Fix tail merge from block with conditional jump to multiple returns (#3267)

* Fix tail merge from block with conditional jump to multiple returns

* PPTC version bump

ARMeilleure/CodeGen/Optimizations/TailMerge.cs

@@ -59,7 +59,7 @@ namespace ARMeilleure.CodeGen.Optimizations
             BasicBlock fromPred = from.Predecessors.Count == 1 ? from.Predecessors[0] : null;
 
             // If the block is empty, we can try to append to the predecessor and avoid unnecessary jumps.
-            if (from.Operations.Count == 0 && fromPred != null)
+            if (from.Operations.Count == 0 && fromPred != null && fromPred.SuccessorsCount == 1)
             {
                 for (int i = 0; i < fromPred.SuccessorsCount; i++)
                 {

ARMeilleure/Signal/NativeSignalHandler.cs

@@ -191,7 +191,7 @@ namespace ARMeilleure.Signal
                 // Is the fault address within this tracked region?
                 Operand inRange = context.BitwiseAnd(
                     context.ICompare(faultAddress, rangeAddress, Comparison.GreaterOrEqualUI),
-                    context.ICompare(faultAddress, rangeEndAddress, Comparison.Less)
+                    context.ICompare(faultAddress, rangeEndAddress, Comparison.LessUI)
                     );
 
                 // Only call tracking if in range.

ARMeilleure/Translation/PTC/Ptc.cs

@@ -27,7 +27,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 3193; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 3267; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";

Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -1136,17 +1136,33 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="range">Texture view physical memory ranges</param>
         /// <param name="layerSize">Layer size on the given texture</param>
         /// <param name="caps">Host GPU capabilities</param>
+        /// <param name="allowMs">Indicates that multisample textures are allowed to match non-multisample requested textures</param>
         /// <param name="firstLayer">Texture view initial layer on this texture</param>
         /// <param name="firstLevel">Texture view first mipmap level on this texture</param>
         /// <returns>The level of compatiblilty a view with the given parameters created from this texture has</returns>
-        public TextureViewCompatibility IsViewCompatible(TextureInfo info, MultiRange range, int layerSize, Capabilities caps, out int firstLayer, out int firstLevel)
+        public TextureViewCompatibility IsViewCompatible(TextureInfo info, MultiRange range, int layerSize, Capabilities caps, bool allowMs, out int firstLayer, out int firstLevel)
         {
             TextureViewCompatibility result = TextureViewCompatibility.Full;
 
             result = TextureCompatibility.PropagateViewCompatibility(result, TextureCompatibility.ViewFormatCompatible(Info, info, caps));
             if (result != TextureViewCompatibility.Incompatible)
             {
-                result = TextureCompatibility.PropagateViewCompatibility(result, TextureCompatibility.ViewTargetCompatible(Info, info));
+                bool msTargetCompatible = false;
+
+                if (allowMs)
+                {
+                    msTargetCompatible = Info.Target == Target.Texture2DMultisample && info.Target == Target.Texture2D;
+                }
+
+                if (!msTargetCompatible)
+                {
+                    result = TextureCompatibility.PropagateViewCompatibility(result, TextureCompatibility.ViewTargetCompatible(Info, info));
+
+                    if (Info.SamplesInX != info.SamplesInX || Info.SamplesInY != info.SamplesInY)
+                    {
+                        result = TextureViewCompatibility.Incompatible;
+                    }
+                }
 
                 if (result == TextureViewCompatibility.Full && Info.FormatInfo.Format != info.FormatInfo.Format && !_context.Capabilities.SupportsMismatchingViewFormat)
                 {
@@ -1156,11 +1172,6 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                     result = TextureViewCompatibility.CopyOnly;
                 }
-
-                if (Info.SamplesInX != info.SamplesInX || Info.SamplesInY != info.SamplesInY)
-                {
-                    result = TextureViewCompatibility.Incompatible;
-                }
             }
 
             firstLayer = 0;

Ryujinx.Graphics.Gpu/Image/TextureCache.cs

@@ -542,7 +542,14 @@ namespace Ryujinx.Graphics.Gpu.Image
             for (int index = 0; index < overlapsCount; index++)
             {
                 Texture overlap = _textureOverlaps[index];
-                TextureViewCompatibility overlapCompatibility = overlap.IsViewCompatible(info, range.Value, sizeInfo.LayerSize, _context.Capabilities, out int firstLayer, out int firstLevel);
+                TextureViewCompatibility overlapCompatibility = overlap.IsViewCompatible(
+                    info,
+                    range.Value,
+                    sizeInfo.LayerSize,
+                    _context.Capabilities,
+                    flags.HasFlag(TextureSearchFlags.ForCopy),
+                    out int firstLayer,
+                    out int firstLevel);
 
                 if (overlapCompatibility == TextureViewCompatibility.Full)
                 {
@@ -650,7 +657,14 @@ namespace Ryujinx.Graphics.Gpu.Image
                     Texture overlap = _textureOverlaps[index];
                     bool overlapInCache = overlap.CacheNode != null;
 
-                    TextureViewCompatibility compatibility = texture.IsViewCompatible(overlap.Info, overlap.Range, overlap.LayerSize, _context.Capabilities, out int firstLayer, out int firstLevel);
+                    TextureViewCompatibility compatibility = texture.IsViewCompatible(
+                        overlap.Info,
+                        overlap.Range,
+                        overlap.LayerSize,
+                        _context.Capabilities,
+                        false,
+                        out int firstLayer,
+                        out int firstLevel);
 
                     if (overlap.IsView && compatibility == TextureViewCompatibility.Full)
                     {
@@ -1000,20 +1014,34 @@ namespace Ryujinx.Graphics.Gpu.Image
                 depthOrLayers = info.DepthOrLayers;
             }
 
+            // 2D and 2D multisample textures are not considered compatible.
+            // This specific case is required for copies, where the source texture might be multisample.
+            // In this case, we inherit the parent texture multisample state.
+            Target target = info.Target;
+            int samplesInX = info.SamplesInX;
+            int samplesInY = info.SamplesInY;
+
+            if (target == Target.Texture2D && parent.Target == Target.Texture2DMultisample)
+            {
+                target = Target.Texture2DMultisample;
+                samplesInX = parent.Info.SamplesInX;
+                samplesInY = parent.Info.SamplesInY;
+            }
+
             return new TextureInfo(
                 info.GpuAddress,
                 width,
                 height,
                 depthOrLayers,
                 info.Levels,
-                info.SamplesInX,
+                samplesInX,
-                info.SamplesInY,
+                samplesInY,
                 info.Stride,
                 info.IsLinear,
                 info.GobBlocksInY,
                 info.GobBlocksInZ,
                 info.GobBlocksInTileX,
-                info.Target,
+                target,
                 info.FormatInfo,
                 info.DepthStencilMode,
                 info.SwizzleR,

Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs

@@ -40,7 +40,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <summary>
         /// Version of the codegen (to be changed when codegen or guest format change).
         /// </summary>
-        private const ulong ShaderCodeGenVersion = 3054;
+        private const ulong ShaderCodeGenVersion = 3251;
 
         // Progress reporting helpers
         private volatile int _shaderCount;

Ryujinx.Graphics.Shader/CodeGen/Glsl/OperandManager.cs

@@ -250,9 +250,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
                             : "gl_SubgroupInvocationID";
                     }
 
-                    // TODO: There must be a better way to handle this...
                     if (config.Stage == ShaderStage.Fragment)
                     {
+                        // TODO: There must be a better way to handle this...
                         switch (value)
                         {
                             case AttributeConsts.PositionX: return $"(gl_FragCoord.x / {DefaultNames.SupportBlockRenderScaleName}[0])";

Ryujinx.Graphics.Shader/Decoders/InstDecoders.cs

@@ -5144,6 +5144,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
         public int SrcC => (int)((_opcode >> 39) & 0xFF);
         public int Pred => (int)((_opcode >> 16) & 0x7);
         public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
         public bool WriteCC => (_opcode & 0x800000000000) != 0;
         public AvgMode AvgMode => (AvgMode)((_opcode >> 56) & 0x3);
         public bool DFormat => (_opcode & 0x40000000000000) != 0;
@@ -5164,6 +5165,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
         public int SrcC => (int)((_opcode >> 39) & 0xFF);
         public int Pred => (int)((_opcode >> 16) & 0x7);
         public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
         public bool WriteCC => (_opcode & 0x800000000000) != 0;
         public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
         public VectorSelect BSelect => (VectorSelect)((int)((_opcode >> 46) & 0x8) | (int)((_opcode >> 28) & 0x7));

Ryujinx.Graphics.Shader/InputTopology.cs

@@ -13,16 +13,28 @@ namespace Ryujinx.Graphics.Shader
     {
         public static string ToGlslString(this InputTopology topology)
         {
-            switch (topology)
+            return topology switch
             {
-                case InputTopology.Points:             return "points";
+                InputTopology.Points => "points",
-                case InputTopology.Lines:              return "lines";
+                InputTopology.Lines => "lines",
-                case InputTopology.LinesAdjacency:     return "lines_adjacency";
+                InputTopology.LinesAdjacency => "lines_adjacency",
-                case InputTopology.Triangles:          return "triangles";
+                InputTopology.Triangles => "triangles",
-                case InputTopology.TrianglesAdjacency: return "triangles_adjacency";
+                InputTopology.TrianglesAdjacency => "triangles_adjacency",
-            }
+                _ => "points"
+            };
+        }
 
-            return "points";
+        public static int ToInputVertices(this InputTopology topology)
+        {
+            return topology switch
+            {
+                InputTopology.Points => 1,
+                InputTopology.Lines or
+                InputTopology.LinesAdjacency => 2,
+                InputTopology.Triangles or
+                InputTopology.TrianglesAdjacency => 3,
+                _ => 1
+            };
         }
     }
 }

Ryujinx.Graphics.Shader/Instructions/InstEmitAluHelper.cs

@@ -73,6 +73,26 @@ namespace Ryujinx.Graphics.Shader.Instructions
             };
         }
 
+        public static Operand Extend(EmitterContext context, Operand src, VectorSelect type)
+        {
+            return type switch
+            {
+                VectorSelect.U8B0 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(0)), 8),
+                VectorSelect.U8B1 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(8)), 8),
+                VectorSelect.U8B2 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(16)), 8),
+                VectorSelect.U8B3 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(24)), 8),
+                VectorSelect.U16H0 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(0)), 16),
+                VectorSelect.U16H1 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(16)), 16),
+                VectorSelect.S8B0 => SignExtendTo32(context, context.ShiftRightU32(src, Const(0)), 8),
+                VectorSelect.S8B1 => SignExtendTo32(context, context.ShiftRightU32(src, Const(8)), 8),
+                VectorSelect.S8B2 => SignExtendTo32(context, context.ShiftRightU32(src, Const(16)), 8),
+                VectorSelect.S8B3 => SignExtendTo32(context, context.ShiftRightU32(src, Const(24)), 8),
+                VectorSelect.S16H0 => SignExtendTo32(context, context.ShiftRightU32(src, Const(0)), 16),
+                VectorSelect.S16H1 => SignExtendTo32(context, context.ShiftRightU32(src, Const(16)), 16),
+                _ => src
+            };
+        }
+
         public static void SetZnFlags(EmitterContext context, Operand dest, bool setCC, bool extended = false)
         {
             if (!setCC)
@@ -118,6 +138,15 @@ namespace Ryujinx.Graphics.Shader.Instructions
             }
         }
 
+        public static (Operand, Operand) NegateLong(EmitterContext context, Operand low, Operand high)
+        {
+            low = context.BitwiseNot(low);
+            high = context.BitwiseNot(high);
+            low = AddWithCarry(context, low, Const(1), out Operand carryOut);
+            high = context.IAdd(high, carryOut);
+            return (low, high);
+        }
+
         public static Operand AddWithCarry(EmitterContext context, Operand lhs, Operand rhs, out Operand carryOut)
         {
             Operand result = context.IAdd(lhs, rhs);

Ryujinx.Graphics.Shader/Instructions/InstEmitAttribute.cs

@@ -168,10 +168,11 @@ namespace Ryujinx.Graphics.Shader.Instructions
         {
             InstIsberd op = context.GetOp<InstIsberd>();
 
-            // This instruction performs a load from ISBE memory,
+            // This instruction performs a load from ISBE (Internal Stage Buffer Entry) memory.
-            // however it seems to be only used to get some vertex
+            // Here, we just propagate the offset, as the result from this instruction is usually
-            // input data, so we instead propagate the offset so that
+            // used with ALD to perform vertex load on geometry or tessellation shaders.
-            // it can be used on the attribute load.
+            // The offset is calculated as (PrimitiveIndex * VerticesPerPrimitive) + VertexIndex.
+            // Since we hardcode PrimitiveIndex to zero, then the offset will be just VertexIndex.
             context.Copy(GetDest(op.Dest), GetSrcReg(context, op.SrcA));
         }
 

Ryujinx.Graphics.Shader/Instructions/InstEmitMove.cs

@@ -94,31 +94,19 @@ namespace Ryujinx.Graphics.Shader.Instructions
                 case SReg.InvocationInfo:
                     if (context.Config.Stage != ShaderStage.Compute && context.Config.Stage != ShaderStage.Fragment)
                     {
-                        Operand primitiveId = Attribute(AttributeConsts.PrimitiveId);
+                        // Note: Lowest 8-bits seems to contain some primitive index,
-                        Operand patchVerticesIn;
+                        // but it seems to be NVIDIA implementation specific as it's only used
+                        // to calculate ISBE offsets, so we can just keep it as zero.
 
-                        if (context.Config.Stage == ShaderStage.TessellationEvaluation)
+                        if (context.Config.Stage == ShaderStage.TessellationControl ||
+                            context.Config.Stage == ShaderStage.TessellationEvaluation)
                         {
-                            patchVerticesIn = context.ShiftLeft(Attribute(AttributeConsts.PatchVerticesIn), Const(16));
+                            src = context.ShiftLeft(Attribute(AttributeConsts.PatchVerticesIn), Const(16));
                         }
                         else
                         {
-                            InputTopology inputTopology = context.Config.GpuAccessor.QueryPrimitiveTopology();
+                            src = Const(context.Config.GpuAccessor.QueryPrimitiveTopology().ToInputVertices() << 16);
-
-                            int inputVertices = inputTopology switch
-                            {
-                                InputTopology.Points => 1,
-                                InputTopology.Lines or
-                                InputTopology.LinesAdjacency => 2,
-                                InputTopology.Triangles or
-                                InputTopology.TrianglesAdjacency => 3,
-                                _ => 1
-                            };
-
-                            patchVerticesIn = Const(inputVertices << 16);
                         }
-
-                        src = context.BitwiseOr(primitiveId, patchVerticesIn);
                     }
                     else
                     {

Ryujinx.Graphics.Shader/Instructions/InstEmitVideoArithmetic.cs

@@ -1,7 +1,9 @@
 using Ryujinx.Graphics.Shader.Decoders;
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
 using Ryujinx.Graphics.Shader.Translation;
 
 using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
+using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
 
 namespace Ryujinx.Graphics.Shader.Instructions
 {
@@ -11,8 +13,106 @@ namespace Ryujinx.Graphics.Shader.Instructions
         {
             InstVmad op = context.GetOp<InstVmad>();
 
-            // TODO: Implement properly.
+            bool aSigned = (op.ASelect & VectorSelect.S8B0) != 0;
-            context.Copy(GetDest(op.Dest), GetSrcReg(context, op.SrcC));
+            bool bSigned = (op.BSelect & VectorSelect.S8B0) != 0;
+
+            Operand srcA = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
+            Operand srcC = context.INegate(GetSrcReg(context, op.SrcC), op.AvgMode == AvgMode.NegB);
+            Operand srcB;
+
+            if (op.BVideo)
+            {
+                srcB = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
+            }
+            else
+            {
+                int imm = op.Imm16;
+
+                if (bSigned)
+                {
+                    imm = (imm << 16) >> 16;
+                }
+
+                srcB = Const(imm);
+            }
+
+            Operand productLow = context.IMultiply(srcA, srcB);
+            Operand productHigh;
+
+            if (aSigned == bSigned)
+            {
+                productHigh = aSigned
+                    ? context.MultiplyHighS32(srcA, srcB)
+                    : context.MultiplyHighU32(srcA, srcB);
+            }
+            else
+            {
+                Operand temp = aSigned
+                    ? context.IMultiply(srcB, context.ShiftRightS32(srcA, Const(31)))
+                    : context.IMultiply(srcA, context.ShiftRightS32(srcB, Const(31)));
+
+                productHigh = context.IAdd(temp, context.MultiplyHighU32(srcA, srcB));
+            }
+
+            if (op.AvgMode == AvgMode.NegA)
+            {
+                (productLow, productHigh) = InstEmitAluHelper.NegateLong(context, productLow, productHigh);
+            }
+
+            Operand resLow = InstEmitAluHelper.AddWithCarry(context, productLow, srcC, out Operand sumCarry);
+            Operand resHigh = context.IAdd(productHigh, sumCarry);
+
+            if (op.AvgMode == AvgMode.PlusOne)
+            {
+                resLow = InstEmitAluHelper.AddWithCarry(context, resLow, Const(1), out Operand poCarry);
+                resHigh = context.IAdd(resHigh, poCarry);
+            }
+
+            bool resSigned = op.ASelect == VectorSelect.S32 ||
+                             op.BSelect == VectorSelect.S32 ||
+                             op.AvgMode == AvgMode.NegB ||
+                             op.AvgMode == AvgMode.NegA;
+
+            int shift = op.VideoScale switch
+            {
+                VideoScale.Shr7 => 7,
+                VideoScale.Shr15 => 15,
+                _ => 0
+            };
+
+            if (shift != 0)
+            {
+                // Low = (Low >> Shift) | (High << (32 - Shift))
+                // High >>= Shift
+                resLow = context.ShiftRightU32(resLow, Const(shift));
+                resLow = context.BitwiseOr(resLow, context.ShiftLeft(resHigh, Const(32 - shift)));
+                resHigh = resSigned
+                    ? context.ShiftRightS32(resHigh, Const(shift))
+                    : context.ShiftRightU32(resHigh, Const(shift));
+            }
+
+            Operand res = resLow;
+
+            if (op.Sat)
+            {
+                Operand sign = context.ShiftRightS32(resHigh, Const(31));
+
+                if (resSigned)
+                {
+                    Operand overflow = context.ICompareNotEqual(resHigh, context.ShiftRightS32(resLow, Const(31)));
+                    Operand clampValue = context.ConditionalSelect(sign, Const(int.MinValue), Const(int.MaxValue));
+                    res = context.ConditionalSelect(overflow, clampValue, resLow);
+                }
+                else
+                {
+                    Operand overflow = context.ICompareNotEqual(resHigh, Const(0));
+                    res = context.ConditionalSelect(overflow, context.BitwiseNot(sign), resLow);
+                }
+            }
+
+            context.Copy(GetDest(op.Dest), res);
+
+            // TODO: CC.
         }
     }
 }

Ryujinx.Graphics.Shader/Instructions/InstEmitVideoMinMax.cs

@@ -13,14 +13,13 @@ namespace Ryujinx.Graphics.Shader.Instructions
         {
             InstVmnmx op = context.GetOp<InstVmnmx>();
 
-            Operand srcA = Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
+            Operand srcA = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
             Operand srcC = GetSrcReg(context, op.SrcC);
-
             Operand srcB;
 
             if (op.BVideo)
             {
-                srcB = Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
+                srcB = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
             }
             else
             {
@@ -124,13 +123,12 @@ namespace Ryujinx.Graphics.Shader.Instructions
         {
             InstVsetp op = context.GetOp<InstVsetp>();
 
-            Operand srcA = Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
+            Operand srcA = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
-
             Operand srcB;
 
             if (op.BVideo)
             {
-                srcB = Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
+                srcB = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
             }
             else
             {
@@ -181,25 +179,5 @@ namespace Ryujinx.Graphics.Shader.Instructions
             context.Copy(Register(op.DestPred, RegisterType.Predicate), p0Res);
             context.Copy(Register(op.DestPredInv, RegisterType.Predicate), p1Res);
         }
-
-        private static Operand Extend(EmitterContext context, Operand src, VectorSelect type)
-        {
-            return type switch
-            {
-                VectorSelect.U8B0 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(0)), 8),
-                VectorSelect.U8B1 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(8)), 8),
-                VectorSelect.U8B2 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(16)), 8),
-                VectorSelect.U8B3 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(24)), 8),
-                VectorSelect.U16H0 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(0)), 16),
-                VectorSelect.U16H1 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(16)), 16),
-                VectorSelect.S8B0 => SignExtendTo32(context, context.ShiftRightU32(src, Const(0)), 8),
-                VectorSelect.S8B1 => SignExtendTo32(context, context.ShiftRightU32(src, Const(8)), 8),
-                VectorSelect.S8B2 => SignExtendTo32(context, context.ShiftRightU32(src, Const(16)), 8),
-                VectorSelect.S8B3 => SignExtendTo32(context, context.ShiftRightU32(src, Const(24)), 8),
-                VectorSelect.S16H0 => SignExtendTo32(context, context.ShiftRightU32(src, Const(0)), 16),
-                VectorSelect.S16H1 => SignExtendTo32(context, context.ShiftRightU32(src, Const(16)), 16),
-                _ => src
-            };
-        }
     }
 }

Ryujinx.Graphics.Shader/Instructions/Lop3Expression.cs

@@ -7,138 +7,135 @@ namespace Ryujinx.Graphics.Shader.Instructions
 {
     static class Lop3Expression
     {
-        public static Operand GetFromTruthTable(EmitterContext context, Operand srcA, Operand srcB, Operand srcC, int imm)
+        private enum TruthTable : byte
         {
-            Operand expr = null;
+            False         = 0x00, // false
-
+            True          = 0xff, // true
-            // Handle some simple cases, or cases where
+            In            = 0xf0, // a
-            // the KMap would yield poor results (like XORs).
+            And2          = 0xc0, // a & b
-            if (imm == 0x96 || imm == 0x69)
+            Or2           = 0xfc, // a | b
-            {
+            Xor2          = 0x3c, // a ^ b
-                // XOR (0x96) and XNOR (0x69).
+            And3          = 0x80, // a & b & c
-                if (imm == 0x69)
+            Or3           = 0xfe, // a | b | c
-                {
+            XorAnd        = 0x60, // a & (b ^ c)
-                    srcA = context.BitwiseNot(srcA);
+            XorOr         = 0xf6, // a | (b ^ c)
-                }
+            OrAnd         = 0xe0, // a & (b | c)
-
+            AndOr         = 0xf8, // a | (b & c)
-                expr = context.BitwiseExclusiveOr(srcA, srcB);
+            Onehot        = 0x16, // (a & !b & !c) | (!a & b & !c) | (!a & !b & c) - Only one value is true.
-                expr = context.BitwiseExclusiveOr(expr, srcC);
+            Majority      = 0xe8, // Popcount(a, b, c) >= 2
-
+            Gamble        = 0x81, // (a & b & c) | (!a & !b & !c) - All on or all off
-                return expr;
+            InverseGamble = 0x7e, // Inverse of Gamble
-            }
+            Dot           = 0x1a, // a ^ (c | (a & b))
-            else if (imm == 0)
+            Mux           = 0xca, // a ? b : c
-            {
+            AndXor        = 0x78, // a ^ (b & c)
-                // Always false.
+            OrXor         = 0x1e, // a ^ (b | c)
-                return Const(IrConsts.False);
+            Xor3          = 0x96, // a ^ b ^ c
-            }
-            else if (imm == 0xff)
-            {
-                // Always true.
-                return Const(IrConsts.True);
-            }
-
-            int map;
-
-            // Encode into gray code.
-            map = ((imm >> 0) & 1) << 0;
-            map |= ((imm >> 1) & 1) << 4;
-            map |= ((imm >> 2) & 1) << 1;
-            map |= ((imm >> 3) & 1) << 5;
-            map |= ((imm >> 4) & 1) << 3;
-            map |= ((imm >> 5) & 1) << 7;
-            map |= ((imm >> 6) & 1) << 2;
-            map |= ((imm >> 7) & 1) << 6;
-
-            // Solve KMap, get sum of products.
-            int visited = 0;
-
-            for (int index = 0; index < 8 && visited != 0xff; index++)
-            {
-                if ((map & (1 << index)) == 0)
-                {
-                    continue;
-                }
-
-                int mask = 0;
-
-                for (int mSize = 4; mSize != 0; mSize >>= 1)
-                {
-                    mask = RotateLeft4((1 << mSize) - 1, index & 3) << (index & 4);
-
-                    if ((map & mask) == mask)
-                    {
-                        break;
-                    }
-                }
-
-                // The mask should wrap, if we are on the high row, shift to low etc.
-                int mask2 = (index & 4) != 0 ? mask >> 4 : mask << 4;
-
-                if ((map & mask2) == mask2)
-                {
-                    mask |= mask2;
-                }
-
-                if ((mask & visited) == mask)
-                {
-                    continue;
-                }
-
-                bool notA = (mask & 0x33) != 0;
-                bool notB = (mask & 0x99) != 0;
-                bool notC = (mask & 0x0f) != 0;
-
-                bool aChanges = (mask & 0xcc) != 0 && notA;
-                bool bChanges = (mask & 0x66) != 0 && notB;
-                bool cChanges = (mask & 0xf0) != 0 && notC;
-
-                Operand localExpr = null;
-
-                void And(Operand source)
-                {
-                    if (localExpr != null)
-                    {
-                        localExpr = context.BitwiseAnd(localExpr, source);
-                    }
-                    else
-                    {
-                        localExpr = source;
-                    }
-                }
-
-                if (!aChanges)
-                {
-                    And(context.BitwiseNot(srcA, notA));
-                }
-
-                if (!bChanges)
-                {
-                    And(context.BitwiseNot(srcB, notB));
-                }
-
-                if (!cChanges)
-                {
-                    And(context.BitwiseNot(srcC, notC));
-                }
-
-                if (expr != null)
-                {
-                    expr = context.BitwiseOr(expr, localExpr);
-                }
-                else
-                {
-                    expr = localExpr;
-                }
-
-                visited |= mask;
-            }
-
-            return expr;
         }
 
-        private static int RotateLeft4(int value, int shift)
+        public static Operand GetFromTruthTable(EmitterContext context, Operand srcA, Operand srcB, Operand srcC, int imm)
         {
-            return ((value << shift) | (value >> (4 - shift))) & 0xf;
+            for (int i = 0; i < 0x40; i++)
+            {
+                TruthTable currImm = (TruthTable)imm;
+
+                Operand x = srcA;
+                Operand y = srcB;
+                Operand z = srcC;
+                
+                if ((i & 0x01) != 0)
+                {
+                    (x, y) = (y, x);
+                    currImm = PermuteTable(currImm, 7, 6, 3, 2, 5, 4, 1, 0);
+                }
+
+                if ((i & 0x02) != 0)
+                {
+                    (x, z) = (z, x);
+                    currImm = PermuteTable(currImm, 7, 3, 5, 1, 6, 2, 4, 0);
+                }
+
+                if ((i & 0x04) != 0)
+                {
+                    (y, z) = (z, y);
+                    currImm = PermuteTable(currImm, 7, 5, 6, 4, 3, 1, 2, 0);
+                }
+
+                if ((i & 0x08) != 0)
+                {
+                    x = context.BitwiseNot(x);
+                    currImm = PermuteTable(currImm, 3, 2, 1, 0, 7, 6, 5, 4);
+                }
+
+                if ((i & 0x10) != 0)
+                {
+                    y = context.BitwiseNot(y);
+                    currImm = PermuteTable(currImm, 5, 4, 7, 6, 1, 0, 3, 2);
+                }
+
+                if ((i & 0x20) != 0)
+                {
+                    z = context.BitwiseNot(z);
+                    currImm = PermuteTable(currImm, 6, 7, 4, 5, 2, 3, 0, 1);
+                }
+
+                Operand result = GetExpr(currImm, context, x, y, z);
+                if (result != null)
+                {
+                    return result;
+                }
+
+                Operand notResult = GetExpr((TruthTable)((~(int)currImm) & 0xff), context, x, y, z);
+                if (notResult != null)
+                {
+                    return context.BitwiseNot(notResult);
+                }
+            }
+
+            return null;
+        }
+
+        private static Operand GetExpr(TruthTable imm, EmitterContext context, Operand x, Operand y, Operand z)
+        {
+            return imm switch
+            {
+                TruthTable.False         => Const(0),
+                TruthTable.True          => Const(-1),
+                TruthTable.In            => x,
+                TruthTable.And2          => context.BitwiseAnd(x, y),
+                TruthTable.Or2           => context.BitwiseOr(x, y),
+                TruthTable.Xor2          => context.BitwiseExclusiveOr(x, y),
+                TruthTable.And3          => context.BitwiseAnd(x, context.BitwiseAnd(y, z)),
+                TruthTable.Or3           => context.BitwiseOr(x, context.BitwiseOr(y, z)),
+                TruthTable.XorAnd        => context.BitwiseAnd(x, context.BitwiseExclusiveOr(y, z)),
+                TruthTable.XorOr         => context.BitwiseOr(x, context.BitwiseExclusiveOr(y, z)),
+                TruthTable.OrAnd         => context.BitwiseAnd(x, context.BitwiseOr(y, z)),
+                TruthTable.AndOr         => context.BitwiseOr(x, context.BitwiseAnd(y, z)),
+                TruthTable.Onehot        => context.BitwiseExclusiveOr(context.BitwiseOr(x, y), context.BitwiseOr(z, context.BitwiseAnd(x, y))),
+                TruthTable.Majority      => context.BitwiseAnd(context.BitwiseOr(x, y), context.BitwiseOr(z, context.BitwiseAnd(x, y))),
+                TruthTable.InverseGamble => context.BitwiseOr(context.BitwiseExclusiveOr(x, y), context.BitwiseExclusiveOr(x, z)),
+                TruthTable.Dot           => context.BitwiseAnd(context.BitwiseExclusiveOr(x, z), context.BitwiseOr(context.BitwiseNot(y), z)),
+                TruthTable.Mux           => context.BitwiseOr(context.BitwiseAnd(x, y), context.BitwiseAnd(context.BitwiseNot(x), z)),
+                TruthTable.AndXor        => context.BitwiseExclusiveOr(x, context.BitwiseAnd(y, z)),
+                TruthTable.OrXor         => context.BitwiseExclusiveOr(x, context.BitwiseOr(y, z)),
+                TruthTable.Xor3          => context.BitwiseExclusiveOr(x, context.BitwiseExclusiveOr(y, z)),
+                _                        => null
+            };
+        }
+
+        private static TruthTable PermuteTable(TruthTable imm, int bit7, int bit6, int bit5, int bit4, int bit3, int bit2, int bit1, int bit0)
+        {
+            int result = 0;
+
+            result |= (((int)imm >> 0) & 1) << bit0;
+            result |= (((int)imm >> 1) & 1) << bit1;
+            result |= (((int)imm >> 2) & 1) << bit2;
+            result |= (((int)imm >> 3) & 1) << bit3;
+            result |= (((int)imm >> 4) & 1) << bit4;
+            result |= (((int)imm >> 5) & 1) << bit5;
+            result |= (((int)imm >> 6) & 1) << bit6;
+            result |= (((int)imm >> 7) & 1) << bit7;
+
+            return (TruthTable)result;
         }
     }
 }