Ryujinx.Tests: Add unicorn to test framework (#389)

* Ryujinx.Tests: Add unicorn to test framework

* CpuTestSimdArithmetic: Comment out inaccurate results

1 files changed, 130 insertions, 1 deletions

diff --git a/Ryujinx.Tests/Cpu/CpuTest.cs b/Ryujinx.Tests/Cpu/CpuTest.cs
index 4ac05f1b..6e013aa0 100644
--- a/Ryujinx.Tests/Cpu/CpuTest.cs
+++ b/Ryujinx.Tests/Cpu/CpuTest.cs
@@ -4,6 +4,8 @@ using ChocolArm64.State;
 
 using NUnit.Framework;
 
+using Ryujinx.Tests.Unicorn;
+
 using System;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -25,10 +27,22 @@ namespace Ryujinx.Tests.Cpu
         private AMemory Memory;
         private AThread Thread;
 
+        private static bool UnicornAvailable;
+        private UnicornAArch64 UnicornEmu;
+
+        static CpuTest()
+        {
+            UnicornAvailable = UnicornAArch64.IsAvailable();
+            if (!UnicornAvailable)
+            {
+                Console.WriteLine("WARNING: Could not find unicorn");
+            }
+        }
+
         [SetUp]
         public void Setup()
         {
-            Position = 0x0;
+            Position = 0x1000;
             Size = 0x1000;
 
             EntryPoint = Position;
@@ -38,6 +52,13 @@ namespace Ryujinx.Tests.Cpu
             Memory = new AMemory(RamPointer);
             Memory.Map(Position, 0, Size);
             Thread = new AThread(Translator, Memory, EntryPoint);
+
+            if (UnicornAvailable)
+            {
+                UnicornEmu = new UnicornAArch64();
+                UnicornEmu.MemoryMap((ulong)Position, (ulong)Size, MemoryPermission.READ | MemoryPermission.EXEC);
+                UnicornEmu.PC = (ulong)EntryPoint;
+            }
         }
 
         [TearDown]
@@ -46,6 +67,7 @@ namespace Ryujinx.Tests.Cpu
             Marshal.FreeHGlobal(RamPointer);
             Memory = null;
             Thread = null;
+            UnicornEmu = null;
         }
 
         protected void Reset()
@@ -57,6 +79,10 @@ namespace Ryujinx.Tests.Cpu
         protected void Opcode(uint Opcode)
         {
             Thread.Memory.WriteUInt32(Position, Opcode);
+            if (UnicornAvailable)
+            {
+                UnicornEmu.MemoryWrite32((ulong)Position, Opcode);
+            }
             Position += 4;
         }
 
@@ -81,6 +107,24 @@ namespace Ryujinx.Tests.Cpu
             Thread.ThreadState.Negative = Negative;
             Thread.ThreadState.Fpcr = Fpcr;
             Thread.ThreadState.Fpsr = Fpsr;
+
+            if (UnicornAvailable)
+            {
+                UnicornEmu.X[0] = X0;
+                UnicornEmu.X[1] = X1;
+                UnicornEmu.X[2] = X2;
+                UnicornEmu.X[3] = X3;
+                UnicornEmu.SP = X31;
+                UnicornEmu.Q[0] = V0;
+                UnicornEmu.Q[1] = V1;
+                UnicornEmu.Q[2] = V2;
+                UnicornEmu.OverflowFlag = Overflow;
+                UnicornEmu.CarryFlag = Carry;
+                UnicornEmu.ZeroFlag = Zero;
+                UnicornEmu.NegativeFlag = Negative;
+                UnicornEmu.Fpcr = Fpcr;
+                UnicornEmu.Fpsr = Fpsr;
+            }
         }
 
         protected void ExecuteOpcodes()
@@ -93,6 +137,11 @@ namespace Ryujinx.Tests.Cpu
                 Thread.Execute();
                 Wait.WaitOne();
             }
+
+            if (UnicornAvailable)
+            {
+                UnicornEmu.RunForCount((ulong)(Position - EntryPoint - 8) / 4);
+            }
         }
 
         protected AThreadState GetThreadState()
@@ -117,6 +166,86 @@ namespace Ryujinx.Tests.Cpu
             return GetThreadState();
         }
 
+        protected void CompareAgainstUnicorn()
+        {
+            if (!UnicornAvailable)
+            {
+                return;
+            }
+
+            Assert.That(Thread.ThreadState.X0, Is.EqualTo(UnicornEmu.X[0]));
+            Assert.That(Thread.ThreadState.X1, Is.EqualTo(UnicornEmu.X[1]));
+            Assert.That(Thread.ThreadState.X2, Is.EqualTo(UnicornEmu.X[2]));
+            Assert.That(Thread.ThreadState.X3, Is.EqualTo(UnicornEmu.X[3]));
+            Assert.That(Thread.ThreadState.X4, Is.EqualTo(UnicornEmu.X[4]));
+            Assert.That(Thread.ThreadState.X5, Is.EqualTo(UnicornEmu.X[5]));
+            Assert.That(Thread.ThreadState.X6, Is.EqualTo(UnicornEmu.X[6]));
+            Assert.That(Thread.ThreadState.X7, Is.EqualTo(UnicornEmu.X[7]));
+            Assert.That(Thread.ThreadState.X8, Is.EqualTo(UnicornEmu.X[8]));
+            Assert.That(Thread.ThreadState.X9, Is.EqualTo(UnicornEmu.X[9]));
+            Assert.That(Thread.ThreadState.X10, Is.EqualTo(UnicornEmu.X[10]));
+            Assert.That(Thread.ThreadState.X11, Is.EqualTo(UnicornEmu.X[11]));
+            Assert.That(Thread.ThreadState.X12, Is.EqualTo(UnicornEmu.X[12]));
+            Assert.That(Thread.ThreadState.X13, Is.EqualTo(UnicornEmu.X[13]));
+            Assert.That(Thread.ThreadState.X14, Is.EqualTo(UnicornEmu.X[14]));
+            Assert.That(Thread.ThreadState.X15, Is.EqualTo(UnicornEmu.X[15]));
+            Assert.That(Thread.ThreadState.X16, Is.EqualTo(UnicornEmu.X[16]));
+            Assert.That(Thread.ThreadState.X17, Is.EqualTo(UnicornEmu.X[17]));
+            Assert.That(Thread.ThreadState.X18, Is.EqualTo(UnicornEmu.X[18]));
+            Assert.That(Thread.ThreadState.X19, Is.EqualTo(UnicornEmu.X[19]));
+            Assert.That(Thread.ThreadState.X20, Is.EqualTo(UnicornEmu.X[20]));
+            Assert.That(Thread.ThreadState.X21, Is.EqualTo(UnicornEmu.X[21]));
+            Assert.That(Thread.ThreadState.X22, Is.EqualTo(UnicornEmu.X[22]));
+            Assert.That(Thread.ThreadState.X23, Is.EqualTo(UnicornEmu.X[23]));
+            Assert.That(Thread.ThreadState.X24, Is.EqualTo(UnicornEmu.X[24]));
+            Assert.That(Thread.ThreadState.X25, Is.EqualTo(UnicornEmu.X[25]));
+            Assert.That(Thread.ThreadState.X26, Is.EqualTo(UnicornEmu.X[26]));
+            Assert.That(Thread.ThreadState.X27, Is.EqualTo(UnicornEmu.X[27]));
+            Assert.That(Thread.ThreadState.X28, Is.EqualTo(UnicornEmu.X[28]));
+            Assert.That(Thread.ThreadState.X29, Is.EqualTo(UnicornEmu.X[29]));
+            Assert.That(Thread.ThreadState.X30, Is.EqualTo(UnicornEmu.X[30]));
+            Assert.That(Thread.ThreadState.X31, Is.EqualTo(UnicornEmu.SP));
+            Assert.That(Thread.ThreadState.V0, Is.EqualTo(UnicornEmu.Q[0]));
+            Assert.That(Thread.ThreadState.V1, Is.EqualTo(UnicornEmu.Q[1]));
+            Assert.That(Thread.ThreadState.V2, Is.EqualTo(UnicornEmu.Q[2]));
+            Assert.That(Thread.ThreadState.V3, Is.EqualTo(UnicornEmu.Q[3]));
+            Assert.That(Thread.ThreadState.V4, Is.EqualTo(UnicornEmu.Q[4]));
+            Assert.That(Thread.ThreadState.V5, Is.EqualTo(UnicornEmu.Q[5]));
+            Assert.That(Thread.ThreadState.V6, Is.EqualTo(UnicornEmu.Q[6]));
+            Assert.That(Thread.ThreadState.V7, Is.EqualTo(UnicornEmu.Q[7]));
+            Assert.That(Thread.ThreadState.V8, Is.EqualTo(UnicornEmu.Q[8]));
+            Assert.That(Thread.ThreadState.V9, Is.EqualTo(UnicornEmu.Q[9]));
+            Assert.That(Thread.ThreadState.V10, Is.EqualTo(UnicornEmu.Q[10]));
+            Assert.That(Thread.ThreadState.V11, Is.EqualTo(UnicornEmu.Q[11]));
+            Assert.That(Thread.ThreadState.V12, Is.EqualTo(UnicornEmu.Q[12]));
+            Assert.That(Thread.ThreadState.V13, Is.EqualTo(UnicornEmu.Q[13]));
+            Assert.That(Thread.ThreadState.V14, Is.EqualTo(UnicornEmu.Q[14]));
+            Assert.That(Thread.ThreadState.V15, Is.EqualTo(UnicornEmu.Q[15]));
+            Assert.That(Thread.ThreadState.V16, Is.EqualTo(UnicornEmu.Q[16]));
+            Assert.That(Thread.ThreadState.V17, Is.EqualTo(UnicornEmu.Q[17]));
+            Assert.That(Thread.ThreadState.V18, Is.EqualTo(UnicornEmu.Q[18]));
+            Assert.That(Thread.ThreadState.V19, Is.EqualTo(UnicornEmu.Q[19]));
+            Assert.That(Thread.ThreadState.V20, Is.EqualTo(UnicornEmu.Q[20]));
+            Assert.That(Thread.ThreadState.V21, Is.EqualTo(UnicornEmu.Q[21]));
+            Assert.That(Thread.ThreadState.V22, Is.EqualTo(UnicornEmu.Q[22]));
+            Assert.That(Thread.ThreadState.V23, Is.EqualTo(UnicornEmu.Q[23]));
+            Assert.That(Thread.ThreadState.V24, Is.EqualTo(UnicornEmu.Q[24]));
+            Assert.That(Thread.ThreadState.V25, Is.EqualTo(UnicornEmu.Q[25]));
+            Assert.That(Thread.ThreadState.V26, Is.EqualTo(UnicornEmu.Q[26]));
+            Assert.That(Thread.ThreadState.V27, Is.EqualTo(UnicornEmu.Q[27]));
+            Assert.That(Thread.ThreadState.V28, Is.EqualTo(UnicornEmu.Q[28]));
+            Assert.That(Thread.ThreadState.V29, Is.EqualTo(UnicornEmu.Q[29]));
+            Assert.That(Thread.ThreadState.V30, Is.EqualTo(UnicornEmu.Q[30]));
+            Assert.That(Thread.ThreadState.V31, Is.EqualTo(UnicornEmu.Q[31]));
+            Assert.That(Thread.ThreadState.V31, Is.EqualTo(UnicornEmu.Q[31]));
+            Assert.That(Thread.ThreadState.Fpcr, Is.EqualTo(UnicornEmu.Fpcr));
+            Assert.That(Thread.ThreadState.Fpsr & 0x08000000, Is.EqualTo(UnicornEmu.Fpsr & 0x08000000));
+            Assert.That(Thread.ThreadState.Overflow, Is.EqualTo(UnicornEmu.OverflowFlag));
+            Assert.That(Thread.ThreadState.Carry, Is.EqualTo(UnicornEmu.CarryFlag));
+            Assert.That(Thread.ThreadState.Zero, Is.EqualTo(UnicornEmu.ZeroFlag));
+            Assert.That(Thread.ThreadState.Negative, Is.EqualTo(UnicornEmu.NegativeFlag));
+        }
+
         protected static Vector128<float> MakeVectorE0(double E0)
         {
             if (!Sse2.IsSupported)