Add SSE4.2 Path for CRC32, add A32 variant, add tests for non-castagnoli variants. (#1328)

* Add CRC32 A32 instructions.

* Fix CRC32 instructions.

* Add CRC intrinsic and fast path.

Loop is currently unrolled, will look into adding temp vars after tests are added.

* Begin work on Crc tests

* Fix SSE4.2 path for CRC32C, finialize tests.

* Remove unused IR path.

* Fix spacing between prefix checks.

* This should be Src.

* PTC Version

* OpCodeTable Order

* Integer check improvement. Value and Crc can be either 32 or 64 size.

* This wasn't necessary...

* If size is 3, value type must be I64.

* Fix same src+dest handling for non crc intrinsics.

* Pre-fix (ha) issue with vex encodings

3 files changed, 190 insertions, 22 deletions

diff --git a/Ryujinx.Tests/Cpu/CpuTest.cs b/Ryujinx.Tests/Cpu/CpuTest.cs
index 9e37c211..2c047248 100644
--- a/Ryujinx.Tests/Cpu/CpuTest.cs
+++ b/Ryujinx.Tests/Cpu/CpuTest.cs
@@ -167,41 +167,42 @@ namespace Ryujinx.Tests.Cpu
             }
         }
 
-        protected void ExecuteOpcodes()
+        protected void ExecuteOpcodes(bool runUnicorn = true)
         {
             _cpuContext.Execute(_context, _entryPoint);
 
-            if (_unicornAvailable)
+            if (_unicornAvailable && runUnicorn)
             {
                 _unicornEmu.RunForCount((_currAddress - _entryPoint - 4) / 4);
             }
         }
 
         protected ExecutionContext SingleOpcode(uint  opcode,
-                                                ulong x0       = 0,
-                                                ulong x1       = 0,
-                                                ulong x2       = 0,
-                                                ulong x3       = 0,
-                                                ulong x31      = 0,
-                                                V128  v0       = default,
-                                                V128  v1       = default,
-                                                V128  v2       = default,
-                                                V128  v3       = default,
-                                                V128  v4       = default,
-                                                V128  v5       = default,
-                                                V128  v30      = default,
-                                                V128  v31      = default,
-                                                bool  overflow = false,
-                                                bool  carry    = false,
-                                                bool  zero     = false,
-                                                bool  negative = false,
-                                                int   fpcr     = 0,
-                                                int   fpsr     = 0)
+                                                ulong x0         = 0,
+                                                ulong x1         = 0,
+                                                ulong x2         = 0,
+                                                ulong x3         = 0,
+                                                ulong x31        = 0,
+                                                V128  v0         = default,
+                                                V128  v1         = default,
+                                                V128  v2         = default,
+                                                V128  v3         = default,
+                                                V128  v4         = default,
+                                                V128  v5         = default,
+                                                V128  v30        = default,
+                                                V128  v31        = default,
+                                                bool  overflow   = false,
+                                                bool  carry      = false,
+                                                bool  zero       = false,
+                                                bool  negative   = false,
+                                                int   fpcr       = 0,
+                                                int   fpsr       = 0,
+                                                bool  runUnicorn = true)
         {
             Opcode(opcode);
             Opcode(0xD65F03C0); // RET
             SetContext(x0, x1, x2, x3, x31, v0, v1, v2, v3, v4, v5, v30, v31, overflow, carry, zero, negative, fpcr, fpsr);
-            ExecuteOpcodes();
+            ExecuteOpcodes(runUnicorn);
 
             return GetContext();
         }
diff --git a/Ryujinx.Tests/Cpu/CpuTestAluBinary.cs b/Ryujinx.Tests/Cpu/CpuTestAluBinary.cs
index 2823477f..eb94b845 100644
--- a/Ryujinx.Tests/Cpu/CpuTestAluBinary.cs
+++ b/Ryujinx.Tests/Cpu/CpuTestAluBinary.cs
@@ -1,5 +1,6 @@
 #define AluBinary
 
+using ARMeilleure.State;
 using NUnit.Framework;
 
 namespace Ryujinx.Tests.Cpu
@@ -8,8 +9,78 @@ namespace Ryujinx.Tests.Cpu
     public sealed class CpuTestAluBinary : CpuTest
     {
 #if AluBinary
+        public struct CrcTest
+        {
+            public uint Crc;
+            public ulong Value;
+            public bool C;
+
+            public uint[] Results; // One result for each CRC variant (8, 16, 32)
+
+            public CrcTest(uint crc, ulong value, bool c, params uint[] results)
+            {
+                Crc = crc;
+                Value = value;
+                C = c;
+                Results = results;
+            }
+        }
+
+#region "ValueSource (CRC32)"
+        private static CrcTest[] _CRC32_Test_Values_()
+        {
+            // Created with http://www.sunshine2k.de/coding/javascript/crc/crc_js.html, with:
+            //  - non-reflected polynomials
+            //  - input reflected, result reflected
+            //  - bytes in order of increasing significance
+            //  - xor 0
+            // Only includes non-C variant, as the other can be tested with unicorn.
+
+            return new CrcTest[]
+            {
+                new CrcTest(0x00000000u, 0x00_00_00_00_00_00_00_00u, false, 0x00000000, 0x00000000, 0x00000000, 0x00000000),
+                new CrcTest(0x00000000u, 0x7f_ff_ff_ff_ff_ff_ff_ffu, false, 0x2d02ef8d, 0xbe2612ff, 0xdebb20e3, 0xa9de8355),
+                new CrcTest(0x00000000u, 0x80_00_00_00_00_00_00_00u, false, 0x00000000, 0x00000000, 0x00000000, 0xedb88320),
+                new CrcTest(0x00000000u, 0xff_ff_ff_ff_ff_ff_ff_ffu, false, 0x2d02ef8d, 0xbe2612ff, 0xdebb20e3, 0x44660075),
+                new CrcTest(0x00000000u, 0xa0_02_f1_ca_52_78_8c_1cu, false, 0x14015c4f, 0x02799256, 0x9063c9e5, 0x8816610a),
+
+                new CrcTest(0xffffffffu, 0x00_00_00_00_00_00_00_00u, false, 0x2dfd1072, 0xbe26ed00, 0xdebb20e3, 0x9add2096),
+                new CrcTest(0xffffffffu, 0x7f_ff_ff_ff_ff_ff_ff_ffu, false, 0x00ffffff, 0x0000ffff, 0x00000000, 0x3303a3c3),
+                new CrcTest(0xffffffffu, 0x80_00_00_00_00_00_00_00u, false, 0x2dfd1072, 0xbe26ed00, 0xdebb20e3, 0x7765a3b6),
+                new CrcTest(0xffffffffu, 0xff_ff_ff_ff_ff_ff_ff_ffu, false, 0x00ffffff, 0x0000ffff, 0x00000000, 0xdebb20e3),
+                new CrcTest(0xffffffffu, 0xa0_02_f1_ca_52_78_8c_1cu, false, 0x39fc4c3d, 0xbc5f7f56, 0x4ed8e906, 0x12cb419c)
+            };
+        }
+#endregion
+
         private const int RndCnt = 2;
 
+        [Test, Combinatorial]
+        public void Crc32_b_h_w_x([Values(0u)] uint rd,
+                                  [Values(1u)] uint rn,
+                                  [Values(2u)] uint rm,
+                                  [Range(0u, 3u)] uint size,
+                                  [ValueSource("_CRC32_Test_Values_")] CrcTest test)
+        {
+            uint opcode = 0x1AC04000; // CRC32B W0, W0, W0
+
+            opcode |= size << 10;
+            opcode |= ((rm & 31) << 16) | ((rn & 31) << 5) | ((rd & 31) << 0);
+
+            if (size == 3)
+            {
+                opcode |= 0x80000000;
+            }
+
+            uint w31 = TestContext.CurrentContext.Random.NextUInt();
+
+            SingleOpcode(opcode, x1: test.Crc, x2: test.Value, x31: w31, runUnicorn: false);
+
+            ExecutionContext context = GetContext();
+            ulong result = context.GetX((int)rd);
+            Assert.That(result == test.Results[size]);
+        }
+
         [Test, Pairwise, Description("CRC32X <Wd>, <Wn>, <Xm>"), Ignore("Unicorn fails.")]
         public void Crc32x([Values(0u, 31u)] uint rd,
                            [Values(1u, 31u)] uint rn,
diff --git a/Ryujinx.Tests/Cpu/CpuTestAluBinary32.cs b/Ryujinx.Tests/Cpu/CpuTestAluBinary32.cs
new file mode 100644
index 00000000..0a0302c2
--- /dev/null
+++ b/Ryujinx.Tests/Cpu/CpuTestAluBinary32.cs
@@ -0,0 +1,96 @@
+#define AluBinary32
+
+using ARMeilleure.State;
+using NUnit.Framework;
+using System;
+
+namespace Ryujinx.Tests.Cpu
+{
+
+    [Category("AluBinary32")]
+    public sealed class CpuTestAluBinary32 : CpuTest32
+    {
+#if AluBinary32
+        public struct CrcTest32
+        {
+            public uint Crc;
+            public uint Value;
+            public bool C;
+
+            public uint[] Results; // One result for each CRC variant (8, 16, 32)
+
+            public CrcTest32(uint crc, uint value, bool c, params uint[] results)
+            {
+                Crc = crc;
+                Value = value;
+                C = c;
+                Results = results;
+            }
+        }
+
+#region "ValueSource (CRC32/CRC32C)"
+        private static CrcTest32[] _CRC32_Test_Values_()
+        {
+            // Created with http://www.sunshine2k.de/coding/javascript/crc/crc_js.html, with:
+            //  - non-reflected polynomials
+            //  - input reflected, result reflected
+            //  - bytes in order of increasing significance
+            //  - xor 0
+
+            return new CrcTest32[]
+            {
+                new CrcTest32(0x00000000u, 0x00_00_00_00u, false, 0x00000000, 0x00000000, 0x00000000),
+                new CrcTest32(0x00000000u, 0x7f_ff_ff_ffu, false, 0x2d02ef8d, 0xbe2612ff, 0x3303a3c3),
+                new CrcTest32(0x00000000u, 0x80_00_00_00u, false, 0x00000000, 0x00000000, 0xedb88320),
+                new CrcTest32(0x00000000u, 0xff_ff_ff_ffu, false, 0x2d02ef8d, 0xbe2612ff, 0xdebb20e3),
+                new CrcTest32(0x00000000u, 0x9d_cb_12_f0u, false, 0xbdbdf21c, 0xe70590f5, 0x3f7480c5),
+
+                new CrcTest32(0xffffffffu, 0x00_00_00_00u, false, 0x2dfd1072, 0xbe26ed00, 0xdebb20e3),
+                new CrcTest32(0xffffffffu, 0x7f_ff_ff_ffu, false, 0x00ffffff, 0x0000ffff, 0xedb88320),
+                new CrcTest32(0xffffffffu, 0x80_00_00_00u, false, 0x2dfd1072, 0xbe26ed00, 0x3303a3c3),
+                new CrcTest32(0xffffffffu, 0xff_ff_ff_ffu, false, 0x00ffffff, 0x0000ffff, 0x00000000),
+                new CrcTest32(0xffffffffu, 0x9d_cb_12_f0u, false, 0x9040e26e, 0x59237df5, 0xe1cfa026),
+
+                new CrcTest32(0x00000000u, 0x00_00_00_00u, true, 0x00000000, 0x00000000, 0x00000000),
+                new CrcTest32(0x00000000u, 0x7f_ff_ff_ffu, true, 0xad7d5351, 0x0e9e77d2, 0x356e8f40),
+                new CrcTest32(0x00000000u, 0x80_00_00_00u, true, 0x00000000, 0x00000000, 0x82f63b78),
+                new CrcTest32(0x00000000u, 0xff_ff_ff_ffu, true, 0xad7d5351, 0x0e9e77d2, 0xb798b438),
+                new CrcTest32(0x00000000u, 0x9d_cb_12_f0u, true, 0xf36e6f75, 0xb5ff99e6, 0x782dfbf1),
+
+                new CrcTest32(0xffffffffu, 0x00_00_00_00u, true, 0xad82acae, 0x0e9e882d, 0xb798b438),
+                new CrcTest32(0xffffffffu, 0x7f_ff_ff_ffu, true, 0x00ffffff, 0x0000ffff, 0x82f63b78),
+                new CrcTest32(0xffffffffu, 0x80_00_00_00u, true, 0xad82acae, 0x0e9e882d, 0x356e8f40),
+                new CrcTest32(0xffffffffu, 0xff_ff_ff_ffu, true, 0x00ffffff, 0x0000ffff, 0x00000000),
+                new CrcTest32(0xffffffffu, 0x9d_cb_12_f0u, true, 0x5eecc3db, 0xbb6111cb, 0xcfb54fc9)
+            };
+        }
+#endregion
+
+        [Test, Combinatorial]
+        public void Crc32_Crc32c_b_h_w([Values(0u)] uint rd,
+                                       [Values(1u)] uint rn,
+                                       [Values(2u)] uint rm,
+                                       [Range(0u, 2u)] uint size,
+                                       [ValueSource("_CRC32_Test_Values_")] CrcTest32 test)
+        {
+            // Unicorn does not yet support 32bit crc instructions, so test against a known table of results/values.
+
+            uint opcode = 0xe1000040; // CRC32B R0, R0, R0
+            opcode |= ((rm & 15) << 0) | ((rd & 15) << 12) | ((rn & 15) << 16);
+            opcode |= size << 21;
+            if (test.C)
+            {
+                opcode |= 1 << 9;
+            }
+
+            uint sp = TestContext.CurrentContext.Random.NextUInt();
+
+            SingleOpcode(opcode, r1: test.Crc, r2: test.Value, sp: sp, runUnicorn: false);
+
+            ExecutionContext context = GetContext();
+            ulong result = context.GetX((int)rd);
+            Assert.That(result == test.Results[size]);
+        }
+#endif
+    }
+}