Finish off Ssa

ILCompiler/Compiler/BasicBlock.cs

@@ -44,21 +44,5 @@ public BasicBlock(int offset)
             StartOffset = offset;
             Label = LabelGenerator.GetLabel(LabelType.BasicBlock);
         }
-
-        public void InsertStatementAtStart(StackEntry statement)
-        {
-            var currentFirst = FirstNode;
-            FirstNode = statement;
-
-            var lastNodeInStatement = statement;
-            while (lastNodeInStatement.Next != null)
-            {
-                lastNodeInStatement = lastNodeInStatement.Next;
-            }
-
-            lastNodeInStatement.Next = currentFirst;
-
-            Statements.Insert(0, statement);
-        }
     }
 }

ILCompiler/Compiler/EvaluationStack/GenericStackEntryAdapter.cs

@@ -33,5 +33,6 @@ public GenericStackEntryAdapter(IGenericStackEntryVisitor genericVisitor)
         public void Visit(StaticFieldEntry entry) => _genericStackEntryVisitor.Visit<StaticFieldEntry>(entry);
         public void Visit(CommaEntry entry) => _genericStackEntryVisitor.Visit<CommaEntry>(entry);
         public void Visit(PhiNode entry) => _genericStackEntryVisitor.Visit<PhiNode>(entry);
+        public void Visit(PhiArg entry) => _genericStackEntryVisitor.Visit<PhiArg>(entry);
     }
 }

ILCompiler/Compiler/EvaluationStack/IStackEntryVisitor.cs

@@ -32,5 +32,6 @@ public interface IStackEntryVisitor
         public void Visit(StaticFieldEntry entry);
         public void Visit(CommaEntry entry);
         public void Visit(PhiNode entry);
+        public void Visit(PhiArg entry);
     }
 }

ILCompiler/Compiler/EvaluationStack/LocalVariableEntry.cs

@@ -3,7 +3,7 @@
     public class LocalVariableEntry : StackEntry, ILocalVariable
     {
         public int LocalNumber { get; }
-        public int SsaNumber { get; }
+        public int SsaNumber { get; set; }
         public LocalVariableEntry(int localNumber, VarType type, int? exactSize) : base(type, exactSize)
         {
             LocalNumber = localNumber;

ILCompiler/Compiler/EvaluationStack/PhiArg.cs

@@ -0,0 +1,26 @@
+namespace ILCompiler.Compiler.EvaluationStack
+{
+    public class PhiArg : StackEntry, ILocalVariable
+    {
+        public int LocalNumber { get; }
+        public int SsaNumber { get; }
+        public BasicBlock Block { get; }
+
+        public PhiArg(VarType type, int localNumber, int ssaNumber, BasicBlock block) : base(type)
+        {
+            LocalNumber = localNumber;
+            SsaNumber = ssaNumber;
+            Block = block;
+        }
+
+        public override StackEntry Duplicate()
+        {
+            return new PhiArg(Type, LocalNumber, SsaNumber, Block);
+        }
+
+        public override void Accept(IStackEntryVisitor visitor)
+        {
+            visitor.Visit(this);
+        }
+    }
+}

ILCompiler/Compiler/EvaluationStack/PhiNode.cs

@@ -2,13 +2,21 @@
 {
     public class PhiNode : StackEntry
     {
+        public IList<PhiArg> Arguments { get; }
+
         public PhiNode(VarType type) : base(type)
         {
+            Arguments = new List<PhiArg>();
+        }
+
+        public PhiNode(VarType type, IList<PhiArg> arguments) : base(type)
+        {
+            Arguments = arguments;
         }
 
         public override StackEntry Duplicate()
         {
-            return new PhiNode(Type);
+            return new PhiNode(Type, Arguments);
         }
 
         public override void Accept(IStackEntryVisitor visitor)

ILCompiler/Compiler/EvaluationStack/StackEntry.cs

@@ -39,6 +39,8 @@ public abstract class StackEntry : IVisitableStackEntry
         public int? ExactSize { get; }
 
         public StackEntry? Next { get; set; }
+        public StackEntry? Prev { get; set; }
+
         public int TreeID { get; }
 
         private static int _treeID = 0;

ILCompiler/Compiler/EvaluationStack/StoreLocalVariableEntry.cs

@@ -5,7 +5,7 @@ public class StoreLocalVariableEntry : StackEntry, ILocalVariable
         public StackEntry Op1 { get; }
 
         public int LocalNumber { get; }
-        public int SsaNumber { get; }
+        public int SsaNumber { get; set; }
 
         public bool IsParameter { get; }
 

ILCompiler/Compiler/Flowgraph.cs

@@ -196,11 +196,17 @@ public void Visit(PhiNode entry)
             SetNext(entry);
         }
 
+        public void Visit(PhiArg entry)
+        {
+            SetNext(entry);
+        }
+
         private void SetNext(StackEntry entry)
         {
             if (Current != null)
             {
                 Current.Next = entry;
+                entry.Prev = Current;
             }
             Current = entry;
             if (First == null)

ILCompiler/Compiler/Importer/AddressOfVarImporter.cs

@@ -12,7 +12,9 @@ public bool Import(Instruction instruction, ImportContext context, IILImporterPr
             {
                 case Code.Ldloca:
                 case Code.Ldloca_S:
-                    importer.PushExpression(new LocalVariableAddressEntry(importer.ParameterCount + (instruction.OperandAs<Local>()).Index));
+                    var localNumber = importer.ParameterCount + (instruction.OperandAs<Local>()).Index;
+                    importer.PushExpression(new LocalVariableAddressEntry(localNumber));
+                    importer.LocalVariableTable[localNumber].AddressExposed = true;
                     return true;
                 default:
                     return false;

ILCompiler/Compiler/Importer/LoadArgAddressImporter.cs

@@ -14,9 +14,11 @@ public bool Import(Instruction instruction, ImportContext context, IILImporterPr
                 case Code.Ldarga:
                 case Code.Ldarga_S:
                     var index = (instruction.OperandAs<Parameter>()).Index;
-                    var lclNum = MapIlArgNum(index, importer.ReturnBufferArgIndex);
+                    var localNumber = MapIlArgNum(index, importer.ReturnBufferArgIndex);
 
-                    importer.PushExpression(new LocalVariableAddressEntry(lclNum));
+                    importer.PushExpression(new LocalVariableAddressEntry(localNumber));
+
+                    importer.LocalVariableTable[localNumber].AddressExposed = true;
 
                     return true;
 

ILCompiler/Compiler/LIRDumper.cs

@@ -99,7 +99,22 @@ public void Visit(StoreLocalVariableEntry entry)
 
         public void Visit(PhiNode entry)
         {
-            _sb.AppendLine($"       phi");
+            var firstArg = true;
+            foreach (var argument in entry.Arguments)
+            {
+                _sb.Append("       ");
+                _sb.Append(firstArg ? "┌──▌" : "├──▌");
+                _sb.Append("  ");
+                _sb.AppendLine($"t{argument.TreeID}");
+                firstArg = false;
+            }
+
+            _sb.AppendLine($"t{entry.TreeID,-3} = phi");
+        }
+
+        public void Visit(PhiArg entry)
+        {
+            _sb.AppendLine($"t{entry.TreeID,-3} = phiarg {entry.Type} V{entry.LocalNumber:00} ssa{entry.SsaNumber}");
         }
 
         public void Visit(CallEntry entry)

ILCompiler/Compiler/LocalVariableDescriptor.cs

@@ -1,4 +1,5 @@
-using ILCompiler.Common.TypeSystem.IL;
+using ILCompiler.Compiler.Lowerings;
+using ILCompiler.Compiler.Ssa;
 
 namespace ILCompiler.Compiler
 {
@@ -17,5 +18,14 @@ public class LocalVariableDescriptor
         public string Name = string.Empty;
 
         public bool MustInit { get; set; } = false;
+        public bool Tracked { get; set; } = false;
+
+        public bool AddressExposed { get; set; } = false;
+
+        public bool InSsa { get; set; } = false;
+
+        public SsaDefList<LocalSsaVariableDescriptor> PerSsaData { get; set; } = new SsaDefList<LocalSsaVariableDescriptor>();
+
+        public LocalSsaVariableDescriptor GetPerSsaData(int ssaNumber) => PerSsaData.SsaDefinition(ssaNumber);
     }
-}
+}

ILCompiler/Compiler/MethodCompiler.cs

@@ -151,7 +151,7 @@ public void CompileMethod(Z80MethodCodeNode methodCodeNodeNeedingCode)
             flowgraph.SetBlockOrder(basicBlocks);
 
             var ssaBuilder = _phaseFactory.Create<ISsaBuilder>();
-            ssaBuilder.Build(basicBlocks, _localVariableTable);
+            ssaBuilder.Build(basicBlocks, _localVariableTable, _configuration.DumpSsa);
 
             if (_configuration.DumpIRTrees)
             {

ILCompiler/Compiler/Rationalizer.cs

@@ -1,5 +1,6 @@
 using ILCompiler.Compiler.EvaluationStack;
 using ILCompiler.Interfaces;
+using System.Diagnostics;
 
 namespace ILCompiler.Compiler
 {
@@ -34,15 +35,29 @@ private static void RemoveCommaNodes(BasicBlock block)
 
         private static void RemovePhiNodes(BasicBlock block)
         {
-            var statement = block.Statements[0];
-            while (statement is PhiNode)
+            var node = block.FirstNode;
+            while (node is PhiArg || node is PhiNode)
             {
-                // Remove PhiNode statement
-                var nextStatement = statement.Next?.Next;
-                block.Statements.RemoveAt(0);
-                block.FirstNode = nextStatement;
+                // Remove PhiArgs
+                while (node is PhiArg)
+                {
+                    node = node.Next;
+                }
+
+                // Remove PhiNode and StoreLocalVariableEntry
+                Debug.Assert(node is PhiNode);
+                node = node.Next;
+                Debug.Assert(node is StoreLocalVariableEntry);
+                node = node.Next;
 
-                statement = nextStatement;
+                // Remove statement
+                block.Statements.RemoveAt(0);
+            }
+
+            block.FirstNode = node;
+            if (node != null)
+            {
+                node.Prev = null;
             }
         }
     }

ILCompiler/Compiler/Ssa/DominatorTreeNode.cs

@@ -1,6 +1,5 @@
 namespace ILCompiler.Compiler.Ssa
 {
-    // TODO: Will need ability to do a pre order traversal of this tree
     internal sealed class DominatorTreeNode
     {
         public BasicBlock Block { get; private set; }

ILCompiler/Compiler/Ssa/DominatorTreeVisitor.cs

@@ -0,0 +1,34 @@
+namespace ILCompiler.Compiler.Ssa
+{
+    internal class DominatorTreeVisitor
+    {
+        readonly DominatorTreeNode _root;
+        public DominatorTreeVisitor(DominatorTreeNode root)
+        {
+            _root = root;
+        }
+
+        public virtual void PreOrderVisit(BasicBlock block)
+        {
+
+        }
+
+        public virtual void PostOrderVisit(BasicBlock block)
+        {
+        }
+
+        public void WalkTree() => WalkTree(_root);
+
+        private void WalkTree(DominatorTreeNode node)
+        {
+            PreOrderVisit(node.Block);
+
+            foreach (var child in node.Children)
+            {
+                WalkTree(child);
+            }
+
+            PostOrderVisit(node.Block);
+        }
+    }
+}

ILCompiler/Compiler/Ssa/LocalSsaVariableDescriptor.cs

@@ -0,0 +1,33 @@
+namespace ILCompiler.Compiler.Ssa
+{
+    public class LocalSsaVariableDescriptor
+    {
+        public BasicBlock Block { get; set; }
+
+        public bool HasGlobalUse { get; private set; } = false;
+        public bool HasPhiUse { get; private set; } = false;
+
+        public int NumberOfUses { get; private set; } = 0;
+
+        public LocalSsaVariableDescriptor(BasicBlock block)
+        {
+            Block = block;
+        }
+
+        public void AddUse(BasicBlock block)
+        {
+            if (block != Block)
+            {
+                HasGlobalUse = true;
+            }
+
+            NumberOfUses++;
+        }
+
+        public void AddPhiUse(BasicBlock block)
+        {
+            HasPhiUse = true;
+            AddUse(block);
+        }
+    }
+}

ILCompiler/Compiler/Ssa/SsaDefList.cs

@@ -0,0 +1,33 @@
+namespace ILCompiler.Compiler.Ssa
+{
+    // A resizable array of Ssa Definitions
+    public class SsaDefList<T>
+    {
+        readonly IList<T> _list = new List<T>();
+
+        static int MinSsaNumber { get; } = 1;
+
+        public int AllocSsaNumber(Func<T> ctor)
+        {
+            var ssaNumber = SsaDefList<T>.MinSsaNumber + _list.Count;
+            _list.Add(ctor());
+
+            return ssaNumber;
+        }
+
+        public int Count { get { return _list.Count; } }
+
+        public T SsaDefinitionByIndex(int index) => _list[index];
+
+        public bool IsValidSsaNumber(int ssaNumber) => MinSsaNumber <= ssaNumber && (ssaNumber < (MinSsaNumber + _list.Count));
+
+        public T SsaDefinition(int ssaNumber) => SsaDefinitionByIndex(ssaNumber - MinSsaNumber);
+
+        public int GetSsaNumber(T ssaDefinition)
+        {
+            var index = _list.IndexOf(ssaDefinition);
+            if (index == - 1) throw new ArgumentException($"Invalid ssaDefinition {ssaDefinition}.", nameof(ssaDefinition));
+            return index + MinSsaNumber;
+        }
+    }
+}