.

Users/Matthijs/DebugCompiler/MyEngine.cs

@@ -17,11 +17,12 @@ public void Test(Type kernelToRun)
             var xEngine = new Engine();
             // Sets the time before an error is registered. For example if set to 60 then if a kernel runs for more than 60 seconds then
             // that kernel will be marked as a failure and terminated
-            xEngine.AllowedSecondsInKernel = 600;
+            xEngine.AllowedSecondsInKernel = 15;
 
             // If you want to test only specific platforms, add them to the list, like next line. By default, all platforms are run.
             xEngine.RunTargets.Add(RunTargetEnum.Bochs);
-
+            //xEngine.StartBochsDebugGui = false;
+            //xEngine.RunWithGDB = true;
             // If you're working on the compiler (or other lower parts), you can choose to run the compiler in process
             // one thing to keep in mind though, is that this only works with 1 kernel at a time!
             xEngine.RunIL2CPUInProcess = false;

source/Cosmos.Assembler/Cosmos.Assembler.csproj

@@ -182,7 +182,7 @@
     <Compile Include="x86\SSE2\SqrtSD.cs" />
     <Compile Include="x86\SSE2\XorPD.cs" />
     <Compile Include="x86\SSE3\IntStoreWithTrunc.cs" />
-    <Compile Include="x86\SSE3\MoveDoubleAndDupplicate.cs" />
+    <Compile Include="x86\SSE3\MoveDoubleAndDuplicate.cs" />
     <Compile Include="x86\SSEAndMMX2\AddPS.cs" />
     <Compile Include="x86\SSEAndMMX2\AddSS.cs" />
     <Compile Include="x86\SSEAndMMX2\AndPS.cs" />

source/Cosmos.Assembler/x86/SSE3/MoveDoubleAndDuplicate.cs

@@ -0,0 +1,12 @@
+namespace Cosmos.Assembler.x86.SSE
+{
+	[Cosmos.Assembler.OpCode("MOVDDUP")]
+	public class MoveDoubleAndDuplicate : InstructionWithDestinationAndSource
+	{
+	}
+
+    [OpCode("MOVDDUP")]
+    public class MoveDoubleAndDupplicate: MoveDoubleAndDuplicate
+    {
+    }
+}

source/Cosmos.Core.Plugs/System/Assemblers/Array_InternalCopy.cs

@@ -1,4 +1,4 @@
-using Cosmos.IL2CPU.Plugs;
+using Cosmos.IL2CPU.Plugs;
 using XSharp.Compiler;
 using CPUx86 = Cosmos.Assembler.x86;
 
@@ -22,35 +22,35 @@ public class Array_InternalCopy : AssemblerMethod
         public override void AssembleNew(Assembler.Assembler aAssembler, object aMethodInfo)
         {
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: SourceArrayDisplacement);
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true }; // dereference memory handle to pointer
+            XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true); // dereference memory handle to pointer
             XS.Push(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX));
             new CPUx86.Add { DestinationReg = CPUx86.RegistersEnum.ESP, DestinationIsIndirect = true, SourceValue = 12, Size = 32 }; // pointer is at the element size
             XS.Pop(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX));
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true }; // element size
+            XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true); // element size
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: SourceIndexDisplacement);
             XS.Multiply(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBX));
             XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), 16);
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ESI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: SourceArrayDisplacement);
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.ESI, SourceReg = CPUx86.RegistersEnum.ESI, SourceIsIndirect = true }; // dereference memory handle to pointer
+            XS.Set(XSRegisters.ESI, XSRegisters.ESI, sourceIsIndirect: true); // dereference memory handle to pointer
             XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ESI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX)); // source ptr
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: DestinationArrayDisplacement);
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EDX, SourceReg = CPUx86.RegistersEnum.EDX, SourceIsIndirect = true }; // dereference memory handle to pointer
+            XS.Set(XSRegisters.EDX, XSRegisters.EDX, sourceIsIndirect: true); // dereference memory handle to pointer
             XS.Push(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX));
             new CPUx86.Add { DestinationReg = CPUx86.RegistersEnum.ESP, DestinationIsIndirect = true, SourceValue = 12, Size = 32 }; // pointer is at element size
             XS.Pop(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX));
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true }; // dereference handle to pointer
+            XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true); // dereference handle to pointer
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ECX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: DestinationIndexDisplacement);
             XS.Multiply(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ECX));
             XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), 16);
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: DestinationArrayDisplacement);
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EDI, SourceReg = CPUx86.RegistersEnum.EDI, SourceIsIndirect = true }; // dereference handle to pointer
+            XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceIsIndirect: true); // dereference handle to pointer
             XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX));
 
             // calculate byte count to copy
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: DestinationArrayDisplacement);
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true }; // dereference memory handle to pointer
+            XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true); // dereference memory handle to pointer
             XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), 12);
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true };
+            XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true);
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: LengthDisplacement);
             XS.Multiply(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX));
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ECX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX));

source/Cosmos.Core.Plugs/System/Assemblers/Array_get_Length.cs

@@ -1,4 +1,4 @@
-using Cosmos.Assembler.x86;
+using Cosmos.Assembler.x86;
 using Cosmos.IL2CPU.Plugs;
 using XSharp.Compiler;
 
@@ -10,7 +10,7 @@ public override void AssembleNew(Assembler.Assembler aAssembler, object aMethodI
         {
             // $this   ebp+8
             XS.Set(XSRegisters.OldToNewRegister(RegistersEnum.EAX), XSRegisters.OldToNewRegister(RegistersEnum.EBP), sourceDisplacement: 8);
-            new Mov { DestinationReg = RegistersEnum.EAX, SourceReg = RegistersEnum.EAX, SourceIsIndirect = true };
+            XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true);
             new Push { DestinationIsIndirect = true, DestinationReg = RegistersEnum.EAX, DestinationDisplacement = 8 };
         }
     }

source/Cosmos.Core.Plugs/System/Assemblers/InvokeImplAssembler.cs

@@ -48,17 +48,17 @@ public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object a
             XS.Pop(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX));
             ;//list
             XS.Comment("eax+=8 is where the offset where an array's count is");
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true };
+            XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true);
             XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), 8);//addrof list.Length
             XS.Comment("store count in ebx");
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EBX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true };//list.count
+            XS.Set(XSRegisters.EBX, XSRegisters.EAX, sourceIsIndirect: true);//list.count
             XS.Comment("eax+=8 is where the offset where an array's items start");
             XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), 8); // Put pointer at the first item in the list.
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), 0);
             XS.Comment("ecx = ptr to delegate object");
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ECX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));//addrof the delegate
             XS.Comment("ecx points to the size of the delegated methods arguments");
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.ECX, SourceReg = CPUx86.RegistersEnum.ECX, SourceIsIndirect = true };
+            XS.Set(XSRegisters.ECX, XSRegisters.ECX, sourceIsIndirect: true);
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ECX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ECX), sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "$$ArgSize$$"));//the size of the arguments to the method? + 12??? -- 12 is the size of the current call stack.. i think
             XS.Xor(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX));
             ;//make sure edx is 0
@@ -71,7 +71,7 @@ public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object a
                 XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ESI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ESP));
                 XS.Comment("edi = ptr to delegate object");
                 XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));
-                new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EDI, SourceReg = CPUx86.RegistersEnum.EDI, SourceIsIndirect = true }; // dereference handle
+                XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceIsIndirect: true); // dereference handle
                 XS.Comment("edi = ptr to delegate object should be a pointer to the delgates context ie (this) for the methods ");
                 XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target"));
                 XS.Compare(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), 0);
@@ -83,8 +83,8 @@ public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object a
                 XS.Comment("make space for us to copy the arguments too");
                 XS.Sub(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ESP), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.ECX));
                 XS.Comment("move the current delegate to edi");
-                new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EDI, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true };
-                new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EDI, SourceReg = CPUx86.RegistersEnum.EDI, SourceIsIndirect = true }; // dereference
+                XS.Set(XSRegisters.EDI, XSRegisters.EAX, sourceIsIndirect: true);
+                XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceIsIndirect: true); // dereference
                 XS.Comment("move the methodptr from that delegate to edi ");
                 XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.IntPtr System.Delegate._methodPtr"));//
                 XS.Comment("save methodptr on the stack");
@@ -109,7 +109,7 @@ public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object a
                 XS.Comment("edi = ptr to delegate object");
                 XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));
                 XS.Comment("edi = ptr to delegate object should be a pointer to the delgates context ie (this) for the methods ");
-                new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EDI, SourceReg = CPUx86.RegistersEnum.EDI, SourceIsIndirect = true }; // dereference handle
+                XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceIsIndirect: true); // dereference handle
                 XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDI), sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target"));//i really dont get the +12, MtW: that's for the object header
                 XS.Label(".noTHIStoPop");
                 new CPUx86.Popad();
@@ -120,7 +120,7 @@ public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object a
             XS.Label(".END_OF_INVOKE_");
             XS.Comment("get the return value");
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EBP), sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));//addrof the delegate
-            new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EDX, SourceReg = CPUx86.RegistersEnum.EDX, SourceIsIndirect = true }; // dereference handle
+            XS.Set(XSRegisters.EDX, XSRegisters.EDX, sourceIsIndirect: true); // dereference handle
             XS.Set(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX), XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX), sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "$$ReturnsValue$$"));
             XS.Compare(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EDX), 0);
             new CPUx86.ConditionalJump { Condition = CPUx86.ConditionalTestEnum.Equal, DestinationLabel = ".noReturn" };
@@ -179,7 +179,7 @@ public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object a
         //      new CPU.Comment("eax+=8 is where the offset where an array's count is");
         //      new CPUx86.Add { DestinationReg = CPUx86.Registers.EAX, SourceValue = 8 };//addrof list.count??
         //      new CPU.Comment("store count in ebx");
-        //      new CPUx86.Move { DestinationReg = CPUx86.Registers.EBX, SourceReg = CPUx86.Registers.EAX, SourceIsIndirect = true };//list.count
+        //      XS.Mov(XSRegisters.EBX, XSRegisters.EAX, sourceIsIndirect: true);//list.count
         //      new CPU.Comment("eax+=8 is where the offset where an array's items start");
         //      new CPUx86.Add { DestinationReg = CPUx86.Registers.EAX, SourceValue = 8 };//why? -- start of list i think? MtW: the array's .Length is at +8
         //      new CPUx86.Move { DestinationReg = CPUx86.Registers.EDI, SourceValue = 0 };
@@ -222,7 +222,7 @@ public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object a
         //      new CPU.Comment("make space for us to copy the arguments too");
         //      new CPUx86.Sub { DestinationReg = CPUx86.Registers.ESP, SourceReg = CPUx86.Registers.EBX };
         //      new CPU.Comment("move the current delegate to edi");
-        //      new CPUx86.Move { DestinationReg = CPUx86.Registers.EDI, SourceReg = CPUx86.Registers.EAX, SourceIsIndirect = true };
+        //      XS.Mov(XSRegisters.EDI, XSRegisters.EAX, sourceIsIndirect: true);
         //      new CPU.Comment("move the methodptr from that delegate to the stack ");
         //      new CPUx86.Pushad();
         //      Ldarg.DoExecute(xAssembler, xMethodInfo, 0);

source/Cosmos.IL2CPU/AppAssembler.cs

@@ -335,12 +335,7 @@ protected void MethodEnd(MethodInfo aMethod)
                 XS.Label(xMethodLabel + EndOfMethodLabelNameNormal);
 
                 XS.Comment("Following code is for debugging. Adjust accordingly!");
-                new Mov
-                {
-                    DestinationRef = ElementReference.New("static_field__Cosmos_Core_INTs_mLastKnownAddress"),
-                    DestinationIsIndirect = true,
-                    SourceRef = ElementReference.New(xMethodLabel + EndOfMethodLabelNameNormal)
-                };
+                XS.Set("static_field__Cosmos_Core_INTs_mLastKnownAddress", xMethodLabel + EndOfMethodLabelNameNormal, destinationIsIndirect: true);
             }
 
             XS.Set(OldToNewRegister(RegistersEnum.ECX), 0);

source/Cosmos.IL2CPU/IL/Mul_Ovf_Un.cs

@@ -61,24 +61,14 @@ public static void DoExecute(uint xStackContentSize, string aBaseLabel)
         XS.Set(XSRegisters.OldToNewRegister(RegistersEnum.ECX), XSRegisters.OldToNewRegister(RegistersEnum.EAX));
 
         //mov RIGHT_LOW to eax
-        new Mov
-          {
-            DestinationReg = RegistersEnum.EAX,
-            SourceReg = RegistersEnum.ESP,
-            SourceIsIndirect = true
-          };
+        XS.Set(XSRegisters.EAX, XSRegisters.ESP, sourceIsIndirect: true);
         // multiply with LEFT_HIGH
         XS.Multiply(XSRegisters.OldToNewRegister(RegistersEnum.ESP), displacement: 12);
         // add result of LEFT_LOW * RIGHT_HIGH + RIGHT_LOW + LEFT_HIGH
         XS.Add(XSRegisters.OldToNewRegister(RegistersEnum.ECX), XSRegisters.OldToNewRegister(RegistersEnum.EAX));
 
         //mov RIGHT_LOW to eax
-        new Mov
-          {
-            DestinationReg = RegistersEnum.EAX,
-            SourceReg = RegistersEnum.ESP,
-            SourceIsIndirect = true
-          };
+        XS.Set(XSRegisters.EAX, XSRegisters.ESP, sourceIsIndirect: true);
         // multiply with LEFT_LOW
         XS.Multiply(XSRegisters.OldToNewRegister(RegistersEnum.ESP), displacement: 8);
         // add LEFT_LOW * RIGHT_HIGH + RIGHT_LOW + LEFT_HIGH to high dword of last result
@@ -88,12 +78,7 @@ public static void DoExecute(uint xStackContentSize, string aBaseLabel)
 
         XS.Label(Simple32Multiply);
         //mov RIGHT_LOW to eax
-        new Mov
-          {
-            DestinationReg = RegistersEnum.EAX,
-            SourceReg = RegistersEnum.ESP,
-            SourceIsIndirect = true
-          };
+        XS.Set(XSRegisters.EAX, XSRegisters.ESP, sourceIsIndirect: true);
         // multiply with LEFT_LOW
         XS.Multiply(XSRegisters.OldToNewRegister(RegistersEnum.ESP), displacement: 8);
 

source/Cosmos.IL2CPU/IL/Newarr.cs

@@ -48,7 +48,7 @@ public override void Execute(MethodInfo aMethod, ILOpCode aOpCode)
       // it's on the stack 3 times now, once from the return value, twice from the pushes;
 
       XS.Pop(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX));
-      new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, SourceReg = CPUx86.RegistersEnum.EAX, SourceIsIndirect = true };
+      XS.Set(XSRegisters.EAX, XSRegisters.EAX, sourceIsIndirect: true);
       new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EBX, SourceRef = Cosmos.Assembler.ElementReference.New(xTypeID), SourceIsIndirect = true };
       new CPUx86.Mov { DestinationReg = CPUx86.RegistersEnum.EAX, DestinationIsIndirect = true, SourceReg = CPUx86.RegistersEnum.EBX };
       XS.Add(XSRegisters.OldToNewRegister(CPUx86.RegistersEnum.EAX), 4);