Add new pass to restructure the conditional checks for loops. This saves an unconditional jump from the loop's end by repeating the conditional check at that point and conditionally jumping to the start of the loop body instead of unconditionally to the loop header. For safety, this pass occurs before the SSA conversion.

Author: DBooots

src/kOS.Safe.Test/Execution/OptimizationTest.cs

@@ -939,5 +939,44 @@ public void TestIfElseIfElseDetection()
                 Where(b => Safe.Compilation.Optimization.Passes.BlockOrdering.IdentifyBranch(b, null, out _)).Count());
         }
         #endregion
+
+        #region Loop Condition Reordering
+        [Test]
+        public void TestUntilLoopCondition()
+        {
+            optimizationLevel = OptimizationLevel.Balanced;
+            List<CodePart> _code = CompileCodePart("integration/branching/until.ks");
+            optimizationLevel = OptimizationLevel.Minimal;
+            List<Safe.Compilation.Opcode> opcodes = _code[0].MainCode;
+            Assert.AreEqual(opcodes[4].ToString(), opcodes[10].ToString());
+            Assert.IsInstanceOf(typeof(OpcodeBranchIfTrue), opcodes[5]);
+            Assert.IsInstanceOf(typeof(OpcodeBranchIfFalse), opcodes[11]);
+        }
+        [Test]
+        public void TestForLoopCondition()
+        {
+            optimizationLevel = OptimizationLevel.Balanced;
+            List<CodePart> _code = CompileCodePart("integration/branching/for.ks");
+            optimizationLevel = OptimizationLevel.Minimal;
+            List<Safe.Compilation.Opcode> opcodes = _code[0].MainCode;
+            Assert.AreEqual(opcodes[8].ToString(), opcodes[15].ToString());
+            Assert.AreEqual(opcodes[9].ToString(), opcodes[16].ToString());
+            Assert.IsInstanceOf(typeof(OpcodeBranchIfFalse), opcodes[10]);
+            Assert.IsInstanceOf(typeof(OpcodeBranchIfTrue), opcodes[17]);
+        }
+        [Test]
+        public void TestFromLoopCondition()
+        {
+            optimizationLevel = OptimizationLevel.Balanced;
+            List<CodePart> _code = CompileCodePart("integration/branching/from.ks");
+            optimizationLevel = OptimizationLevel.Minimal;
+            List<Safe.Compilation.Opcode> opcodes = _code[0].MainCode;
+            Assert.AreEqual(opcodes[7].ToString(), opcodes[19].ToString());
+            Assert.AreEqual(opcodes[8].ToString(), opcodes[20].ToString());
+            Assert.AreEqual(opcodes[9].ToString(), opcodes[21].ToString());
+            Assert.IsInstanceOf(typeof(OpcodeBranchIfTrue), opcodes[10]);
+            Assert.IsInstanceOf(typeof(OpcodeBranchIfFalse), opcodes[22]);
+        }
+        #endregion
     }
 }

src/kOS.Safe/Compilation/Optimization/OptimizationLevel.cs

@@ -26,6 +26,7 @@ namespace kOS.Safe.Compilation
      *  32767. Block ordering to minimize unconditional jumps.
      *  
      * O2:
+     * -10000. Loop condition reorganization
      *  1000. Common expression elimination
      *          Particularly: Any expression of 3 opcodes used more than twice,
      *          or any expression of >3 opcodes used more than once

src/kOS.Safe/Compilation/Optimization/Passes/BlockOrdering.cs

@@ -106,7 +106,9 @@ private static MetaBlockSequence ConstructMetaSequence(BasicBlock root, Stack<Ba
                         newOffshoots.Enqueue(child);
                     block = loopData.exit;
                 }
-                else if (IdentifyBranch(block, regionExits.Peek(), out BranchData branchData))
+                else if (IdentifyBranch(block, regionExits.Peek(), out BranchData branchData) &&
+                    !((branchData.ifBlock?.Dominator != null && branchData.ifBlock.Dominator != block) ||
+                    (branchData.elseBlock?.Dominator != null && branchData.elseBlock.Dominator != block)))
                 {
                     sequence.Add(ConstructMetaSequence(branchData.ifBlock, regionExits, out Queue<BasicBlock> childOffshoots));
                     foreach (BasicBlock child in childOffshoots)
@@ -197,6 +199,7 @@ private static BasicBlock GetSequenceEnd(BasicBlock block)
         }
         private static bool BackEdgeDetection(BasicBlock successor, BasicBlock target)
         {
+            BasicBlock firstSuccessor = successor;
             if (successor.Dominator != target)
                 return false;
 
@@ -207,7 +210,7 @@ private static bool BackEdgeDetection(BasicBlock successor, BasicBlock target)
                     return true;
             }
 
-            return successor.Successors.Contains(target);
+            return successor.Successors.Contains(target) || successor.Successors.Contains(firstSuccessor);
         }
         private static BasicBlock FindLocalMerge(BasicBlock ifBlock, BasicBlock regionExit)
         {

src/kOS.Safe/Compilation/Optimization/Passes/LoopConditionalRelocation.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using kOS.Safe.Compilation.IR;
+
+namespace kOS.Safe.Compilation.Optimization.Passes
+{
+    public class LoopConditionalRelocation : IHolisticOptimizationPass
+    {
+        public OptimizationLevel OptimizationLevel => OptimizationLevel.Balanced;
+
+        public short SortIndex => -10000;
+
+        public void ApplyPass(IRCodePart codePart)
+        {
+            foreach (IRCodePart.IRFunction function in codePart.Functions)
+                foreach (IRCodePart.IRFunction.IRFunctionFragment fragment in function.Fragments)
+                    ApplyPass(fragment.FunctionCode[0]);
+            foreach (IRCodePart.IRTrigger trigger in codePart.Triggers)
+                ApplyPass(trigger.Code[0]);
+            ApplyPass(codePart.MainCode[0]);
+        }
+
+        private static void ApplyPass(BasicBlock root)
+        {
+            IEnumerable<BasicBlock> GetEdges(BasicBlock block)
+                => block.Successors.Where(BlockOrdering.InitialPredicate);
+
+            List<BasicBlock> reversePostOrder = BasicBlock.GetReversePostOrder(root, GetEdges);
+            Stack<BasicBlock> regionExits = new Stack<BasicBlock>();
+            regionExits.Push(reversePostOrder[reversePostOrder.Count - 1]);
+
+            List<BlockOrdering.LoopData> loopData = new List<BlockOrdering.LoopData>();
+
+            FindLoops(root, regionExits, loopData);
+
+            foreach (BlockOrdering.LoopData loop in loopData)
+            {
+                RelocateConditional(loop);
+            }
+        }
+
+        private static void RelocateConditional(BlockOrdering.LoopData loopData)
+        {
+            BasicBlock header = loopData.header;
+            BasicBlock block = loopData.body;
+            while (block.PostDominator?.Dominator == block)
+                block = block.PostDominator;
+
+            IRBranch newBranch = (IRBranch)header.Instructions[header.Instructions.Count - 1];
+            newBranch = newBranch.Clone(block);
+            newBranch.PreferFalse = !newBranch.PreferFalse;
+
+            block.Instructions[block.Instructions.Count - 1] = newBranch;
+            block.AddSuccessor(newBranch.True);
+            block.AddSuccessor(newBranch.False);
+            block.RemoveSuccessor(header);
+        }
+
+        private static void FindLoops(BasicBlock root, Stack<BasicBlock> regionExits, List<BlockOrdering.LoopData> loops)
+        {
+            BasicBlock block = root;
+            while (block != null && block != regionExits.Peek())
+            {
+                if (BlockOrdering.IdentifyLoop(block, regionExits.Peek(), out BlockOrdering.LoopData loopData))
+                {
+                    loops.Add(loopData);
+                    regionExits.Push(loopData.exit);
+                    FindLoops(loopData.body, regionExits, loops);
+                    regionExits.Pop();
+                    block = loopData.exit;
+                }
+                else if (BlockOrdering.IdentifyBranch(block, regionExits.Peek(), out BlockOrdering.BranchData branchData))
+                {
+                    FindLoops(branchData.ifBlock, regionExits, loops);
+                    if (branchData.exit == null && branchData.elseBlock != null)
+                    {
+                        block = branchData.elseBlock;
+                    }
+                    else
+                    {
+                        if (branchData.elseBlock != null)
+                            FindLoops(branchData.elseBlock, regionExits, loops);
+                        block = branchData.exit;
+                    }
+                }
+                else if (block.PostDominator?.Dominator == block)
+                {
+                    block = block.PostDominator;
+                }
+                else
+                    return;
+            }
+        }
+    }
+}