Implement AESMC, AESIMC, AESE, AESD and VEOR AArch32 instructions (#982)

* Add VEOR and AES instructions.

* Add tests for crypto instructions.

* Update ValueSource name.

3 files changed, 172 insertions, 14 deletions

diff --git a/Ryujinx.Tests/Cpu/CpuTest32.cs b/Ryujinx.Tests/Cpu/CpuTest32.cs
index a039d280..07354442 100644
--- a/Ryujinx.Tests/Cpu/CpuTest32.cs
+++ b/Ryujinx.Tests/Cpu/CpuTest32.cs
@@ -164,11 +164,11 @@ namespace Ryujinx.Tests.Cpu
             }
         }
 
-        protected void ExecuteOpcodes()
+        protected void ExecuteOpcodes(bool runUnicorn = true)
         {
             _translator.Execute(_context, _entryPoint);
 
-            if (_unicornAvailable)
+            if (_unicornAvailable && runUnicorn)
             {
                 _unicornEmu.RunForCount((ulong)(_currAddress - _entryPoint - 4) / 4);
             }
@@ -193,7 +193,8 @@ namespace Ryujinx.Tests.Cpu
                                                 bool zero = false,
                                                 bool negative = false,
                                                 int fpscr = 0,
-                                                bool copyFpFlags = false)
+                                                bool copyFpFlags = false,
+                                                bool runUnicorn = true)
         {
             Opcode(opcode);
             if (copyFpFlags)
@@ -202,7 +203,7 @@ namespace Ryujinx.Tests.Cpu
             }
             Opcode(0xe12fff1e); // BX LR
             SetContext(r0, r1, r2, r3, sp, v0, v1, v2, v3, v4, v5, v14, v15, overflow, carry, zero, negative, fpscr);
-            ExecuteOpcodes();
+            ExecuteOpcodes(runUnicorn);
 
             return GetContext();
         }
diff --git a/Ryujinx.Tests/Cpu/CpuTestSimdCrypto32.cs b/Ryujinx.Tests/Cpu/CpuTestSimdCrypto32.cs
new file mode 100644
index 00000000..0bcb7a1f
--- /dev/null
+++ b/Ryujinx.Tests/Cpu/CpuTestSimdCrypto32.cs
@@ -0,0 +1,155 @@
+// https://www.intel.com/content/dam/doc/white-paper/advanced-encryption-standard-new-instructions-set-paper.pdf
+
+using ARMeilleure.State;
+
+using NUnit.Framework;
+
+namespace Ryujinx.Tests.Cpu
+{
+    public class CpuTestSimdCrypto32 : CpuTest32
+    {
+        [Test, Description("AESD.8 <Qd>, <Qm>")]
+        public void Aesd_V([Values(0u)] uint rd,
+                           [Values(2u)] uint rm,
+                           [Values(0x7B5B546573745665ul)] ulong valueH,
+                           [Values(0x63746F725D53475Dul)] ulong valueL,
+                           [Random(2)]                    ulong roundKeyH,
+                           [Random(2)]                    ulong roundKeyL,
+                           [Values(0x8DCAB9BC035006BCul)] ulong resultH,
+                           [Values(0x8F57161E00CAFD8Dul)] ulong resultL)
+        {
+            uint opcode = 0xf3b00340; // AESD.8 Q0, Q0
+            opcode |= ((rm & 0xf) << 0) | ((rm & 0x10) << 1);
+            opcode |= ((rd & 0xf) << 12) | ((rd & 0x10) << 18);
+
+            V128 v0 = MakeVectorE0E1(roundKeyL ^ valueL, roundKeyH ^ valueH);
+            V128 v1 = MakeVectorE0E1(roundKeyL, roundKeyH);
+
+            ExecutionContext context = SingleOpcode(opcode, v0: v0, v1: v1, runUnicorn: false);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(GetVectorE0(context.GetV(0)), Is.EqualTo(resultL));
+                Assert.That(GetVectorE1(context.GetV(0)), Is.EqualTo(resultH));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(GetVectorE0(context.GetV(1)), Is.EqualTo(roundKeyL));
+                Assert.That(GetVectorE1(context.GetV(1)), Is.EqualTo(roundKeyH));
+            });
+
+            // Unicorn does not yet support crypto instructions in A32.
+            // CompareAgainstUnicorn();
+        }
+
+        [Test, Description("AESE.8 <Qd>, <Qm>")]
+        public void Aese_V([Values(0u)] uint rd,
+                           [Values(2u)] uint rm,
+                           [Values(0x7B5B546573745665ul)] ulong valueH,
+                           [Values(0x63746F725D53475Dul)] ulong valueL,
+                           [Random(2)]                    ulong roundKeyH,
+                           [Random(2)]                    ulong roundKeyL,
+                           [Values(0x8F92A04DFBED204Dul)] ulong resultH,
+                           [Values(0x4C39B1402192A84Cul)] ulong resultL)
+        {
+            uint opcode = 0xf3b00300; // AESE.8 Q0, Q0
+            opcode |= ((rm & 0xf) << 0) | ((rm & 0x10) << 1);
+            opcode |= ((rd & 0xf) << 12) | ((rd & 0x10) << 18);
+
+            V128 v0 = MakeVectorE0E1(roundKeyL ^ valueL, roundKeyH ^ valueH);
+            V128 v1 = MakeVectorE0E1(roundKeyL, roundKeyH);
+
+            ExecutionContext context = SingleOpcode(opcode, v0: v0, v1: v1, runUnicorn: false);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(GetVectorE0(context.GetV(0)), Is.EqualTo(resultL));
+                Assert.That(GetVectorE1(context.GetV(0)), Is.EqualTo(resultH));
+            });
+            Assert.Multiple(() =>
+            {
+                Assert.That(GetVectorE0(context.GetV(1)), Is.EqualTo(roundKeyL));
+                Assert.That(GetVectorE1(context.GetV(1)), Is.EqualTo(roundKeyH));
+            });
+
+            // Unicorn does not yet support crypto instructions in A32.
+            // CompareAgainstUnicorn();
+        }
+
+        [Test, Description("AESIMC.8 <Qd>, <Qm>")]
+        public void Aesimc_V([Values(0u)]     uint rd,
+                             [Values(2u, 0u)] uint rm,
+                             [Values(0x8DCAB9DC035006BCul)] ulong valueH,
+                             [Values(0x8F57161E00CAFD8Dul)] ulong valueL,
+                             [Values(0xD635A667928B5EAEul)] ulong resultH,
+                             [Values(0xEEC9CC3BC55F5777ul)] ulong resultL)
+        {
+            uint opcode = 0xf3b003c0; // AESIMC.8 Q0, Q0
+            opcode |= ((rm & 0xf) << 0) | ((rm & 0x10) << 1);
+            opcode |= ((rd & 0xf) << 12) | ((rd & 0x10) << 18);
+
+            V128 v = MakeVectorE0E1(valueL, valueH);
+
+            ExecutionContext context = SingleOpcode(
+                opcode,
+                v0: rm == 0u ? v : default(V128),
+                v1: rm == 2u ? v : default(V128),
+                runUnicorn: false);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(GetVectorE0(context.GetV(0)), Is.EqualTo(resultL));
+                Assert.That(GetVectorE1(context.GetV(0)), Is.EqualTo(resultH));
+            });
+            if (rm == 2u)
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(GetVectorE0(context.GetV(1)), Is.EqualTo(valueL));
+                    Assert.That(GetVectorE1(context.GetV(1)), Is.EqualTo(valueH));
+                });
+            }
+
+            // Unicorn does not yet support crypto instructions in A32.
+            // CompareAgainstUnicorn();
+        }
+
+        [Test, Description("AESMC.8 <Qd>, <Qm>")]
+        public void Aesmc_V([Values(0u)]     uint rd,
+                            [Values(2u, 0u)] uint rm,
+                            [Values(0x627A6F6644B109C8ul)] ulong valueH,
+                            [Values(0x2B18330A81C3B3E5ul)] ulong valueL,
+                            [Values(0x7B5B546573745665ul)] ulong resultH,
+                            [Values(0x63746F725D53475Dul)] ulong resultL)
+        {
+            uint opcode = 0xf3b00380; // AESMC.8 Q0, Q0
+            opcode |= ((rm & 0xf) << 0) | ((rm & 0x10) << 1);
+            opcode |= ((rd & 0xf) << 12) | ((rd & 0x10) << 18);
+
+            V128 v = MakeVectorE0E1(valueL, valueH);
+
+            ExecutionContext context = SingleOpcode(
+                opcode,
+                v0: rm == 0u ? v : default(V128),
+                v1: rm == 2u ? v : default(V128),
+                runUnicorn: false);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(GetVectorE0(context.GetV(0)), Is.EqualTo(resultL));
+                Assert.That(GetVectorE1(context.GetV(0)), Is.EqualTo(resultH));
+            });
+            if (rm == 2u)
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(GetVectorE0(context.GetV(1)), Is.EqualTo(valueL));
+                    Assert.That(GetVectorE1(context.GetV(1)), Is.EqualTo(valueH));
+                });
+            }
+
+            // Unicorn does not yet support crypto instructions in A32.
+            // CompareAgainstUnicorn();
+        }
+    }
+}
diff --git a/Ryujinx.Tests/Cpu/CpuTestSimdLogical32.cs b/Ryujinx.Tests/Cpu/CpuTestSimdLogical32.cs
index 459127de..b6c05b10 100644
--- a/Ryujinx.Tests/Cpu/CpuTestSimdLogical32.cs
+++ b/Ryujinx.Tests/Cpu/CpuTestSimdLogical32.cs
@@ -12,14 +12,16 @@ namespace Ryujinx.Tests.Cpu
 #if SimdLogical32
 
 #region "ValueSource (Opcodes)"
-        private static uint[] _Vbif_Vbit_Vbsl_Vand_()
+        private static uint[] _Vbif_Vbit_Vbsl_Vand_Vorr_Veor_()
         {
             return new uint[]
             {
                 0xf3300110u, // VBIF D0, D0, D0
                 0xf3200110u, // VBIT D0, D0, D0
                 0xf3100110u, // VBSL D0, D0, D0
-                0xf2000110u  // VAND D0, D0, D0
+                0xf2000110u, // VAND D0, D0, D0
+                0xf2200110u, // VORR D0, D0, D0
+                0xf3000110u  // VEOR D0, D0, D0
             };
         }
  #endregion
@@ -27,14 +29,14 @@ namespace Ryujinx.Tests.Cpu
         private const int RndCnt = 2;
 
         [Test, Pairwise]
-        public void Vbif_Vbit_Vbsl_Vand([ValueSource("_Vbif_Vbit_Vbsl_Vand_")] uint opcode,
-                                        [Range(0u, 4u)] uint rd,
-                                        [Range(0u, 4u)] uint rn,
-                                        [Range(0u, 4u)] uint rm,
-                                        [Random(RndCnt)] ulong z,
-                                        [Random(RndCnt)] ulong a,
-                                        [Random(RndCnt)] ulong b,
-                                        [Values] bool q)
+        public void Vbif_Vbit_Vbsl_Vand_Vorr_Veor([ValueSource("_Vbif_Vbit_Vbsl_Vand_Vorr_Veor_")] uint opcode,
+                                                  [Range(0u, 4u)] uint rd,
+                                                  [Range(0u, 4u)] uint rn,
+                                                  [Range(0u, 4u)] uint rm,
+                                                  [Random(RndCnt)] ulong z,
+                                                  [Random(RndCnt)] ulong a,
+                                                  [Random(RndCnt)] ulong b,
+                                                  [Values] bool q)
         {
             if (q)
             {