1 files changed, 30 insertions, 41 deletions
diff --git a/ARMeilleure/CodeGen/X86/X86Optimizer.cs b/ARMeilleure/CodeGen/X86/X86Optimizer.cs
index fa8b54e8..ed040e15 100644
--- a/ARMeilleure/CodeGen/X86/X86Optimizer.cs
+++ b/ARMeilleure/CodeGen/X86/X86Optimizer.cs
@@ -2,9 +2,8 @@
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.Translation;
 using System.Collections.Generic;
-
-using static ARMeilleure.IntermediateRepresentation.OperandHelper;
-using static ARMeilleure.IntermediateRepresentation.OperationHelper;
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+using static ARMeilleure.IntermediateRepresentation.Operation.Factory;
 
 namespace ARMeilleure.CodeGen.X86
 {
@@ -34,32 +33,27 @@ namespace ARMeilleure.CodeGen.X86
             {
                 constants.Clear();
 
-                Node nextNode;
+                Operation nextNode;
 
-                for (Node node = block.Operations.First; node != null; node = nextNode)
+                for (Operation node = block.Operations.First; node != default; node = nextNode)
                 {
                     nextNode = node.ListNext;
 
-                    if (!(node is Operation operation))
-                    {
-                        continue;
-                    }
-
                     // Insert copies for constants that can't fit on a 32-bits immediate.
                     // Doing this early unblocks a few optimizations.
-                    if (operation.Instruction == Instruction.Add)
+                    if (node.Instruction == Instruction.Add)
                     {
-                        Operand src1 = operation.GetSource(0);
-                        Operand src2 = operation.GetSource(1);
+                        Operand src1 = node.GetSource(0);
+                        Operand src2 = node.GetSource(1);
 
                         if (src1.Kind == OperandKind.Constant && (src1.Relocatable || CodeGenCommon.IsLongConst(src1)))
                         {
-                            operation.SetSource(0, GetConstantCopy(block, operation, src1));
+                            node.SetSource(0, GetConstantCopy(block, node, src1));
                         }
 
                         if (src2.Kind == OperandKind.Constant && (src2.Relocatable || CodeGenCommon.IsLongConst(src2)))
                         {
-                            operation.SetSource(1, GetConstantCopy(block, operation, src2));
+                            node.SetSource(1, GetConstantCopy(block, node, src2));
                         }
                     }
 
@@ -70,24 +64,24 @@ namespace ARMeilleure.CodeGen.X86
                     //  mov rax, [rax]
                     // Into:
                     //  mov rax, [rax+rbx*4+0xcafe]
-                    if (IsMemoryLoadOrStore(operation.Instruction))
+                    if (IsMemoryLoadOrStore(node.Instruction))
                     {
                         OperandType type;
 
-                        if (operation.Destination != null)
+                        if (node.Destination != default)
                         {
-                            type = operation.Destination.Type;
+                            type = node.Destination.Type;
                         }
                         else
                         {
-                            type = operation.GetSource(1).Type;
+                            type = node.GetSource(1).Type;
                         }
 
-                        MemoryOperand memOp = GetMemoryOperandOrNull(operation.GetSource(0), type);
+                        Operand memOp = GetMemoryOperandOrNull(node.GetSource(0), type);
 
-                        if (memOp != null)
+                        if (memOp != default)
                         {
-                            operation.SetSource(0, memOp);
+                            node.SetSource(0, memOp);
                         }
                     }
                 }
@@ -96,7 +90,7 @@ namespace ARMeilleure.CodeGen.X86
             Optimizer.RemoveUnusedNodes(cfg);
         }
 
-        private static MemoryOperand GetMemoryOperandOrNull(Operand addr, OperandType type)
+        private static Operand GetMemoryOperandOrNull(Operand addr, OperandType type)
         {
             Operand baseOp = addr;
 
@@ -117,10 +111,10 @@ namespace ARMeilleure.CodeGen.X86
             // If baseOp is still equal to address, then there's nothing that can be optimized.
             if (baseOp == addr)
             {
-                return null;
+                return default;
             }
 
-            if (imm == 0 && scale == Multiplier.x1 && indexOp != null)
+            if (imm == 0 && scale == Multiplier.x1 && indexOp != default)
             {
                 imm = GetConstOp(ref indexOp);
             }
@@ -132,7 +126,7 @@ namespace ARMeilleure.CodeGen.X86
         {
             Operation operation = GetAsgOpWithInst(baseOp, Instruction.Add);
 
-            if (operation == null)
+            if (operation == default)
             {
                 return 0;
             }
@@ -172,13 +166,13 @@ namespace ARMeilleure.CodeGen.X86
 
         private static (Operand, Multiplier) GetIndexOp(ref Operand baseOp)
         {
-            Operand indexOp = null;
+            Operand indexOp = default;
 
             Multiplier scale = Multiplier.x1;
 
             Operation addOp = GetAsgOpWithInst(baseOp, Instruction.Add);
 
-            if (addOp == null)
+            if (addOp == default)
             {
                 return (indexOp, scale);
             }
@@ -198,14 +192,14 @@ namespace ARMeilleure.CodeGen.X86
 
             bool indexOnSrc2 = false;
 
-            if (shlOp == null)
+            if (shlOp == default)
             {
                 shlOp = GetAsgOpWithInst(src2, Instruction.ShiftLeft);
 
                 indexOnSrc2 = true;
             }
 
-            if (shlOp != null)
+            if (shlOp != default)
             {
                 Operand shSrc = shlOp.GetSource(0);
                 Operand shift = shlOp.GetSource(1);
@@ -233,24 +227,19 @@ namespace ARMeilleure.CodeGen.X86
             // If we have multiple assignments, folding is not safe
             // as the value may be different depending on the
             // control flow path.
-            if (op.Assignments.Count != 1)
+            if (op.AssignmentsCount != 1)
             {
-                return null;
+                return default;
             }
 
-            Node asgOp = op.Assignments[0];
-
-            if (!(asgOp is Operation operation))
-            {
-                return null;
-            }
+            Operation asgOp = op.Assignments[0];
 
-            if (operation.Instruction != inst)
+            if (asgOp.Instruction != inst)
             {
-                return null;
+                return default;
             }
 
-            return operation;
+            return asgOp;
         }
 
         private static bool IsMemoryLoadOrStore(Instruction inst)