1 files changed, 91 insertions, 29 deletions
diff --git a/ARMeilleure/IntermediateRepresentation/BasicBlock.cs b/ARMeilleure/IntermediateRepresentation/BasicBlock.cs
index 056a9d46..7cee52e5 100644
--- a/ARMeilleure/IntermediateRepresentation/BasicBlock.cs
+++ b/ARMeilleure/IntermediateRepresentation/BasicBlock.cs
@@ -1,37 +1,47 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 
 namespace ARMeilleure.IntermediateRepresentation
 {
-    class BasicBlock : IIntrusiveListNode<BasicBlock>
+    class BasicBlock : IEquatable<BasicBlock>, IIntrusiveListNode<BasicBlock>
     {
-        private readonly List<BasicBlock> _successors;
+        private const uint MaxSuccessors = 2;
 
-        public int Index { get; set; }
+        private int _succCount;
+        private BasicBlock _succ0;
+        private BasicBlock _succ1;
+        private HashSet<BasicBlock> _domFrontiers;
 
+        public int Index { get; set; }
         public BasicBlockFrequency Frequency { get; set; }
-
         public BasicBlock ListPrevious { get; set; }
         public BasicBlock ListNext { get; set; }
-
-        public IntrusiveList<Node> Operations { get; }
-
+        public IntrusiveList<Operation> Operations { get; }
         public List<BasicBlock> Predecessors { get; }
-
-        public HashSet<BasicBlock> DominanceFrontiers { get; }
         public BasicBlock ImmediateDominator { get; set; }
 
-        public int SuccessorCount => _successors.Count;
+        public int SuccessorsCount => _succCount;
+
+        public HashSet<BasicBlock> DominanceFrontiers
+        {
+            get
+            {
+                if (_domFrontiers == null)
+                {
+                    _domFrontiers = new HashSet<BasicBlock>();
+                }
+
+                return _domFrontiers;
+            }
+        }
 
         public BasicBlock() : this(index: -1) { }
 
         public BasicBlock(int index)
         {
-            _successors = new List<BasicBlock>();
-
-            Operations = new IntrusiveList<Node>();
+            Operations = new IntrusiveList<Operation>();
             Predecessors = new List<BasicBlock>();
-            DominanceFrontiers = new HashSet<BasicBlock>();
 
             Index = index;
         }
@@ -40,54 +50,92 @@ namespace ARMeilleure.IntermediateRepresentation
         {
             if (block == null)
             {
-                throw new ArgumentNullException(nameof(block));
+                ThrowNull(nameof(block));
+            }
+
+            if ((uint)_succCount + 1 > MaxSuccessors)
+            {
+                ThrowSuccessorOverflow();
             }
 
             block.Predecessors.Add(this);
 
-            _successors.Add(block);
+            GetSuccessorUnsafe(_succCount++) = block;
         }
 
         public void RemoveSuccessor(int index)
         {
-            BasicBlock oldBlock = _successors[index];
+            if ((uint)index >= (uint)_succCount)
+            {
+                ThrowOutOfRange(nameof(index));
+            }
+
+            ref BasicBlock oldBlock = ref GetSuccessorUnsafe(index);
 
             oldBlock.Predecessors.Remove(this);
+            oldBlock = null;
+
+            if (index == 0)
+            {
+                _succ0 = _succ1;
+            }
 
-            _successors.RemoveAt(index);
+            _succCount--;
         }
 
         public BasicBlock GetSuccessor(int index)
         {
-            return _successors[index];
+            if ((uint)index >= (uint)_succCount)
+            {
+                ThrowOutOfRange(nameof(index));
+            }
+
+            return GetSuccessorUnsafe(index);
+        }
+
+        private ref BasicBlock GetSuccessorUnsafe(int index)
+        {
+            return ref Unsafe.Add(ref _succ0, index);
         }
 
         public void SetSuccessor(int index, BasicBlock block)
         {
             if (block == null)
             {
-                throw new ArgumentNullException(nameof(block));
+                ThrowNull(nameof(block));
             }
 
-            BasicBlock oldBlock = _successors[index];
+            if ((uint)index >= (uint)_succCount)
+            {
+                ThrowOutOfRange(nameof(index));
+            }
+
+            ref BasicBlock oldBlock = ref GetSuccessorUnsafe(index);
 
             oldBlock.Predecessors.Remove(this);
             block.Predecessors.Add(this);
-
-            _successors[index] = block;
+            
+            oldBlock = block;
         }
 
-        public void Append(Node node)
+        public void Append(Operation node)
         {
-            var lastOp = Operations.Last as Operation;
+            Operation last = Operations.Last;
 
             // Append node before terminal or to end if no terminal.
-            switch (lastOp?.Instruction)
+            if (last == default)
+            {
+                Operations.AddLast(node);
+
+                return;
+            }
+
+            switch (last.Instruction)
             {
                 case Instruction.Return:
                 case Instruction.Tailcall:
                 case Instruction.BranchIf:
-                    Operations.AddBefore(lastOp, node);
+                    Operations.AddBefore(last, node);
                     break;
 
                 default:
@@ -96,9 +144,23 @@ namespace ARMeilleure.IntermediateRepresentation
             }
         }
 
-        public Node GetLastOp()
+        private static void ThrowNull(string name) => throw new ArgumentNullException(name);
+        private static void ThrowOutOfRange(string name) => throw new ArgumentOutOfRangeException(name);
+        private static void ThrowSuccessorOverflow() => throw new OverflowException($"BasicBlock can only have {MaxSuccessors} successors.");
+
+        public bool Equals(BasicBlock other)
+        {
+            return other == this;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as BasicBlock);
+        }
+
+        public override int GetHashCode()
         {
-            return Operations.Last;
+            return base.GetHashCode();
         }
     }
 }
 \ No newline at end of file