Issue #14

Added OptimizationPassBase to make possible implementing optimizations without Result. Changed InFunctionLoweringVars to use this base class as a model.
ciplogic · Feb 8, 2015 · b55aedf · b55aedf
1 parent cdd5e11
commit b55aedf
Show file tree

Hide file tree

Showing 10 changed files with 62 additions and 41 deletions.
diff --git a/Common/CodeRefractor.RuntimeBase/Backend/ComputeClosure/MethodInterpreterCodeWriter.cs b/Common/CodeRefractor.RuntimeBase/Backend/ComputeClosure/MethodInterpreterCodeWriter.cs
@@ -44,8 +44,7 @@ public static string WriteDelegateCallCode(MethodInterpreter interpreter)
             return interpreter.WriteDelegateCallCode();
         }
 
-        public static bool ApplyLocalOptimizations(IEnumerable<ResultingOptimizationPass> optimizationPasses,
-            CilMethodInterpreter interpreter)
+        public static bool ApplyLocalOptimizations(IEnumerable<ResultingOptimizationPass> optimizationPasses, CilMethodInterpreter interpreter, ClosureEntities entities)
         {
             if (optimizationPasses == null)
                 return false;
@@ -54,17 +53,14 @@ public static bool ApplyLocalOptimizations(IEnumerable<ResultingOptimizationPass
             var result = false;
             var optimizationsList = new List<ResultingOptimizationPass>(optimizationPasses);
             var areOptimizationsAvailable = true;
-            if (interpreter.Method.Name == "pollEvents")
-            {
-            }
             while (areOptimizationsAvailable)
             {
                 interpreter.MidRepresentation.UpdateUseDef();
                 areOptimizationsAvailable = false;
                 foreach (var optimizationPass in optimizationsList)
                 {
                     var optimizationName = optimizationPass.GetType().Name;
-                    if (!optimizationPass.CheckPreconditions(interpreter))
+                    if (!optimizationPass.CheckPreconditions(interpreter, entities))
                         continue;
                     areOptimizationsAvailable = optimizationPass.Optimize(interpreter);
 

diff --git a/Common/CodeRefractor.RuntimeBase/ClosureCompute/ClosureEntities.cs b/Common/CodeRefractor.RuntimeBase/ClosureCompute/ClosureEntities.cs
@@ -168,7 +168,7 @@ public bool AddType(Type type)
             return true;
         }
 
-        public void OptimizeClosure()
+        public void OptimizeClosure(ClosureEntities entities)
         {
             var level = new OptimizationLevels();
 
@@ -190,7 +190,7 @@ public void OptimizeClosure()
 
                 foreach (var cilMethod in cilMethods)
                 {
-                    isOptimizationPossible |= MethodInterpreterCodeWriter.ApplyLocalOptimizations(optimizations, cilMethod);
+                    isOptimizationPossible |= MethodInterpreterCodeWriter.ApplyLocalOptimizations(optimizations, cilMethod, entities);
                 }
 
                 var programWideOptimizationsAvailable = ApplyProgramWideOptimizations();

diff --git a/Common/CodeRefractor.RuntimeBase/ClosureCompute/ClosureEntitiesUtils.cs b/Common/CodeRefractor.RuntimeBase/ClosureCompute/ClosureEntitiesUtils.cs
@@ -33,7 +33,7 @@ public ClosureEntities BuildClosureEntities(MethodInfo definition, Assembly runt
             closureEntities.EntitiesBuilder.AddTypeResolver(new ResolveRuntimeType(runtimeAssembly));
 
             closureEntities.ComputeFullClosure();
-            closureEntities.OptimizeClosure();
+            closureEntities.OptimizeClosure(closureEntities);
 
             return closureEntities;
         }

diff --git a/Common/CodeRefractor.RuntimeBase/CodeRefractor.Compiler.Internals.csproj b/Common/CodeRefractor.RuntimeBase/CodeRefractor.Compiler.Internals.csproj
@@ -127,6 +127,7 @@
     <Compile Include="MiddleEnd\Interpreters\NonCil\CppMethodInterpreter.cs" />
     <Compile Include="MiddleEnd\Interpreters\NonCil\PlatformInvokeMethod.cs" />
     <Compile Include="Backend\ProgramWideOptimizations\Virtual\DevirtualizeWholeClosureMethods.cs" />
+    <Compile Include="MiddleEnd\Optimizations\Common\OptimizationPassBase.cs" />
     <Compile Include="MiddleEnd\Optimizations\SimpleDce\DeleteUnusedNewObjectOperations.cs" />
     <Compile Include="MiddleEnd\UseDefs\UseDefDescription.cs" />
     <Compile Include="MiddleEnd\UseDefs\UseDefHelper.cs" />

diff --git a/Common/CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/Common/OptimizationPassBase.cs b/Common/CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/Common/OptimizationPassBase.cs
@@ -0,0 +1,22 @@
+using CodeRefractor.ClosureCompute;
+using CodeRefractor.MiddleEnd.Interpreters.Cil;
+using CodeRefractor.RuntimeBase.Optimizations;
+
+namespace CodeRefractor.MiddleEnd.Optimizations.Common
+{
+    public abstract class OptimizationPassBase
+    {
+        public abstract bool ApplyOptimization(CilMethodInterpreter intermediateCode, ClosureEntities closure);
+
+        public virtual bool CheckPreconditions(CilMethodInterpreter midRepresentation, ClosureEntities closure)
+        {
+            return true;
+        }
+        public OptimizationKind Kind { get; set; }
+        protected OptimizationPassBase(OptimizationKind kind)
+        {
+            Kind = kind;
+        }
+
+    }
+}
diff --git a/Common/CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/Common/ResultingOptimizationPass.cs b/Common/CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/Common/ResultingOptimizationPass.cs
@@ -8,35 +8,26 @@
 
 namespace CodeRefractor.MiddleEnd.Optimizations.Common
 {
-    public abstract class ResultingOptimizationPass
+    public abstract class ResultingOptimizationPass : OptimizationPassBase
     {
         //returns true if it succeed to apply any optimizations
         //Try to return false by default
         //If the code succeeded to optimize something that other optimizations may benefit, return true
 
         public static ClosureEntities Closure { get; set; }
-        protected ResultingOptimizationPass(OptimizationKind kind)
+        protected ResultingOptimizationPass(OptimizationKind kind) 
+            : base(kind)
         {
-            Kind = kind;
         }
 
         public bool Result { get; set; }
 
         public abstract void OptimizeOperations(CilMethodInterpreter interpreter);
 
-
-
-
-        public OptimizationKind Kind { get; set; }
-
-        public virtual bool CheckPreconditions(CilMethodInterpreter midRepresentation)
-        {
-            return true;
-        }
          //returns true if it succeed to apply any optimizations
         //Try to return false by default
         //If the code succeeded to optimize something that other optimizations may benefit, return true
-        public  bool Optimize(CilMethodInterpreter intermediateCode)
+        public bool Optimize(CilMethodInterpreter intermediateCode)
         {
             Result = false;
             try
@@ -48,5 +39,10 @@ public  bool Optimize(CilMethodInterpreter intermediateCode)
             }
             return Result;
         }
+
+        public override bool ApplyOptimization(CilMethodInterpreter intermediateCode, ClosureEntities closure)
+        {
+            return Optimize(intermediateCode);
+        }
     }
 }
diff --git a/...Refractor.RuntimeBase/MiddleEnd/Optimizations/EscapeAndLowering/InFunctionLoweringVars.cs b/...Refractor.RuntimeBase/MiddleEnd/Optimizations/EscapeAndLowering/InFunctionLoweringVars.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using CodeRefractor.ClosureCompute;
 using CodeRefractor.CodeWriter.Linker;
 using CodeRefractor.FrontEnd.SimpleOperations;
 using CodeRefractor.FrontEnd.SimpleOperations.Identifiers;
@@ -22,24 +23,25 @@
 namespace CodeRefractor.MiddleEnd.Optimizations.EscapeAndLowering
 {
     [Optimization(Category = OptimizationCategories.Analysis)]
-    internal class InFunctionLoweringVars : ResultingInFunctionOptimizationPass
+    internal class InFunctionLoweringVars : OptimizationPassBase
     {
-        public override void OptimizeOperations(CilMethodInterpreter interpreter)
+        public InFunctionLoweringVars()
+            : base(OptimizationKind.InFunction)
         {
-            var candidateVariables = SetAllCandidateVariables(interpreter);
+        }
+
+        public override bool ApplyOptimization(CilMethodInterpreter interpreter, ClosureEntities closure)
+        {
+            var candidateVariables = SetAllCandidateVariables(interpreter, closure);
             var useDef = interpreter.MidRepresentation.UseDef;
             var localOp = useDef.GetLocalOperations();
 
-            if (interpreter.Method.Name == "Concat")
-            {
-
-            }
             if (RemoveAllEscaping(candidateVariables, localOp, useDef))
-                return;
+                return false;
 
 
             if (candidateVariables.Count == 0)
-                return;
+                return false;
             foreach (var variable in candidateVariables)
             {
                 var getVariableData = interpreter.AnalyzeProperties.GetVariableData(variable);
@@ -49,6 +51,7 @@ public override void OptimizeOperations(CilMethodInterpreter interpreter)
                 }
             }
             AllocateVariablesOnStack(localOp, candidateVariables, interpreter);
+            return true;
         }
 
         private static bool RemoveAllEscaping(HashSet<LocalVariable> candidateVariables, LocalOperation[] localOp,
@@ -74,22 +77,21 @@ private static bool RemoveAllEscaping(HashSet<LocalVariable> candidateVariables,
             return false;
         }
 
-        private static HashSet<LocalVariable> SetAllCandidateVariables(CilMethodInterpreter interpreter)
+        private static HashSet<LocalVariable> SetAllCandidateVariables(CilMethodInterpreter interpreter, ClosureEntities closure)
         {
             var candidateVariables = new HashSet<LocalVariable>();
             var midRepresentation = interpreter.MidRepresentation;
             var variables = midRepresentation.Vars;
-            var toAdd = variables.LocalVars.Where(varId => !varId.ComputedType().GetClrType(Closure).IsPrimitive);
+            var toAdd = variables.LocalVars.Where(varId => !varId.ComputedType().GetClrType(closure).IsPrimitive);
             candidateVariables.AddRange(toAdd);
-            toAdd = variables.VirtRegs.Where(varId => !varId.ComputedType().GetClrType(Closure).IsPrimitive);
+            toAdd = variables.VirtRegs.Where(varId => !varId.ComputedType().GetClrType(closure).IsPrimitive);
             candidateVariables.AddRange(toAdd);
-            toAdd = interpreter.AnalyzeProperties.Arguments.Where(varId => !varId.ComputedType().GetClrType(Closure).IsPrimitive);
+            toAdd = interpreter.AnalyzeProperties.Arguments.Where(varId => !varId.ComputedType().GetClrType(closure).IsPrimitive);
             candidateVariables.AddRange(toAdd);
             return candidateVariables;
         }
 
-        private static void AllocateVariablesOnStack(LocalOperation[] localOp, HashSet<LocalVariable> candidateVariables,
-            MethodInterpreter interpreter)
+        private static void AllocateVariablesOnStack(LocalOperation[] localOp, HashSet<LocalVariable> candidateVariables, MethodInterpreter interpreter)
         {
             var newOps = localOp.Where(op =>
                 op.Kind == OperationKind.NewArray
@@ -106,7 +108,7 @@ private static void AllocateVariablesOnStack(LocalOperation[] localOp, HashSet<L
                 var variableData = interpreter.AnalyzeProperties.GetVariableData(variable);
                 if (variableData != EscapingMode.Stack)
                 {
-                    interpreter.AnalyzeProperties.SetVariableData(variable, EscapingMode.Stack);
+                    interpreter.AnalyzeProperties.SetVariableData(variable, EscapingMode.Stack);               
                 }
             }
         }
@@ -238,5 +240,6 @@ private static void HandleSetField(HashSet<LocalVariable> candidateVariables, Lo
                 candidateVariables.Remove(right);
             }
         }
+
     }
 }
diff --git a/Common/CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/Licm/LoopInvariantCodeMotion.cs b/Common/CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/Licm/LoopInvariantCodeMotion.cs
@@ -1,6 +1,7 @@
 #region Usings
 
 using System.Collections.Generic;
+using CodeRefractor.ClosureCompute;
 using CodeRefractor.FrontEnd.SimpleOperations;
 using CodeRefractor.MiddleEnd.Interpreters.Cil;
 using CodeRefractor.MiddleEnd.Optimizations.Common;
@@ -18,7 +19,7 @@ namespace CodeRefractor.MiddleEnd.Optimizations.Licm
     [Optimization(Category = OptimizationCategories.CommonSubexpressionsElimination)]
     internal class LoopInvariantCodeMotion : ResultingGlobalOptimizationPass
     {
-        public override bool CheckPreconditions(CilMethodInterpreter midRepresentation)
+        public override bool CheckPreconditions(CilMethodInterpreter midRepresentation, ClosureEntities entities)
         {
             var loopStarts = LoopDetection.FindLoops(midRepresentation.MidRepresentation);
             return loopStarts.Count != 0;

diff --git a/...ractor.RuntimeBase/MiddleEnd/Optimizations/Purity/EvaluatePureFunctionWithConstantCall.cs b/...ractor.RuntimeBase/MiddleEnd/Optimizations/Purity/EvaluatePureFunctionWithConstantCall.cs
@@ -1,6 +1,7 @@
 #region Usings
 
 using System.Collections.Generic;
+using CodeRefractor.ClosureCompute;
 using CodeRefractor.CodeWriter.Linker;
 using CodeRefractor.FrontEnd.SimpleOperations;
 using CodeRefractor.FrontEnd.SimpleOperations.Identifiers;
@@ -19,7 +20,7 @@ namespace CodeRefractor.MiddleEnd.Optimizations.Purity
 	[Optimization(Category = OptimizationCategories.Purity)]
     internal class EvaluatePureFunctionWithConstantCall : ResultingGlobalOptimizationPass
     {
-        public override bool CheckPreconditions(CilMethodInterpreter midRepresentation)
+        public override bool CheckPreconditions(CilMethodInterpreter midRepresentation, ClosureEntities entities)
         {
             var operations = midRepresentation.MidRepresentation.UseDef;
 

diff --git a/.../CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/SimpleDce/AssignToReturnPropagation.cs b/.../CodeRefractor.RuntimeBase/MiddleEnd/Optimizations/SimpleDce/AssignToReturnPropagation.cs
@@ -1,5 +1,6 @@
 #region Usings
 
+using CodeRefractor.ClosureCompute;
 using CodeRefractor.FrontEnd.SimpleOperations.Methods;
 using CodeRefractor.MiddleEnd.Interpreters.Cil;
 using CodeRefractor.MiddleEnd.Optimizations.Common;
@@ -23,7 +24,7 @@ namespace CodeRefractor.MiddleEnd.Optimizations.SimpleDce
 	[Optimization(Category = OptimizationCategories.DeadCodeElimination)]
     internal class AssignToReturnPropagation : ResultingInFunctionOptimizationPass
     {
-        public override bool CheckPreconditions(CilMethodInterpreter midRepresentation)
+        public override bool CheckPreconditions(CilMethodInterpreter midRepresentation, ClosureEntities entities)
         {
             var localOperations = midRepresentation.MidRepresentation.UseDef.GetLocalOperations();
             return localOperations.Length >= 2;